@formatjs/intl-pluralrules 6.1.2 → 6.2.1

package/abstract/GetOperands.d.ts

@@ -1,32 +1,59 @@
 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)
+	* CLDR operand: n (absolute value of the source number)
 	*/
 	Number: Decimal;
 	/**
-	* Number of digits of `number`
+	* CLDR operand: i (integer digits of n)
+	* Implementation: String for very large numbers exceeding Number.MAX_SAFE_INTEGER
 	*/
-	IntegerDigits: number;
+	IntegerDigits: number | string;
 	/**
-	* Number of visible fraction digits in [[Number]], with trailing zeroes.
+	* CLDR operand: v (number of visible fraction digits in n, with trailing zeros)
 	*/
 	NumberOfFractionDigits: number;
 	/**
-	* Number of visible fraction digits in [[Number]], without trailing zeroes.
+	* CLDR operand: w (number of visible fraction digits in n, without trailing zeros)
 	*/
 	NumberOfFractionDigitsWithoutTrailing: number;
 	/**
-	* Number of visible fractional digits in [[Number]], with trailing zeroes.
+	* CLDR operand: f (visible fractional digits in n, with trailing zeros)
 	*/
 	FractionDigits: number;
 	/**
-	* Number of visible fractional digits in [[Number]], without trailing zeroes.
+	* 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
+* 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): OperandsRecord;
+export declare function GetOperands(s: string, exponent?: number): OperandsRecord;

package/abstract/GetOperands.js

@@ -1,9 +1,14 @@
 import { invariant, ToNumber, ZERO } from "@formatjs/ecma402-abstract";
 /**
-* http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
-* @param s
+* 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) {
+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");
@@ -35,10 +40,11 @@ export function GetOperands(s) {
 	}
 	return {
 		Number: n,
-		IntegerDigits: i.toNumber(),
+		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()
+		FractionDigitsWithoutTrailing: t.toNumber(),
+		CompactExponent: exponent
 	};
 }

package/abstract/InitializePluralRules.js

@@ -10,7 +10,22 @@ export function InitializePluralRules(pl, locales, options, { availableLocales,
 	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,7 +1,37 @@
 import { type LDMLPluralRule, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
-import type Decimal from "decimal.js";
+import Decimal from "decimal.js";
 import { type OperandsRecord } from "./GetOperands.js";
 /**
+* 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

package/abstract/ResolvePlural.js

@@ -1,21 +1,75 @@
-import { FormatNumericToString, invariant, Type } from "@formatjs/ecma402-abstract";
+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
+* 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 ResolvePlural(pl, n, { getInternalSlots, PluralRuleSelect }) {
+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 "other";
+		return {
+			formattedString: String(n),
+			pluralCategory: "other"
+		};
 	}
-	const { locale, type } = internalSlots;
+	const { locale, type, notation } = internalSlots;
+	// ECMA-402 Spec: Format the number according to digit options
 	const res = FormatNumericToString(internalSlots, n);
 	const s = res.formattedString;
-	const operands = GetOperands(s);
-	return PluralRuleSelect(locale, type, n, operands);
+	// 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,5 +1,3 @@
-// Type-only circular import
-// eslint-disable-next-line import/no-cycle
 import type { PluralRules } from "./index.js";
 import { type PluralRulesInternal } from "./index.js";
 export default function getInternalSlots(x: PluralRules): PluralRulesInternal;

package/index.d.ts

@@ -1,13 +1,71 @@
 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";
+	notation: "standard" | "compact";
+	compactDisplay?: "short" | "long";
+	dataLocaleData?: any;
 }
-export declare class PluralRules implements Intl.PluralRules {
+export declare class PluralRules {
 	constructor(locales?: string | string[], options?: Intl.PluralRulesOptions);
 	resolvedOptions(): Intl.ResolvedPluralRulesOptions;
-	select(val: number): LDMLPluralRule;
+	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;

package/index.js

@@ -1,7 +1,8 @@
-import { CanonicalizeLocaleList, SupportedLocales, ToNumber } from "@formatjs/ecma402-abstract";
+import { CanonicalizeLocaleList, SupportedLocales, ToIntlMathematicalValue } from "@formatjs/ecma402-abstract";
 import "./abstract/GetOperands.js";
 import { InitializePluralRules } from "./abstract/InitializePluralRules.js";
 import { ResolvePlural } from "./abstract/ResolvePlural.js";
+import { ResolvePluralRange } from "./abstract/ResolvePluralRange.js";
 import getInternalSlots from "./get_internal_slots.js";
 function validateInstance(instance, method) {
 	if (!(instance instanceof PluralRules)) {
@@ -15,8 +16,44 @@ function validateInstance(instance, method) {
 * @param _n
 * @param param3
 */
