@formatjs/ecma402-abstract 3.0.6 → 3.0.8

package/NumberFormat/ComputeExponentForMagnitude.js

@@ -1,66 +1,67 @@
-import { Decimal } from 'decimal.js';
-import { invariant } from '../utils.js';
-import { getPowerOf10 } from './decimal-cache.js';
-Decimal.set({
-    toExpPos: 100,
-});
+import { Decimal } from "decimal.js";
+import "../types/number.js";
+import { invariant } from "../utils.js";
+import { getPowerOf10 } from "./decimal-cache.js";
+Decimal.set({ toExpPos: 100 });
 /**
- * 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).
- */
+* 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).
+*/
 export function ComputeExponentForMagnitude(internalSlots, magnitude) {
-    var notation = internalSlots.notation, dataLocaleData = internalSlots.dataLocaleData, numberingSystem = internalSlots.numberingSystem;
-    switch (notation) {
-        case 'standard':
-            return 0;
-        case 'scientific':
-            return magnitude.toNumber();
-        case 'engineering':
-            var thousands = magnitude.div(3).floor();
-            return thousands.times(3).toNumber();
-        default: {
-            invariant(notation === 'compact', 'Invalid notation');
-            // Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a
-            // number of the given magnitude in compact notation for the current locale.
-            var compactDisplay = internalSlots.compactDisplay, style = internalSlots.style, currencyDisplay = internalSlots.currencyDisplay;
-            var thresholdMap = void 0;
-            if (style === 'currency' && currencyDisplay !== 'name') {
-                var currency = dataLocaleData.numbers.currency[numberingSystem] ||
-                    dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]];
-                thresholdMap = currency.short;
-            }
-            else {
-                var decimal = dataLocaleData.numbers.decimal[numberingSystem] ||
-                    dataLocaleData.numbers.decimal[dataLocaleData.numbers.nu[0]];
-                thresholdMap = compactDisplay === 'long' ? decimal.long : decimal.short;
-            }
-            if (!thresholdMap) {
-                return 0;
-            }
-            var num = getPowerOf10(magnitude).toString();
-            var thresholds = Object.keys(thresholdMap); // TODO: this can be pre-processed
-            if (num < thresholds[0]) {
-                return 0;
-            }
-            if (num > thresholds[thresholds.length - 1]) {
-                return thresholds[thresholds.length - 1].length - 1;
-            }
-            var i = thresholds.indexOf(num);
-            if (i === -1) {
-                return 0;
-            }
-            // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
-            // Special handling if the pattern is precisely `0`.
-            var magnitudeKey = thresholds[i];
-            // TODO: do we need to handle plural here?
-            var compactPattern = thresholdMap[magnitudeKey].other;
-            if (compactPattern === '0') {
-                return 0;
-            }
-            // Example: in zh-TW, `10000000` maps to `0000萬`. So we need to return 8 - 4 = 4 here.
-            return (magnitudeKey.length -
-                thresholdMap[magnitudeKey].other.match(/0+/)[0].length);
-        }
-    }
+	const { notation, dataLocaleData, numberingSystem } = internalSlots;
+	switch (notation) {
+		case "standard": return 0;
+		case "scientific": return magnitude.toNumber();
+		case "engineering":
+			const thousands = magnitude.div(3).floor();
+			return thousands.times(3).toNumber();
+		default: {
+			invariant(notation === "compact", "Invalid notation");
+			// Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a
+			// number of the given magnitude in compact notation for the current locale.
+			const { compactDisplay, style, currencyDisplay } = internalSlots;
+			let thresholdMap;
+			if (style === "currency" && currencyDisplay !== "name") {
+				const currency = dataLocaleData.numbers.currency[numberingSystem] || dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]];
+				thresholdMap = currency.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]) {
+				// GH #4236: When number exceeds max threshold, use the exponent
+				// corresponding to the largest available threshold in locale data.
+				// Calculate exponent the same way as for normal thresholds (lines 70-73).
+				const magnitudeKey = thresholds[thresholds.length - 1];
+				const compactPattern = thresholdMap[magnitudeKey].other;
+				if (compactPattern === "0") {
+					return 0;
+				}
+				return magnitudeKey.length - thresholdMap[magnitudeKey].other.match(/0+/)[0].length;
+			}
+			const i = thresholds.indexOf(num);
+			if (i === -1) {
+				return 0;
+			}
+			// See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
+			// Special handling if the pattern is precisely `0`.
+			const magnitudeKey = thresholds[i];
+			// TODO: do we need to handle plural here?
+			const compactPattern = thresholdMap[magnitudeKey].other;
+			if (compactPattern === "0") {
+				return 0;
+			}
+			// Example: in zh-TW, `10000000` maps to `0000萬`. So we need to return 8 - 4 = 4 here.
+			return magnitudeKey.length - thresholdMap[magnitudeKey].other.match(/0+/)[0].length;
+		}
+	}
 }

