@formatjs/intl-pluralrules 6.1.1 → 6.2.0

package/abstract/GetOperands.d.ts

@@ -1,32 +1,59 @@
-import Decimal from 'decimal.js';
+import type Decimal from "decimal.js";
+/**
+* CLDR Spec: Operands as defined in https://unicode.org/reports/tr35/tr35-numbers.html#Operands
+* ECMA-402 Spec: GetOperands abstract operation (https://tc39.es/ecma402/#sec-getoperands)
+*
+* Maps CLDR operand symbols to JavaScript property names:
+* - n → Number (absolute value)
+* - i → IntegerDigits
+* - v → NumberOfFractionDigits
+* - w → NumberOfFractionDigitsWithoutTrailing
+* - f → FractionDigits
+* - t → FractionDigitsWithoutTrailing
+* - c, e → CompactExponent (extension for compact notation)
+*/
 export interface OperandsRecord {
-    /**
-     * Absolute value of the source number (integer and decimals)
-     */
-    Number: Decimal;
-    /**
-     * Number of digits of `number`
-     */
-    IntegerDigits: number;
-    /**
-     * Number of visible fraction digits in [[Number]], with trailing zeroes.
-     */
-    NumberOfFractionDigits: number;
-    /**
-     * Number of visible fraction digits in [[Number]], without trailing zeroes.
-     */
-    NumberOfFractionDigitsWithoutTrailing: number;
-    /**
-     * Number of visible fractional digits in [[Number]], with trailing zeroes.
-     */
-    FractionDigits: number;
-    /**
-     * Number of visible fractional digits in [[Number]], without trailing zeroes.
-     */
-    FractionDigitsWithoutTrailing: number;
+	/**
+	* CLDR operand: n (absolute value of the source number)
+	*/
+	Number: Decimal;
+	/**
+	* CLDR operand: i (integer digits of n)
+	* Implementation: String for very large numbers exceeding Number.MAX_SAFE_INTEGER
+	*/
+	IntegerDigits: number | string;
+	/**
+	* CLDR operand: v (number of visible fraction digits in n, with trailing zeros)
+	*/
+	NumberOfFractionDigits: number;
+	/**
+	* CLDR operand: w (number of visible fraction digits in n, without trailing zeros)
+	*/
+	NumberOfFractionDigitsWithoutTrailing: number;
+	/**
+	* CLDR operand: f (visible fractional digits in n, with trailing zeros)
+	*/
+	FractionDigits: number;
+	/**
+	* CLDR operand: t (visible fractional digits in n, without trailing zeros)
+	*/
+	FractionDigitsWithoutTrailing: number;
+	/**
+	* CLDR operands: c and e (synonyms for compact decimal exponent)
+	*
+	* Extension: Not in base ECMA-402 spec, but defined in CLDR for compact notation.
+	* Example: "1.2M" has exponent 6 (since M = 10^6)
+	* Used by 9 locales: ca, es, fr, it, lld, pt, pt-PT, scn, vec
+	*/
+	CompactExponent: number;
 }
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
- * @param s
- */
-export declare function GetOperands(s: string): OperandsRecord;
+* ECMA-402 Spec: GetOperands abstract operation
+* https://tc39.es/ecma402/#sec-getoperands
+*
+* Implementation: Extended to support compact exponent (c/e operands)
+*
+* @param s Formatted number string
+* @param exponent Compact decimal exponent (c/e operand), defaults to 0
+*/
+export declare function GetOperands(s: string, exponent?: number): OperandsRecord;

package/abstract/GetOperands.js