-function PluralRuleSelect(locale, type, _n, { IntegerDigits, NumberOfFractionDigits, FractionDigits }) {
-	return PluralRules.localeData[locale].fn(NumberOfFractionDigits ? `${IntegerDigits}.${FractionDigits}` : IntegerDigits, type === "ordinal");
+function PluralRuleSelect(locale, type, _n, { IntegerDigits, NumberOfFractionDigits, FractionDigits, CompactExponent }) {
+	// Always pass a string to the compiled function to preserve precision for huge numbers
+	return PluralRules.localeData[locale].fn(NumberOfFractionDigits ? `${IntegerDigits}.${FractionDigits}` : String(IntegerDigits), type === "ordinal", CompactExponent);
+}
+/**
+* PluralRuleSelectRange ( locale, type, notation, compactDisplay, start, end )
+*
+* Implementation-defined abstract operation that determines the plural category for a range
+* by consulting CLDR plural range data. Each locale defines how different combinations of
+* start and end plural categories map to a range plural category.
+*
+* Examples from CLDR:
+* - English: "one" + "other" → "other" (e.g., "1-2 items")
+* - French: "one" + "one" → "one" (e.g., "0-1 vue")
+* - Arabic: "few" + "many" → "many" (e.g., complex range rules)
+*
+* The spec allows this to be implementation-defined, and we use CLDR supplemental data
+* from pluralRanges.json which provides explicit mappings for each locale.
+*
+* @param locale - BCP 47 locale identifier
+* @param type - "cardinal" or "ordinal"
+* @param xp - Start plural category
+* @param yp - End plural category
+* @returns The plural category for the range
+*/
+function PluralRuleSelectRange(locale, type, xp, yp) {
+	const localeData = PluralRules.localeData[locale];
+	if (!localeData || !localeData.pluralRanges) {
+		// Fallback: If no range data is available, return the end category.
+		// This is a reasonable default as the end value often determines the plural form.
+		return yp;
+	}
+	// Construct lookup key: "start_end" (e.g., "one_other", "few_many")
+	const key = `${xp}_${yp}`;
+	// Select the appropriate range data based on type (cardinal vs ordinal)
+	const rangeData = type === "ordinal" ? localeData.pluralRanges.ordinal : localeData.pluralRanges.cardinal;
+	// Look up the result, falling back to end category if not found
+	return rangeData?.[key] ?? yp;
 }
 export class PluralRules {
 	constructor(locales, options) {
@@ -57,12 +94,69 @@ export class PluralRules {
 	}
 	select(val) {
 		validateInstance(this, "select");
-		const n = ToNumber(val);
+		// Use ToIntlMathematicalValue which handles bigint per ECMA-402
+		// https://tc39.es/ecma402/#sec-intl.pluralrules.prototype.select
+		const n = ToIntlMathematicalValue(val);
 		return ResolvePlural(this, n, {
 			getInternalSlots,
 			PluralRuleSelect
 		});
 	}
+	/**
+	* 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, end) {
+		validateInstance(this, "selectRange");
+		// Spec: https://tc39.es/ecma402/#sec-intl.pluralrules.prototype.selectrange
+		// 1. Let pr be the this value.
+		// 2. Perform ? RequireInternalSlot(pr, [[InitializedPluralRules]]).
+		// (Validation is done by validateInstance above)
+		// 3. If start is undefined or end is undefined, throw a TypeError exception.
+		if (start === undefined || end === undefined) {
+			throw new TypeError("selectRange requires both start and end arguments");
+		}
+		// 4. Let x be ? ToIntlMathematicalValue(start).
+		const x = ToIntlMathematicalValue(start);
+		// 5. Let y be ? ToIntlMathematicalValue(end).
+		const y = ToIntlMathematicalValue(end);
+		// 6. Return ? ResolvePluralRange(pr, x, y).
+		return ResolvePluralRange(this, x, y, {
+			getInternalSlots,
+			PluralRuleSelect,
+			PluralRuleSelectRange
+		});
+	}
 	toString() {
 		return "[object Intl.PluralRules]";
 	}

package/locale-data/af.js

@@ -1,8 +1,18 @@
 /* @generated */
 // prettier-ignore
 if (Intl.PluralRules && typeof Intl.PluralRules.__addLocaleData === 'function') {
-  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(n, ord) {
-  if (ord) return 'other';
-  return n == 1 ? 'one' : 'other';
-}},"locale":"af"})
+  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(num, isOrdinal, exponent = 0) {
+    const numStr = String(num);
+    const parts = numStr.split(".");
+    const integerPart = parts[0];
+    const decimalPart = parts[1] || "";
+    const n = Math.abs(parseFloat(numStr));
+    if (isOrdinal) {
+    }
+    else {
+        if (n === 1)
+            return "one";
+    }
+    return "other";
+},"pluralRanges":{"cardinal":{"one_other":"other","other_one":"other","other_other":"other"},"ordinal":{}}},"locale":"af"})
 }