package/NumberFormat/CurrencyDigits.d.ts

@@ -1,6 +1,6 @@
 /**
- * https://tc39.es/ecma402/#sec-currencydigits
- */
+* https://tc39.es/ecma402/#sec-currencydigits
+*/
 export declare function CurrencyDigits(c: string, { currencyDigitsData }: {
-    currencyDigitsData: Record<string, number>;
+	currencyDigitsData: Record<string, number>;
 }): number;

package/NumberFormat/CurrencyDigits.js

@@ -1,10 +1,7 @@
-import { HasOwnProperty } from '../262.js';
+import { HasOwnProperty } from "../262.js";
 /**
- * https://tc39.es/ecma402/#sec-currencydigits
- */
-export function CurrencyDigits(c, _a) {
-    var currencyDigitsData = _a.currencyDigitsData;
-    return HasOwnProperty(currencyDigitsData, c)
-        ? currencyDigitsData[c]
-        : 2;
+* https://tc39.es/ecma402/#sec-currencydigits
+*/
+export function CurrencyDigits(c, { currencyDigitsData }) {
+	return HasOwnProperty(currencyDigitsData, c) ? currencyDigitsData[c] : 2;
 }

package/NumberFormat/FormatApproximately.d.ts

@@ -1,5 +1,5 @@
-import { NumberFormatInternal, NumberFormatPart } from '../types/number.js';
+import { type NumberFormatInternal, type NumberFormatPart } from "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-formatapproximately
- */
+* https://tc39.es/ecma402/#sec-formatapproximately
+*/
 export declare function FormatApproximately(internalSlots: NumberFormatInternal, result: NumberFormatPart[]): NumberFormatPart[];

package/NumberFormat/FormatApproximately.js

@@ -1,9 +1,13 @@
+import "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-formatapproximately
- */
+* https://tc39.es/ecma402/#sec-formatapproximately
+*/
 export function FormatApproximately(internalSlots, result) {
-    var symbols = internalSlots.dataLocaleData.numbers.symbols[internalSlots.numberingSystem];
-    var approximatelySign = symbols.approximatelySign;
-    result.push({ type: 'approximatelySign', value: approximatelySign });
-    return result;
+	const symbols = internalSlots.dataLocaleData.numbers.symbols[internalSlots.numberingSystem];
+	const approximatelySign = symbols.approximatelySign;
+	result.push({
+		type: "approximatelySign",
+		value: approximatelySign
+	});
+	return result;
 }

package/NumberFormat/FormatNumeric.d.ts

@@ -1,3 +1,3 @@
-import { Decimal } from 'decimal.js';
-import { NumberFormatInternal } from '../types/number.js';
+import type { Decimal } from "decimal.js";
+import { type NumberFormatInternal } from "../types/number.js";
 export declare function FormatNumeric(internalSlots: NumberFormatInternal, x: Decimal): string;

package/NumberFormat/FormatNumeric.js

@@ -1,5 +1,6 @@
-import { PartitionNumberPattern } from './PartitionNumberPattern.js';
+import "../types/number.js";
+import { PartitionNumberPattern } from "./PartitionNumberPattern.js";
 export function FormatNumeric(internalSlots, x) {
-    var parts = PartitionNumberPattern(internalSlots, x);
-    return parts.map(function (p) { return p.value; }).join('');
+	const parts = PartitionNumberPattern(internalSlots, x);
+	return parts.map((p) => p.value).join("");
 }

package/NumberFormat/FormatNumericRange.d.ts

@@ -1,8 +1,8 @@
-import { Decimal } from 'decimal.js';
-import { NumberFormatInternal } from '../types/number.js';
+import type { Decimal } from "decimal.js";
+import { type NumberFormatInternal } from "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumericrange
- */
-export declare function FormatNumericRange(numberFormat: Intl.NumberFormat, x: Decimal, y: Decimal, { getInternalSlots, }: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+* https://tc39.es/ecma402/#sec-formatnumericrange
+*/
+export declare function FormatNumericRange(numberFormat: Intl.NumberFormat, x: Decimal, y: Decimal, { getInternalSlots }: {
+	getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
 }): string;

package/NumberFormat/FormatNumericRange.js

@@ -1,11 +1,9 @@
-import { PartitionNumberRangePattern } from './PartitionNumberRangePattern.js';
+import "../types/number.js";
+import { PartitionNumberRangePattern } from "./PartitionNumberRangePattern.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumericrange
- */
-export function FormatNumericRange(numberFormat, x, y, _a) {
-    var getInternalSlots = _a.getInternalSlots;
-    var parts = PartitionNumberRangePattern(numberFormat, x, y, {
-        getInternalSlots: getInternalSlots,
-    });
-    return parts.map(function (part) { return part.value; }).join('');
+* https://tc39.es/ecma402/#sec-formatnumericrange
+*/
+export function FormatNumericRange(numberFormat, x, y, { getInternalSlots }) {
+	const parts = PartitionNumberRangePattern(numberFormat, x, y, { getInternalSlots });
+	return parts.map((part) => part.value).join("");
 }

package/NumberFormat/FormatNumericRangeToParts.d.ts

@@ -1,8 +1,8 @@
-import { Decimal } from 'decimal.js';
-import { NumberFormatInternal, NumberRangeToParts } from '../types/number.js';
+import type { Decimal } from "decimal.js";
+import { type NumberFormatInternal, type NumberRangeToParts } from "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumericrangetoparts
- */
-export declare function FormatNumericRangeToParts(numberFormat: Intl.NumberFormat, x: Decimal, y: Decimal, { getInternalSlots, }: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+* https://tc39.es/ecma402/#sec-formatnumericrangetoparts
+*/
+export declare function FormatNumericRangeToParts(numberFormat: Intl.NumberFormat, x: Decimal, y: Decimal, { getInternalSlots }: {
+	getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
 }): NumberRangeToParts[];

package/NumberFormat/FormatNumericRangeToParts.js

@@ -1,16 +1,14 @@
-import { PartitionNumberRangePattern } from './PartitionNumberRangePattern.js';
+import "../types/number.js";
+import { PartitionNumberRangePattern } from "./PartitionNumberRangePattern.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumericrangetoparts
- */
-export function FormatNumericRangeToParts(numberFormat, x, y, _a) {
-    var getInternalSlots = _a.getInternalSlots;
-    var parts = PartitionNumberRangePattern(numberFormat, x, y, {
-        getInternalSlots: getInternalSlots,
-    });
-    return parts.map(function (part, index) { return ({
-        type: part.type,
-        value: part.value,
-        source: part.source,
-        result: index.toString(),
-    }); });
+* https://tc39.es/ecma402/#sec-formatnumericrangetoparts
+*/
+export function FormatNumericRangeToParts(numberFormat, x, y, { getInternalSlots }) {
+	const parts = PartitionNumberRangePattern(numberFormat, x, y, { getInternalSlots });
+	return parts.map((part, index) => ({
+		type: part.type,
+		value: part.value,
+		source: part.source,
+		result: index.toString()
+	}));
 }

package/NumberFormat/FormatNumericToParts.d.ts

@@ -1,5 +1,5 @@
-import { Decimal } from 'decimal.js';
-import { NumberFormatInternal, NumberFormatPart } from '../types/number.js';
+import type { Decimal } from "decimal.js";
+import { type NumberFormatInternal, type NumberFormatPart } from "../types/number.js";
 export declare function FormatNumericToParts(nf: Intl.NumberFormat, x: Decimal, implDetails: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+	getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
 }): NumberFormatPart[];

package/NumberFormat/FormatNumericToParts.js

@@ -1,14 +1,14 @@
-import { ArrayCreate } from '../262.js';
-import { PartitionNumberPattern } from './PartitionNumberPattern.js';
+import { ArrayCreate } from "../262.js";
+import "../types/number.js";
+import { PartitionNumberPattern } from "./PartitionNumberPattern.js";
 export function FormatNumericToParts(nf, x, implDetails) {
-    var parts = PartitionNumberPattern(implDetails.getInternalSlots(nf), x);
-    var result = ArrayCreate(0);
-    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
-        var part = parts_1[_i];
-        result.push({
-            type: part.type,
-            value: part.value,
-        });
-    }
-    return result;
+	const parts = PartitionNumberPattern(implDetails.getInternalSlots(nf), x);
+	const result = ArrayCreate(0);
+	for (const part of parts) {
+		result.push({
+			type: part.type,
+			value: part.value
+		});
+	}
+	return result;
 }

package/NumberFormat/FormatNumericToString.d.ts

@@ -1,9 +1,9 @@
-import { Decimal } from 'decimal.js';
-import { NumberFormatDigitInternalSlots } from '../types/number.js';
+import type { Decimal } from "decimal.js";
+import { type NumberFormatDigitInternalSlots } from "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumberstring
- */
-export declare function FormatNumericToString(intlObject: Pick<NumberFormatDigitInternalSlots, 'roundingType' | 'minimumSignificantDigits' | 'maximumSignificantDigits' | 'minimumIntegerDigits' | 'minimumFractionDigits' | 'maximumFractionDigits' | 'roundingIncrement' | 'roundingMode' | 'trailingZeroDisplay'>, _x: Decimal): {
-    roundedNumber: Decimal;
-    formattedString: string;
+* https://tc39.es/ecma402/#sec-formatnumberstring
+*/
+export declare function FormatNumericToString(intlObject: Pick<NumberFormatDigitInternalSlots, "roundingType" | "minimumSignificantDigits" | "maximumSignificantDigits" | "minimumIntegerDigits" | "minimumFractionDigits" | "maximumFractionDigits" | "roundingIncrement" | "roundingMode" | "trailingZeroDisplay">, _x: Decimal): {
+	roundedNumber: Decimal;
+	formattedString: string;
 };

package/NumberFormat/FormatNumericToString.js

@@ -1,84 +1,82 @@
-import { NEGATIVE_ZERO, ZERO } from '../constants.js';
-import { invariant, repeat } from '../utils.js';
-import { GetUnsignedRoundingMode } from './GetUnsignedRoundingMode.js';
-import { ToRawFixed } from './ToRawFixed.js';
-import { ToRawPrecision } from './ToRawPrecision.js';
+import { NEGATIVE_ZERO, ZERO } from "../constants.js";
+import "../types/number.js";
+import { invariant, repeat } from "../utils.js";
+import { GetUnsignedRoundingMode } from "./GetUnsignedRoundingMode.js";
+import { ToRawFixed } from "./ToRawFixed.js";
+import { ToRawPrecision } from "./ToRawPrecision.js";
 /**
- * https://tc39.es/ecma402/#sec-formatnumberstring
- */
+* https://tc39.es/ecma402/#sec-formatnumberstring
+*/
 export function FormatNumericToString(intlObject, _x) {
-    var x = _x;
-    var sign;
-    // -0
-    if (x.isZero() && x.isNegative()) {
-        sign = 'negative';
-        x = ZERO;
-    }
-    else {
-        invariant(x.isFinite(), 'NumberFormatDigitInternalSlots value is not finite');
-        if (x.lessThan(0)) {
-            sign = 'negative';
-        }
-        else {
-            sign = 'positive';
-        }
-        if (sign === 'negative') {
-            x = x.negated();
-        }
-    }
-    var result;
-    var roundingType = intlObject.roundingType;
-    var unsignedRoundingMode = GetUnsignedRoundingMode(intlObject.roundingMode, sign === 'negative');
-    switch (roundingType) {
-        case 'significantDigits':
-            result = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
-            break;
-        case 'fractionDigits':
-            result = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits, intlObject.roundingIncrement, unsignedRoundingMode);
-            break;
-        default:
-            var sResult = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
-            var 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(intlObject.roundingType === 'lessPrecision', 'Invalid roundingType');
-                if (sResult.roundingMagnitude <= fResult.roundingMagnitude) {
-                    result = fResult;
-                }
-                else {
-                    result = sResult;
-                }
-            }
-            break;
-    }
-    x = result.roundedNumber;
-    var string = result.formattedString;
-    if (intlObject.trailingZeroDisplay === 'stripIfInteger' && x.isInteger()) {
-        var i = string.indexOf('.');
-        if (i > -1) {
-            string = string.slice(0, i);
-        }
-    }
-    var int = result.integerDigitsCount;
-    var minInteger = intlObject.minimumIntegerDigits;
-    if (int < minInteger) {
-        var forwardZeros = repeat('0', minInteger - int);
-        string = forwardZeros + string;
-    }
-    if (sign === 'negative') {
-        if (x.isZero()) {
-            x = NEGATIVE_ZERO;
-        }
-        else {
-            x = x.negated();
-        }
-    }
-    return { roundedNumber: x, formattedString: string };
+	let x = _x;
+	let sign;
+	// -0
+	if (x.isZero() && x.isNegative()) {
+		sign = "negative";
+		x = ZERO;
+	} else {
+		invariant(x.isFinite(), "NumberFormatDigitInternalSlots value is not finite");
+		if (x.lessThan(0)) {
+			sign = "negative";
+		} else {
+			sign = "positive";
+		}
+		if (sign === "negative") {
+			x = x.negated();
+		}
+	}
+	let result;
+	const roundingType = intlObject.roundingType;
+	const unsignedRoundingMode = GetUnsignedRoundingMode(intlObject.roundingMode, sign === "negative");
+	switch (roundingType) {
+		case "significantDigits":
+			result = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
+			break;
+		case "fractionDigits":
+			result = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits, intlObject.roundingIncrement, unsignedRoundingMode);
+			break;
+		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(intlObject.roundingType === "lessPrecision", "Invalid roundingType");
+				if (sResult.roundingMagnitude <= fResult.roundingMagnitude) {
+					result = fResult;
+				} else {
+					result = sResult;
+				}
+			}
+			break;
+	}
+	x = result.roundedNumber;
+	let string = result.formattedString;
+	if (intlObject.trailingZeroDisplay === "stripIfInteger" && x.isInteger()) {
+		let i = string.indexOf(".");
+		if (i > -1) {
+			string = string.slice(0, i);
+		}
+	}
+	const int = result.integerDigitsCount;
+	const minInteger = intlObject.minimumIntegerDigits;
+	if (int < minInteger) {
+		const forwardZeros = repeat("0", minInteger - int);
+		string = forwardZeros + string;
+	}
+	if (sign === "negative") {
+		if (x.isZero()) {
+			x = NEGATIVE_ZERO;
+		} else {
+			x = x.negated();
+		}
+	}
+	return {
+		roundedNumber: x,
+		formattedString: string
+	};
 }