@@ -1,46 +1,50 @@
-import { invariant, ToNumber, ZERO } from '@formatjs/ecma402-abstract';
+import { invariant, ToNumber, ZERO } from "@formatjs/ecma402-abstract";
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
- * @param s
- */
-export function GetOperands(s) {
-    invariant(typeof s === 'string', "GetOperands should have been called with a string");
-    var n = ToNumber(s);
-    invariant(n.isFinite(), 'n should be finite');
-    var dp = s.indexOf('.');
-    var iv;
-    var f;
-    var v;
-    var fv = '';
-    if (dp === -1) {
-        iv = n;
-        f = ZERO;
-        v = 0;
-    }
-    else {
-        iv = s.slice(0, dp);
-        fv = s.slice(dp, s.length);
-        f = ToNumber(fv);
-        v = fv.length;
-    }
-    var i = ToNumber(iv).abs();
-    var w;
-    var t;
-    if (!f.isZero()) {
-        var ft = fv.replace(/0+$/, '');
-        w = ft.length;
-        t = ToNumber(ft);
-    }
-    else {
-        w = 0;
-        t = ZERO;
-    }
-    return {
-        Number: n,
-        IntegerDigits: i.toNumber(),
-        NumberOfFractionDigits: v,
-        NumberOfFractionDigitsWithoutTrailing: w,
-        FractionDigits: f.toNumber(),
-        FractionDigitsWithoutTrailing: t.toNumber(),
-    };
+* ECMA-402 Spec: GetOperands abstract operation
+* https://tc39.es/ecma402/#sec-getoperands
+*
+* Implementation: Extended to support compact exponent (c/e operands)
+*
+* @param s Formatted number string
+* @param exponent Compact decimal exponent (c/e operand), defaults to 0
+*/
+export function GetOperands(s, exponent = 0) {
+	invariant(typeof s === "string", `GetOperands should have been called with a string`);
+	const n = ToNumber(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;
+		v = 0;
+	} else {
+		iv = s.slice(0, dp);
+		fv = s.slice(dp, s.length);
+		f = ToNumber(fv);
+		v = fv.length;
+	}
+	const i = ToNumber(iv).abs();
+	let w;
+	let t;
+	if (!f.isZero()) {
+		const ft = fv.replace(/0+$/, "");
+		w = ft.length;
+		t = ToNumber(ft);
+	} else {
+		w = 0;
+		t = ZERO;
+	}
+	return {
+		Number: n,
+		IntegerDigits: i.lessThanOrEqualTo(Number.MAX_SAFE_INTEGER) && i.greaterThanOrEqualTo(-Number.MAX_SAFE_INTEGER) ? i.toNumber() : i.toString(),
+		NumberOfFractionDigits: v,
+		NumberOfFractionDigitsWithoutTrailing: w,
+		FractionDigits: f.toNumber(),
+		FractionDigitsWithoutTrailing: t.toNumber(),
+		CompactExponent: exponent
+	};
 }

package/abstract/InitializePluralRules.d.ts

@@ -1,8 +1,8 @@
-import { PluralRulesData, PluralRulesInternal } from '@formatjs/ecma402-abstract';
-export declare function InitializePluralRules(pl: Intl.PluralRules, locales: string | string[] | undefined, options: Intl.PluralRulesOptions | undefined, { availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, getInternalSlots, }: {
-    availableLocales: Set<string>;
-    relevantExtensionKeys: string[];
-    localeData: Record<string, PluralRulesData | undefined>;
-    getDefaultLocale(): string;
-    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+import { type PluralRulesData, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
+export declare function InitializePluralRules(pl: Intl.PluralRules, locales: string | string[] | undefined, options: Intl.PluralRulesOptions | undefined, { availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, getInternalSlots }: {
+	availableLocales: Set<string>;
+	relevantExtensionKeys: string[];
+	localeData: Record<string, PluralRulesData | undefined>;
+	getDefaultLocale(): string;
+	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
 }): Intl.PluralRules;

package/abstract/InitializePluralRules.js

@@ -1,17 +1,31 @@
-import { CanonicalizeLocaleList, CoerceOptionsToObject, GetOption, SetNumberFormatDigitOptions, } from '@formatjs/ecma402-abstract';
-import { ResolveLocale } from '@formatjs/intl-localematcher';
-export function InitializePluralRules(pl, locales, options, _a) {
-    var availableLocales = _a.availableLocales, relevantExtensionKeys = _a.relevantExtensionKeys, localeData = _a.localeData, getDefaultLocale = _a.getDefaultLocale, getInternalSlots = _a.getInternalSlots;
-    var requestedLocales = CanonicalizeLocaleList(locales);
-    var opt = Object.create(null);
-    var opts = CoerceOptionsToObject(options);
-    var internalSlots = getInternalSlots(pl);
-    internalSlots.initializedPluralRules = true;
-    var matcher = GetOption(opts, 'localeMatcher', 'string', ['best fit', 'lookup'], 'best fit');
-    opt.localeMatcher = matcher;
-    var r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
-    internalSlots.locale = r.locale;
-    internalSlots.type = GetOption(opts, 'type', 'string', ['cardinal', 'ordinal'], 'cardinal');
-    SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, 'standard');
-    return pl;
+import { CanonicalizeLocaleList, CoerceOptionsToObject, GetOption, SetNumberFormatDigitOptions } from "@formatjs/ecma402-abstract";
+import { ResolveLocale } from "@formatjs/intl-localematcher";
+export function InitializePluralRules(pl, locales, options, { availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, getInternalSlots }) {
+	const requestedLocales = CanonicalizeLocaleList(locales);
+	const opt = Object.create(null);
+	const opts = CoerceOptionsToObject(options);
+	const internalSlots = getInternalSlots(pl);
+	internalSlots.initializedPluralRules = true;
+	const matcher = GetOption(opts, "localeMatcher", "string", ["best fit", "lookup"], "best fit");
+	opt.localeMatcher = matcher;
+	const r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
+	internalSlots.locale = r.locale;
+	// ECMA-402 Spec: type option ('cardinal' or 'ordinal')
+	internalSlots.type = GetOption(opts, "type", "string", ["cardinal", "ordinal"], "cardinal");
+	// Extension: notation options for compact notation support
+	// Not in ECMA-402 spec, but mirrors Intl.NumberFormat notation option
+	// Enables proper plural selection for compact numbers (e.g., "1.2M")
+	const notation = GetOption(opts, "notation", "string", ["standard", "compact"], "standard");
+	internalSlots.notation = notation;
+	if (notation === "compact") {
+		// Extension: compactDisplay option (mirrors Intl.NumberFormat)
+		internalSlots.compactDisplay = GetOption(opts, "compactDisplay", "string", ["short", "long"], "short");
+		// Implementation: Load NumberFormat locale data if available (soft dependency)
+		// This is needed to calculate compact exponents using ComputeExponentForMagnitude
+		if (typeof Intl !== "undefined" && Intl.NumberFormat && Intl.NumberFormat.localeData) {
+			internalSlots.dataLocaleData = Intl.NumberFormat.localeData[r.locale];
+		}
+	}
+	SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, "standard");
+	return pl;
 }

package/abstract/ResolvePlural.d.ts

@@ -1,13 +1,43 @@
-import { LDMLPluralRule, PluralRulesInternal } from '@formatjs/ecma402-abstract';
-import Decimal from 'decimal.js';
-import { OperandsRecord } from './GetOperands.js';
+import { type LDMLPluralRule, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
+import Decimal from "decimal.js";
+import { type OperandsRecord } from "./GetOperands.js";
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
- * @param pl
- * @param n
- * @param PluralRuleSelect Has to pass in bc it's implementation-specific
- */
-export declare function ResolvePlural(pl: Intl.PluralRules, n: Decimal, { getInternalSlots, PluralRuleSelect, }: {
-    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
-    PluralRuleSelect: (locale: string, type: 'cardinal' | 'ordinal', n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
+* Result of ResolvePluralInternal containing both the formatted string and plural category.
+* This corresponds to a Record with [[FormattedString]] and [[PluralCategory]] fields
+* as described in the ECMA-402 spec for ResolvePluralRange.
+*/
+export interface ResolvePluralResult {
+	/** The formatted representation of the number */
+	formattedString: string;
+	/** The LDML plural category (zero, one, two, few, many, or other) */
+	pluralCategory: LDMLPluralRule;
+}
+/**
+* ResolvePluralInternal ( pluralRules, n )
+*
+* Internal version of ResolvePlural that returns both the formatted string and plural category.
+* This is needed for selectRange, which must compare formatted strings to determine if the
+* start and end values are identical.
+*
+* The formatted string is obtained by applying the number formatting options (digit options)
+* from the PluralRules object to the input number. This ensures that formatting-sensitive
+* plural rules work correctly (e.g., rules that depend on visible fraction digits).
+*
+* @param pl - An initialized PluralRules object
+* @param n - Mathematical value to resolve
+* @returns Record containing the formatted string and plural category
+*/
+export declare function ResolvePluralInternal(pl: Intl.PluralRules, n: Decimal, { getInternalSlots, PluralRuleSelect }: {
+	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
+}): ResolvePluralResult;
+/**
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
+* @param pl
+* @param n
+* @param PluralRuleSelect Has to pass in bc it's implementation-specific
+*/
+export declare function ResolvePlural(pl: Intl.PluralRules, n: Decimal, { getInternalSlots, PluralRuleSelect }: {
+	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
 }): LDMLPluralRule;

package/abstract/ResolvePlural.js

@@ -1,22 +1,75 @@
-import { FormatNumericToString, invariant, Type, } from '@formatjs/ecma402-abstract';
-import { GetOperands } from './GetOperands.js';
+import { ComputeExponentForMagnitude, FormatNumericToString, invariant, Type } from "@formatjs/ecma402-abstract";
+import Decimal from "decimal.js";
+import { GetOperands } from "./GetOperands.js";
 /**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
- * @param pl
- * @param n
- * @param PluralRuleSelect Has to pass in bc it's implementation-specific
- */
-export function ResolvePlural(pl, n, _a) {
-    var getInternalSlots = _a.getInternalSlots, PluralRuleSelect = _a.PluralRuleSelect;
-    var internalSlots = getInternalSlots(pl);
-    invariant(Type(internalSlots) === 'Object', 'pl has to be an object');
-    invariant('initializedPluralRules' in internalSlots, 'pluralrules must be initialized');
-    if (!n.isFinite()) {
-        return 'other';
-    }
-    var locale = internalSlots.locale, type = internalSlots.type;
-    var res = FormatNumericToString(internalSlots, n);
-    var s = res.formattedString;
-    var operands = GetOperands(s);
-    return PluralRuleSelect(locale, type, n, operands);
+* ResolvePluralInternal ( pluralRules, n )
+*
+* Internal version of ResolvePlural that returns both the formatted string and plural category.
+* This is needed for selectRange, which must compare formatted strings to determine if the
+* start and end values are identical.
+*
+* The formatted string is obtained by applying the number formatting options (digit options)
+* from the PluralRules object to the input number. This ensures that formatting-sensitive
+* plural rules work correctly (e.g., rules that depend on visible fraction digits).
+*
+* @param pl - An initialized PluralRules object
+* @param n - Mathematical value to resolve
+* @returns Record containing the formatted string and plural category
+*/
+export function ResolvePluralInternal(pl, n, { getInternalSlots, PluralRuleSelect }) {
+	const internalSlots = getInternalSlots(pl);
+	invariant(Type(internalSlots) === "Object", "pl has to be an object");
+	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
+	// Handle non-finite values (Infinity, -Infinity, NaN)
+	if (!n.isFinite()) {
+		return {
+			formattedString: String(n),
+			pluralCategory: "other"
+		};
+	}
+	const { locale, type, notation } = internalSlots;
+	// ECMA-402 Spec: Format the number according to digit options
+	const res = FormatNumericToString(internalSlots, n);
+	const s = res.formattedString;
+	// Extension: Calculate compact exponent if using compact notation
+	// This enables CLDR c/e operands for proper plural selection with compact numbers
+	let exponent = 0;
+	if (notation === "compact" && !n.isZero()) {
+		// Implementation: Only calculate exponent if NumberFormat locale data is available (soft dependency)
+		if (internalSlots.dataLocaleData?.numbers) {
+			try {
+				// Calculate magnitude (floor of log10 of absolute value)
+				const magnitudeNum = Math.floor(Math.log10(Math.abs(n.toNumber())));
+				const magnitude = new Decimal(magnitudeNum);
+				// Use ComputeExponentForMagnitude from ecma402-abstract
+				// This determines which compact notation pattern to use (K, M, B, etc.)
+				// Cast to any since it expects NumberFormatInternal
+				exponent = ComputeExponentForMagnitude(internalSlots, magnitude);
+			} catch {
+				// Gracefully fall back to 0 if exponent calculation fails
+				exponent = 0;
+			}
+		}
+	}
+	// ECMA-402 Spec: Extract CLDR operands from the formatted string
+	// Extension: Pass exponent for c/e operands
+	const operands = GetOperands(s, exponent);
+	// ECMA-402 Spec: Select the appropriate plural category using the locale's plural rules
+	const pluralCategory = PluralRuleSelect(locale, type, n, operands);
+	return {
+		formattedString: s,
+		pluralCategory
+	};
+}
+/**
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
+* @param pl
+* @param n
+* @param PluralRuleSelect Has to pass in bc it's implementation-specific
+*/
+export function ResolvePlural(pl, n, { getInternalSlots, PluralRuleSelect }) {
+	return ResolvePluralInternal(pl, n, {
+		getInternalSlots,
+		PluralRuleSelect
+	}).pluralCategory;
 }

package/abstract/ResolvePluralRange.d.ts

@@ -0,0 +1,23 @@
+import { type LDMLPluralRule, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
+import type Decimal from "decimal.js";
+import { type OperandsRecord } from "./GetOperands.js";
+/**
+* ResolvePluralRange ( pluralRules, x, y )
+*
+* The ResolvePluralRange abstract operation is called with arguments pluralRules (which must be
+* an object initialized as a PluralRules), x (a mathematical value), and y (a mathematical value).
+* 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.
+*
+* Specification: https://tc39.es/ecma402/#sec-resolvepluralrange
+*
+* @param pluralRules - An initialized PluralRules object
+* @param x - Mathematical value for the range start
+* @param y - Mathematical value for the range end
+* @returns The plural category for the range (zero, one, two, few, many, or other)
+*/
+export declare function ResolvePluralRange(pluralRules: Intl.PluralRules, x: Decimal, y: Decimal, { getInternalSlots, PluralRuleSelect, PluralRuleSelectRange }: {
+	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
+	PluralRuleSelectRange: (locale: string, type: "cardinal" | "ordinal", xp: LDMLPluralRule, yp: LDMLPluralRule) => LDMLPluralRule;
+}): LDMLPluralRule;

package/abstract/ResolvePluralRange.js

@@ -0,0 +1,59 @@
+import { invariant, Type } from "@formatjs/ecma402-abstract";
+import "./GetOperands.js";
+import { ResolvePluralInternal } from "./ResolvePlural.js";
+/**
+* ResolvePluralRange ( pluralRules, x, y )
+*
+* The ResolvePluralRange abstract operation is called with arguments pluralRules (which must be
+* an object initialized as a PluralRules), x (a mathematical value), and y (a mathematical value).
+* 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.
+*
+* Specification: https://tc39.es/ecma402/#sec-resolvepluralrange
+*
+* @param pluralRules - An initialized PluralRules object
+* @param x - Mathematical value for the range start
+* @param y - Mathematical value for the range end
+* @returns The plural category for the range (zero, one, two, few, many, or other)
+*/
+export function ResolvePluralRange(pluralRules, x, y, { getInternalSlots, PluralRuleSelect, PluralRuleSelectRange }) {
+	// 1. If x is not-a-number or y is not-a-number, throw a RangeError exception.
+	if (!x.isFinite() || !y.isFinite()) {
+		throw new RangeError("selectRange requires start and end values to be finite numbers");
+	}
+	// Validation: Assert that pluralRules has been initialized
+	const internalSlots = getInternalSlots(pluralRules);
+	invariant(Type(internalSlots) === "Object", "pluralRules has to be an object");
+	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
+	// 2. Let xp be ResolvePlural(pluralRules, x).
+	// Note: ResolvePlural returns a Record with [[FormattedString]] and [[PluralCategory]]
+	const xp = ResolvePluralInternal(pluralRules, x, {
+		getInternalSlots,
+		PluralRuleSelect
+	});
+	// 3. Let yp be ResolvePlural(pluralRules, y).
+	const yp = ResolvePluralInternal(pluralRules, y, {
+		getInternalSlots,
+		PluralRuleSelect
+	});
+	// 4. If xp.[[FormattedString]] is yp.[[FormattedString]], then
+	//    a. Return xp.[[PluralCategory]].
+	// Note: When the formatted strings are identical (e.g., "1" and "1"), the values are
+	// effectively the same, so we return the plural category of the start value.
+	if (xp.formattedString === yp.formattedString) {
+		return xp.pluralCategory;
+	}
+	// 5. Let locale be pluralRules.[[Locale]].
+	// 6. Let type be pluralRules.[[Type]].
+	const { locale, type } = internalSlots;
+	// 7. Let notation be pluralRules.[[Notation]].
+	// 8. Let compactDisplay be pluralRules.[[CompactDisplay]].
+	// Note: notation and compactDisplay are not yet implemented for PluralRules polyfill.
+	// When implemented, these would affect how the range is formatted and thus which
+	// plural rules apply (see c/e operand support).
+	// 9. Return PluralRuleSelectRange(locale, type, notation, compactDisplay, xp.[[PluralCategory]], yp.[[PluralCategory]]).
+	// Note: PluralRuleSelectRange is implementation-defined and uses CLDR plural range data
+	// to determine the appropriate plural category for a range based on the start and end categories.
+	// Example: In English, "one" to "other" → "other" (e.g., "1-2 items")
+	return PluralRuleSelectRange(locale, type, xp.pluralCategory, yp.pluralCategory);
+}

package/get_internal_slots.d.ts

@@ -1,2 +1,3 @@
-import { PluralRules, PluralRulesInternal } from '.';
+import type { PluralRules } from "./index.js";
+import { type PluralRulesInternal } from "./index.js";
 export default function getInternalSlots(x: PluralRules): PluralRulesInternal;

package/get_internal_slots.js

@@ -1,9 +1,10 @@
-var internalSlotMap = new WeakMap();
+import "./index.js";
+const internalSlotMap = new WeakMap();
 export default function getInternalSlots(x) {
-    var internalSlots = internalSlotMap.get(x);
-    if (!internalSlots) {
-        internalSlots = Object.create(null);
-        internalSlotMap.set(x, internalSlots);
-    }
-    return internalSlots;
+	let internalSlots = internalSlotMap.get(x);
+	if (!internalSlots) {
+		internalSlots = Object.create(null);
+		internalSlotMap.set(x, internalSlots);
+	}
+	return internalSlots;
 }

package/index.d.ts

@@ -1,20 +1,78 @@
-import { LDMLPluralRule, NumberFormatDigitInternalSlots, PluralRulesData, PluralRulesLocaleData } from '@formatjs/ecma402-abstract';
+import { type LDMLPluralRule, type NumberFormatDigitInternalSlots, type PluralRulesData, type PluralRulesLocaleData } from "@formatjs/ecma402-abstract";
+/**
+* Type augmentation for Intl.PluralRules
+*
+* ECMA-402 Spec: selectRange method (Intl.PluralRules.prototype.selectRange)
+* https://tc39.es/ecma402/#sec-intl.pluralrules.prototype.selectrange
+*
+* Extension: notation and compactDisplay options (not in ECMA-402 spec)
+* Mirrors Intl.NumberFormat notation option for proper plural selection with compact numbers
+*/
+declare global {
+	namespace Intl {
+		interface PluralRules {
+			selectRange(start: number | bigint, end: number | bigint): LDMLPluralRule;
+		}
+		interface PluralRulesOptions {
+			notation?: "standard" | "compact";
+			compactDisplay?: "short" | "long";
+		}
+	}
+}
 export interface PluralRulesInternal extends NumberFormatDigitInternalSlots {
-    initializedPluralRules: boolean;
-    locale: string;
-    type: 'cardinal' | 'ordinal';
+	initializedPluralRules: boolean;
+	locale: string;
+	type: "cardinal" | "ordinal";
+	notation: "standard" | "compact";
+	compactDisplay?: "short" | "long";
+	dataLocaleData?: any;
 }
-export declare class PluralRules implements Intl.PluralRules {
-    constructor(locales?: string | string[], options?: Intl.PluralRulesOptions);
-    resolvedOptions(): Intl.ResolvedPluralRulesOptions;
-    select(val: number): LDMLPluralRule;
-    toString(): string;
-    static supportedLocalesOf(locales?: string | string[], options?: Pick<Intl.PluralRulesOptions, 'localeMatcher'>): string[];
-    static __addLocaleData(...data: PluralRulesLocaleData[]): void;
-    static localeData: Record<string, PluralRulesData>;
-    static availableLocales: Set<string>;
-    static __defaultLocale: string;
-    static getDefaultLocale(): string;
-    static relevantExtensionKeys: never[];
-    static polyfilled: boolean;
+export declare class PluralRules {
+	constructor(locales?: string | string[], options?: Intl.PluralRulesOptions);
+	resolvedOptions(): Intl.ResolvedPluralRulesOptions;
+	select(val: number | bigint): LDMLPluralRule;
+	/**
+	* Intl.PluralRules.prototype.selectRange ( start, end )
+	*
+	* Returns a string indicating which plural rule applies to a range of numbers.
+	* This is useful for formatting ranges like "1-2 items" vs "2-3 items" where
+	* different languages have different plural rules for ranges.
+	*
+	* Specification: https://tc39.es/ecma402/#sec-intl.pluralrules.prototype.selectrange
+	*
+	* @param start - The start value of the range (number or bigint)
+	* @param end - The end value of the range (number or bigint)
+	* @returns The plural category for the range (zero, one, two, few, many, or other)
+	*
+	* @example
+	* const pr = new Intl.PluralRules('en');
+	* pr.selectRange(1, 2); // "other" (English: "1-2 items")
+	* pr.selectRange(1, 1); // "one" (same value: "1 item")
+	*
+	* @example
+	* const prFr = new Intl.PluralRules('fr');
+	* prFr.selectRange(0, 1); // "one" (French: "0-1 vue")
+	* prFr.selectRange(1, 2); // "other" (French: "1-2 vues")
+	*
+	* @example
+	* // BigInt support (spec-compliant, but Chrome has a bug as of early 2025)
+	* 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)
+	*
+	* @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
+	* a browser bug - the spec requires BigInt support. This polyfill handles BigInt correctly.
+	*/
+	selectRange(start: number | bigint, end: number | bigint): LDMLPluralRule;
+	toString(): string;
+	static supportedLocalesOf(locales?: string | string[], options?: Pick<Intl.PluralRulesOptions, "localeMatcher">): string[];
+	static __addLocaleData(...data: PluralRulesLocaleData[]): void;
+	static localeData: Record<string, PluralRulesData>;
+	static availableLocales: Set<string>;
+	static __defaultLocale: string;
+	static getDefaultLocale(): string;
+	static relevantExtensionKeys: never[];
+	static polyfilled: boolean;
 }