package/locale-data/ak.js

@@ -1,8 +1,18 @@
 /* @generated */
 // prettier-ignore
 if (Intl.PluralRules && typeof Intl.PluralRules.__addLocaleData === 'function') {
-  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(n, ord) {
-  if (ord) return 'other';
-  return (n == 0 || n == 1) ? 'one' : 'other';
-}},"locale":"ak"})
+  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(num, isOrdinal, exponent = 0) {
+    const numStr = String(num);
+    const parts = numStr.split(".");
+    const integerPart = parts[0];
+    const decimalPart = parts[1] || "";
+    const n = Math.abs(parseFloat(numStr));
+    if (isOrdinal) {
+    }
+    else {
+        if ((n >= 0 && n <= 1))
+            return "one";
+    }
+    return "other";
+},"pluralRanges":{"cardinal":{"one_one":"other","one_other":"other","other_one":"one","other_other":"other"},"ordinal":{}}},"locale":"ak"})
 }

package/locale-data/am.js

@@ -1,8 +1,19 @@
 /* @generated */
 // prettier-ignore
 if (Intl.PluralRules && typeof Intl.PluralRules.__addLocaleData === 'function') {
-  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(n, ord) {
-  if (ord) return 'other';
-  return n >= 0 && n <= 1 ? 'one' : 'other';
-}},"locale":"am"})
+  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(num, isOrdinal, exponent = 0) {
+    const numStr = String(num);
+    const parts = numStr.split(".");
+    const integerPart = parts[0];
+    const decimalPart = parts[1] || "";
+    const n = Math.abs(parseFloat(numStr));
+    const i = Math.floor(Math.abs(parseFloat(integerPart)));
+    if (isOrdinal) {
+    }
+    else {
+        if (i === 0 || n === 1)
+            return "one";
+    }
+    return "other";
+},"pluralRanges":{"cardinal":{"one_one":"one","one_other":"other","other_other":"other"},"ordinal":{}}},"locale":"am"})
 }

package/locale-data/an.js

@@ -1,8 +1,18 @@
 /* @generated */
 // prettier-ignore
 if (Intl.PluralRules && typeof Intl.PluralRules.__addLocaleData === 'function') {
-  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(n, ord) {
-  if (ord) return 'other';
-  return n == 1 ? 'one' : 'other';
-}},"locale":"an"})
+  Intl.PluralRules.__addLocaleData({"data":{"categories":{"cardinal":["one","other"],"ordinal":["other"]},"fn":function(num, isOrdinal, exponent = 0) {
+    const numStr = String(num);
+    const parts = numStr.split(".");
+    const integerPart = parts[0];
+    const decimalPart = parts[1] || "";
+    const n = Math.abs(parseFloat(numStr));
+    if (isOrdinal) {
+    }
+    else {
+        if (n === 1)
+            return "one";
+    }
+    return "other";
+},"pluralRanges":{"cardinal":{"one_other":"other","other_one":"other","other_other":"other"},"ordinal":{}}},"locale":"an"})
 }