package/NumberFormat/GetUnsignedRoundingMode.d.ts

@@ -1,2 +1,2 @@
-import { RoundingModeType, UnsignedRoundingModeType } from '../types/number.js';
+import { type RoundingModeType, type UnsignedRoundingModeType } from "../types/number.js";
 export declare function GetUnsignedRoundingMode(roundingMode: RoundingModeType, isNegative: boolean): UnsignedRoundingModeType;

package/NumberFormat/GetUnsignedRoundingMode.js

@@ -1,28 +1,29 @@
-var negativeMapping = {
-    ceil: 'zero',
-    floor: 'infinity',
-    expand: 'infinity',
-    trunc: 'zero',
-    halfCeil: 'half-zero',
-    halfFloor: 'half-infinity',
-    halfExpand: 'half-infinity',
-    halfTrunc: 'half-zero',
-    halfEven: 'half-even',
+import "../types/number.js";
+const negativeMapping = {
+	ceil: "zero",
+	floor: "infinity",
+	expand: "infinity",
+	trunc: "zero",
+	halfCeil: "half-zero",
+	halfFloor: "half-infinity",
+	halfExpand: "half-infinity",
+	halfTrunc: "half-zero",
+	halfEven: "half-even"
 };
-var positiveMapping = {
-    ceil: 'infinity',
-    floor: 'zero',
-    expand: 'infinity',
-    trunc: 'zero',
-    halfCeil: 'half-infinity',
-    halfFloor: 'half-zero',
-    halfExpand: 'half-infinity',
-    halfTrunc: 'half-zero',
-    halfEven: 'half-even',
+const positiveMapping = {
+	ceil: "infinity",
+	floor: "zero",
+	expand: "infinity",
+	trunc: "zero",
+	halfCeil: "half-infinity",
+	halfFloor: "half-zero",
+	halfExpand: "half-infinity",
+	halfTrunc: "half-zero",
+	halfEven: "half-even"
 };
 export function GetUnsignedRoundingMode(roundingMode, isNegative) {
-    if (isNegative) {
-        return negativeMapping[roundingMode];
-    }
-    return positiveMapping[roundingMode];
+	if (isNegative) {
+		return negativeMapping[roundingMode];
+	}
+	return positiveMapping[roundingMode];
 }

package/NumberFormat/InitializeNumberFormat.d.ts

@@ -1,12 +1,12 @@
-import { NumberFormatInternal, NumberFormatLocaleInternalData, NumberFormatOptions } from '../types/number.js';
+import { type NumberFormatInternal, type NumberFormatLocaleInternalData, type NumberFormatOptions } from "../types/number.js";
 /**
- * https://tc39.es/ecma402/#sec-initializenumberformat
- */
-export declare function InitializeNumberFormat(nf: Intl.NumberFormat, locales: string | ReadonlyArray<string> | undefined, opts: NumberFormatOptions | undefined, { getInternalSlots, localeData, availableLocales, numberingSystemNames, getDefaultLocale, currencyDigitsData, }: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
-    localeData: Record<string, NumberFormatLocaleInternalData | undefined>;
-    availableLocales: Set<string>;
-    numberingSystemNames: ReadonlyArray<string>;
-    getDefaultLocale(): string;
-    currencyDigitsData: Record<string, number>;
+* https://tc39.es/ecma402/#sec-initializenumberformat
+*/
+export declare function InitializeNumberFormat(nf: Intl.NumberFormat, locales: string | ReadonlyArray<string> | undefined, opts: NumberFormatOptions | undefined, { getInternalSlots, localeData, availableLocales, numberingSystemNames, getDefaultLocale, currencyDigitsData }: {
+	getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+	localeData: Record<string, NumberFormatLocaleInternalData | undefined>;
+	availableLocales: Set<string>;
+	numberingSystemNames: ReadonlyArray<string>;
+	getDefaultLocale(): string;
+	currencyDigitsData: Record<string, number>;
 }): Intl.NumberFormat;