@formatjs/ecma402-abstract 2.2.5 → 2.3.1

package/NumberFormat/PartitionNumberPattern.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartitionNumberPattern = PartitionNumberPattern;
 var tslib_1 = require("tslib");
-var FormatNumericToString_1 = require("./FormatNumericToString");
-var _262_1 = require("../262");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
 var ComputeExponent_1 = require("./ComputeExponent");
 var format_to_parts_1 = tslib_1.__importDefault(require("./format_to_parts"));
+var FormatNumericToString_1 = require("./FormatNumericToString");
 /**
  * https://tc39.es/ecma402/#sec-formatnumberstring
  */
@@ -19,26 +20,23 @@ function PartitionNumberPattern(numberFormat, x, _a) {
     var magnitude = 0;
     var exponent = 0;
     var n;
-    if (isNaN(x)) {
+    if (x.isNaN()) {
         n = symbols.nan;
     }
-    else if (x == Number.POSITIVE_INFINITY || x == Number.NEGATIVE_INFINITY) {
+    else if (!x.isFinite()) {
         n = symbols.infinity;
     }
     else {
-        if (!(0, _262_1.SameValue)(x, -0)) {
-            if (!isFinite(x)) {
-                throw new Error('Input must be a mathematical value');
-            }
+        if (!x.isZero()) {
+            (0, utils_1.invariant)(x.isFinite(), 'Input must be a mathematical value');
             if (internalSlots.style == 'percent') {
-                x *= 100;
+                x = x.times(100);
             }
             ;
             _b = (0, ComputeExponent_1.ComputeExponent)(numberFormat, x, {
                 getInternalSlots: getInternalSlots,
             }), exponent = _b[0], magnitude = _b[1];
-            // Preserve more precision by doing multiplication when exponent is negative.
-            x = exponent < 0 ? x * Math.pow(10, -exponent) : x / Math.pow(10, exponent);
+            x = x.times(constants_1.TEN.pow(-exponent));
         }
         var formatNumberResult = (0, FormatNumericToString_1.FormatNumericToString)(internalSlots, x);
         n = formatNumberResult.formattedString;
@@ -53,7 +51,7 @@ function PartitionNumberPattern(numberFormat, x, _a) {
             sign = 0;
             break;
         case 'auto':
-            if ((0, _262_1.SameValue)(x, 0) || x > 0 || isNaN(x)) {
+            if (x.isPositive() || x.isNaN()) {
                 sign = 0;
             }
             else {
@@ -61,24 +59,33 @@ function PartitionNumberPattern(numberFormat, x, _a) {
             }
             break;
         case 'always':
-            if ((0, _262_1.SameValue)(x, 0) || x > 0 || isNaN(x)) {
+            if (x.isPositive() || x.isNaN()) {
                 sign = 1;
             }
             else {
                 sign = -1;
             }
             break;
-        default:
-            // x === 0 -> x is 0 or x is -0
-            if (x === 0 || isNaN(x)) {
+        case 'exceptZero':
+            if (x.isZero()) {
                 sign = 0;
             }
-            else if (x > 0) {
-                sign = 1;
+            else if (x.isNegative()) {
+                sign = -1;
             }
             else {
+                sign = 1;
+            }
+            break;
+        default:
+            (0, utils_1.invariant)(signDisplay === 'negative', 'signDisplay must be "negative"');
+            if (x.isNegative() && !x.isZero()) {
                 sign = -1;
             }
+            else {
+                sign = 0;
+            }
+            break;
     }
     return (0, format_to_parts_1.default)({ roundedNumber: x, formattedString: n, exponent: exponent, magnitude: magnitude, sign: sign }, internalSlots.dataLocaleData, pl, internalSlots);
 }

package/NumberFormat/PartitionNumberRangePattern.d.ts

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

package/NumberFormat/PartitionNumberRangePattern.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartitionNumberRangePattern = PartitionNumberRangePattern;
+var utils_1 = require("../utils");
 var CollapseNumberRange_1 = require("./CollapseNumberRange");
 var FormatApproximately_1 = require("./FormatApproximately");
 var PartitionNumberPattern_1 = require("./PartitionNumberPattern");
@@ -9,9 +10,7 @@ var PartitionNumberPattern_1 = require("./PartitionNumberPattern");
  */
 function PartitionNumberRangePattern(numberFormat, x, y, _a) {
     var getInternalSlots = _a.getInternalSlots;
-    if (isNaN(x) || isNaN(y)) {
-        throw new RangeError('Input must be a number');
-    }
+    (0, utils_1.invariant)(!x.isNaN() && !y.isNaN(), 'Input must be a number');
     var result = [];
     var xResult = (0, PartitionNumberPattern_1.PartitionNumberPattern)(numberFormat, x, { getInternalSlots: getInternalSlots });
     var yResult = (0, PartitionNumberPattern_1.PartitionNumberPattern)(numberFormat, y, { getInternalSlots: getInternalSlots });

package/NumberFormat/SetNumberFormatDigitOptions.js

@@ -4,6 +4,10 @@ exports.SetNumberFormatDigitOptions = SetNumberFormatDigitOptions;
 var DefaultNumberOption_1 = require("../DefaultNumberOption");
 var GetNumberOption_1 = require("../GetNumberOption");
 var GetOption_1 = require("../GetOption");
+var utils_1 = require("../utils");
+var VALID_ROUNDING_INCREMENTS = new Set([
+    1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000, 2500, 5000,
+]);
 /**
  * https://tc39.es/ecma402/#sec-setnfdigitoptions
  */
@@ -14,7 +18,27 @@ function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefau
     var mnsd = opts.minimumSignificantDigits;
     var mxsd = opts.maximumSignificantDigits;
     internalSlots.minimumIntegerDigits = mnid;
+    var roundingIncrement = (0, GetNumberOption_1.GetNumberOption)(opts, 'roundingIncrement', 1, 5000, 1);
+    (0, utils_1.invariant)(VALID_ROUNDING_INCREMENTS.has(roundingIncrement), "Invalid rounding increment value: ".concat(roundingIncrement, ".\nValid values are ").concat(Array.from(VALID_ROUNDING_INCREMENTS).join(', '), "."));
+    var roundingMode = (0, GetOption_1.GetOption)(opts, 'roundingMode', 'string', [
+        'ceil',
+        'floor',
+        'expand',
+        'trunc',
+        'halfCeil',
+        'halfFloor',
+        'halfExpand',
+        'halfTrunc',
+        'halfEven',
+    ], 'halfExpand');
     var roundingPriority = (0, GetOption_1.GetOption)(opts, 'roundingPriority', 'string', ['auto', 'morePrecision', 'lessPrecision'], 'auto');
+    var trailingZeroDisplay = (0, GetOption_1.GetOption)(opts, 'trailingZeroDisplay', 'string', ['auto', 'stripIfInteger'], 'auto');
+    if (roundingIncrement !== 1) {
+        mxfdDefault = mnfdDefault;
+    }
+    internalSlots.roundingIncrement = roundingIncrement;
+    internalSlots.roundingMode = roundingMode;
+    internalSlots.trailingZeroDisplay = trailingZeroDisplay;
     var hasSd = mnsd !== undefined || mxsd !== undefined;
     var hasFd = mnfd !== undefined || mxfd !== undefined;
     var needSd = true;
@@ -27,10 +51,8 @@ function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefau
     }
     if (needSd) {
         if (hasSd) {
-            mnsd = (0, DefaultNumberOption_1.DefaultNumberOption)(mnsd, 1, 21, 1);
-            mxsd = (0, DefaultNumberOption_1.DefaultNumberOption)(mxsd, mnsd, 21, 21);
-            internalSlots.minimumSignificantDigits = mnsd;
-            internalSlots.maximumSignificantDigits = mxsd;
+            internalSlots.minimumSignificantDigits = (0, DefaultNumberOption_1.DefaultNumberOption)(mnsd, 1, 21, 1);
+            internalSlots.maximumSignificantDigits = (0, DefaultNumberOption_1.DefaultNumberOption)(mxsd, internalSlots.minimumSignificantDigits, 21, 21);
         }
         else {
             internalSlots.minimumSignificantDigits = 1;
@@ -39,11 +61,10 @@ function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefau
     }
     if (needFd) {
         if (hasFd) {
-            mnfd = (0, DefaultNumberOption_1.DefaultNumberOption)(mnfd, 0, 20, undefined);
-            mxfd = (0, DefaultNumberOption_1.DefaultNumberOption)(mxfd, 0, 20, undefined);
+            mnfd = (0, DefaultNumberOption_1.DefaultNumberOption)(mnfd, 0, 100, undefined);
+            mxfd = (0, DefaultNumberOption_1.DefaultNumberOption)(mxfd, 0, 100, undefined);
             if (mnfd === undefined) {
-                // @ts-expect-error
-                mnfd = Math.min(mnfdDefault, mxfd);
+                mnfd = Math.min(mnfdDefault, mxfd !== null && mxfd !== void 0 ? mxfd : 0);
             }
             else if (mxfd === undefined) {
                 mxfd = Math.max(mxfdDefault, mnfd);
@@ -59,25 +80,33 @@ function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefau
             internalSlots.maximumFractionDigits = mxfdDefault;
         }
     }
-    if (needSd || needFd) {
-        if (roundingPriority === 'morePrecision') {
-            internalSlots.roundingType = 'morePrecision';
-        }
-        else if (roundingPriority === 'lessPrecision') {
-            internalSlots.roundingType = 'lessPrecision';
-        }
-        else if (hasSd) {
-            internalSlots.roundingType = 'significantDigits';
-        }
-        else {
-            internalSlots.roundingType = 'fractionDigits';
-        }
-    }
-    else {
-        internalSlots.roundingType = 'morePrecision';
+    if (!needSd && !needFd) {
         internalSlots.minimumFractionDigits = 0;
         internalSlots.maximumFractionDigits = 0;
         internalSlots.minimumSignificantDigits = 1;
         internalSlots.maximumSignificantDigits = 2;
+        internalSlots.roundingType = 'morePrecision';
+        internalSlots.roundingPriority = 'morePrecision';
+    }
+    else if (roundingPriority === 'morePrecision') {
+        internalSlots.roundingType = 'morePrecision';
+        internalSlots.roundingPriority = 'morePrecision';
+    }
+    else if (roundingPriority === 'lessPrecision') {
+        internalSlots.roundingType = 'lessPrecision';
+        internalSlots.roundingPriority = 'lessPrecision';
+    }
+    else if (hasSd) {
+        internalSlots.roundingType = 'significantDigits';
+        internalSlots.roundingPriority = 'auto';
+    }
+    else {
+        internalSlots.roundingType = 'fractionDigits';
+        internalSlots.roundingPriority = 'auto';
+    }
+    if (roundingIncrement !== 1) {
+        (0, utils_1.invariant)(internalSlots.roundingType === 'fractionDigits', 'Invalid roundingType');
+        (0, utils_1.invariant)(internalSlots.maximumFractionDigits ===
+            internalSlots.minimumFractionDigits, 'With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.');
     }
 }

package/NumberFormat/ToRawFixed.d.ts

@@ -1,4 +1,5 @@
-import { RawNumberFormatResult } from '../types/number';
+import Decimal from 'decimal.js';
+import { RawNumberFormatResult, UnsignedRoundingModeType } from '../types/number';
 /**
  * TODO: dedup with intl-pluralrules and support BigInt
  * https://tc39.es/ecma402/#sec-torawfixed
@@ -6,4 +7,4 @@ import { RawNumberFormatResult } from '../types/number';
  * @param minFraction and integer between 0 and 20
  * @param maxFraction and integer between 0 and 20
  */
-export declare function ToRawFixed(x: number, minFraction: number, maxFraction: number): RawNumberFormatResult;
+export declare function ToRawFixed(x: Decimal, minFraction: number, maxFraction: number, roundingIncrement: number, unsignedRoundingMode: UnsignedRoundingModeType): RawNumberFormatResult;

package/NumberFormat/ToRawFixed.js

@@ -1,7 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToRawFixed = ToRawFixed;
+var tslib_1 = require("tslib");
+var decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+var constants_1 = require("../constants");
 var utils_1 = require("../utils");
+var ApplyUnsignedRoundingMode_1 = require("./ApplyUnsignedRoundingMode");
+decimal_js_1.default.set({
+    toExpPos: 100,
+});
+function ToRawFixedFn(n, f) {
+    return n.times(constants_1.TEN.pow(-f));
+}
+function findN1R1(x, f, roundingIncrement) {
+    var nx = x.times(constants_1.TEN.pow(f)).floor();
+    var n1 = nx.div(roundingIncrement).floor().times(roundingIncrement);
+    var r1 = ToRawFixedFn(n1, f);
+    return {
+        n1: n1,
+        r1: r1,
+    };
+}
+function findN2R2(x, f, roundingIncrement) {
+    var nx = x.times(constants_1.TEN.pow(f)).ceil();
+    var n2 = nx.div(roundingIncrement).ceil().times(roundingIncrement);
+    var r2 = ToRawFixedFn(n2, f);
+    return {
+        n2: n2,
+        r2: r2,
+    };
+}
 /**
  * TODO: dedup with intl-pluralrules and support BigInt
  * https://tc39.es/ecma402/#sec-torawfixed
@@ -9,34 +37,38 @@ var utils_1 = require("../utils");
  * @param minFraction and integer between 0 and 20
  * @param maxFraction and integer between 0 and 20
  */
-function ToRawFixed(x, minFraction, maxFraction) {
+function ToRawFixed(x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode) {
     var f = maxFraction;
-    var n = Math.round(x * Math.pow(10, f));
-    var xFinal = n / Math.pow(10, f);
-    // n is a positive integer, but it is possible to be greater than 1e21.
-    // In such case we will go the slow path.
-    // See also: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
+    var _a = findN1R1(x, f, roundingIncrement), n1 = _a.n1, r1 = _a.r1;
+    var _b = findN2R2(x, f, roundingIncrement), n2 = _b.n2, r2 = _b.r2;
+    var r = (0, ApplyUnsignedRoundingMode_1.ApplyUnsignedRoundingMode)(x, r1, r2, unsignedRoundingMode);
+    var n, xFinal;
     var m;
-    if (n < 1e21) {
-        m = n.toString();
+    if (r.eq(r1)) {
+        n = n1;
+        xFinal = r1;
+    }
+    else {
+        n = n2;
+        xFinal = r2;
+    }
+    if (n.isZero()) {
+        m = '0';
     }
     else {
         m = n.toString();
-        var _a = m.split('e'), mantissa = _a[0], exponent = _a[1];
-        m = mantissa.replace('.', '');
-        m = m + (0, utils_1.repeat)('0', Math.max(+exponent - m.length + 1, 0));
     }
     var int;
     if (f !== 0) {
         var k = m.length;
         if (k <= f) {
-            var z = (0, utils_1.repeat)('0', f + 1 - k);
+            var z = (0, utils_1.repeat)('0', f - k + 1);
             m = z + m;
             k = f + 1;
         }
         var a = m.slice(0, k - f);
-        var b = m.slice(k - f);
-        m = "".concat(a, ".").concat(b);
+        var b = m.slice(m.length - f);
+        m = a + '.' + b;
         int = a.length;
     }
     else {
@@ -44,11 +76,16 @@ function ToRawFixed(x, minFraction, maxFraction) {
     }
     var cut = maxFraction - minFraction;
     while (cut > 0 && m[m.length - 1] === '0') {
-        m = m.slice(0, -1);
+        m = m.slice(0, m.length - 1);
         cut--;
     }
-    if (m[m.length - 1] === '.') {
-        m = m.slice(0, -1);
+    if (m[m.length - 1] === '\u002e') {
+        m = m.slice(0, m.length - 1);
     }
-    return { formattedString: m, roundedNumber: xFinal, integerDigitsCount: int };
+    return {
+        formattedString: m,
+        roundedNumber: xFinal,
+        integerDigitsCount: int,
+        roundingMagnitude: -f,
+    };
 }

package/NumberFormat/ToRawPrecision.d.ts

@@ -1,2 +1,3 @@
-import { RawNumberFormatResult } from '../types/number';
-export declare function ToRawPrecision(x: number, minPrecision: number, maxPrecision: number): RawNumberFormatResult;
+import Decimal from 'decimal.js';
+import { RawNumberFormatResult, UnsignedRoundingModeType } from '../types/number';
+export declare function ToRawPrecision(x: Decimal, minPrecision: number, maxPrecision: number, unsignedRoundingMode: UnsignedRoundingModeType): RawNumberFormatResult;

package/NumberFormat/ToRawPrecision.js

@@ -1,50 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToRawPrecision = ToRawPrecision;
+var tslib_1 = require("tslib");
+var decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+var constants_1 = require("../constants");
 var utils_1 = require("../utils");
-function ToRawPrecision(x, minPrecision, maxPrecision) {
+var ApplyUnsignedRoundingMode_1 = require("./ApplyUnsignedRoundingMode");
+decimal_js_1.default.set({
+    toExpPos: 100,
+});
+function ToRawPrecisionFn(n, e, p) {
+    (0, utils_1.invariant)(constants_1.TEN.pow(p - 1).lessThanOrEqualTo(n) && n.lessThan(constants_1.TEN.pow(p)), "n should be in the range ".concat(constants_1.TEN.pow(p - 1), " <= n < ").concat(constants_1.TEN.pow(p), " but got ").concat(n));
+    // n * 10^(e - p + 1)
+    return n.times(constants_1.TEN.pow(e.minus(p).plus(1)));
+}
+function findN1E1R1(x, p) {
+    var maxN1 = constants_1.TEN.pow(p);
+    var minN1 = constants_1.TEN.pow(p - 1);
+    var maxE1 = x.div(minN1).log(10).plus(p).minus(1).ceil();
+    for (var currentE1 = maxE1;; currentE1 = currentE1.minus(1)) {
+        var currentN1 = x.div(constants_1.TEN.pow(currentE1.minus(p).plus(1))).floor();
+        if (currentN1.lessThan(maxN1) && currentN1.greaterThanOrEqualTo(minN1)) {
+            var currentR1 = ToRawPrecisionFn(currentN1, currentE1, p);
+            if (currentR1.lessThanOrEqualTo(x)) {
+                return {
+                    n1: currentN1,
+                    e1: currentE1,
+                    r1: currentR1,
+                };
+            }
+        }
+    }
+}
+function findN2E2R2(x, p) {
+    var maxN2 = constants_1.TEN.pow(p);
+    var minN2 = constants_1.TEN.pow(p - 1);
+    var minE2 = x.div(maxN2).log(10).plus(p).minus(1).floor();
+    for (var currentE2 = minE2;; currentE2 = currentE2.plus(1)) {
+        var currentN2 = x.div(constants_1.TEN.pow(currentE2.minus(p).plus(1))).ceil();
+        if (currentN2.lessThan(maxN2) && currentN2.greaterThanOrEqualTo(minN2)) {
+            var currentR2 = ToRawPrecisionFn(currentN2, currentE2, p);
+            if (currentR2.greaterThanOrEqualTo(x)) {
+                return {
+                    n2: currentN2,
+                    e2: currentE2,
+                    r2: currentR2,
+                };
+            }
+        }
+    }
+}
+function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
     var p = maxPrecision;
     var m;
     var e;
     var xFinal;
-    if (x === 0) {
+    if (x.isZero()) {
         m = (0, utils_1.repeat)('0', p);
         e = 0;
-        xFinal = 0;
+        xFinal = constants_1.ZERO;
     }
     else {
-        var xToString = x.toString();
-        // If xToString is formatted as scientific notation, the number is either very small or very
-        // large. If the precision of the formatted string is lower that requested max precision, we
-        // should still infer them from the formatted string, otherwise the formatted result might have
-        // precision loss (e.g. 1e41 will not have 0 in every trailing digits).
-        var xToStringExponentIndex = xToString.indexOf('e');
-        var _a = xToString.split('e'), xToStringMantissa = _a[0], xToStringExponent = _a[1];
-        var xToStringMantissaWithoutDecimalPoint = xToStringMantissa.replace('.', '');
-        if (xToStringExponentIndex >= 0 &&
-            xToStringMantissaWithoutDecimalPoint.length <= p) {
-            e = +xToStringExponent;
-            m =
-                xToStringMantissaWithoutDecimalPoint +
-                    (0, utils_1.repeat)('0', p - xToStringMantissaWithoutDecimalPoint.length);
-            xFinal = x;
+        var _a = findN1E1R1(x, p), n1 = _a.n1, e1 = _a.e1, r1 = _a.r1;
+        var _b = findN2E2R2(x, p), n2 = _b.n2, e2 = _b.e2, r2 = _b.r2;
+        var r = (0, ApplyUnsignedRoundingMode_1.ApplyUnsignedRoundingMode)(x, r1, r2, unsignedRoundingMode);
+        var n = void 0;
+        if (r.eq(r1)) {
+            n = n1;
+            e = e1.toNumber();
+            xFinal = r1;
         }
         else {
-            e = (0, utils_1.getMagnitude)(x);
-            var decimalPlaceOffset = e - p + 1;
-            // n is the integer containing the required precision digits. To derive the formatted string,
-            // we will adjust its decimal place in the logic below.
-            var n = Math.round(adjustDecimalPlace(x, decimalPlaceOffset));
-            // The rounding caused the change of magnitude, so we should increment `e` by 1.
-            if (adjustDecimalPlace(n, p - 1) >= 10) {
-                e = e + 1;
-                // Divide n by 10 to swallow one precision.
-                n = Math.floor(n / 10);
-            }
-            m = n.toString();
-            // Equivalent of n * 10 ** (e - p + 1)
-            xFinal = adjustDecimalPlace(n, p - 1 - e);
+            n = n2;
+            e = e2.toNumber();
+            xFinal = r2;
         }
+        m = n.toString();
     }
     var int;
     if (e >= p - 1) {
@@ -52,26 +83,28 @@ function ToRawPrecision(x, minPrecision, maxPrecision) {
         int = e + 1;
     }
     else if (e >= 0) {
-        m = "".concat(m.slice(0, e + 1), ".").concat(m.slice(e + 1));
+        m = m.slice(0, e + 1) + '.' + m.slice(m.length - (p - (e + 1)));
         int = e + 1;
     }
     else {
-        m = "0.".concat((0, utils_1.repeat)('0', -e - 1)).concat(m);
+        (0, utils_1.invariant)(e < 0, 'e should be less than 0');
+        m = '0.' + (0, utils_1.repeat)('0', -e - 1) + m;
         int = 1;
     }
-    if (m.indexOf('.') >= 0 && maxPrecision > minPrecision) {
+    if (m.includes('.') && maxPrecision > minPrecision) {
         var cut = maxPrecision - minPrecision;
         while (cut > 0 && m[m.length - 1] === '0') {
-            m = m.slice(0, -1);
+            m = m.slice(0, m.length - 1);
             cut--;
         }
         if (m[m.length - 1] === '.') {
-            m = m.slice(0, -1);
+            m = m.slice(0, m.length - 1);
         }
     }
-    return { formattedString: m, roundedNumber: xFinal, integerDigitsCount: int };
-    // x / (10 ** magnitude), but try to preserve as much floating point precision as possible.
-    function adjustDecimalPlace(x, magnitude) {
-        return magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);
-    }
+    return {
+        formattedString: m,
+        roundedNumber: xFinal,
+        integerDigitsCount: int,
+        roundingMagnitude: e,
+    };
 }

package/NumberFormat/format_to_parts.d.ts

@@ -1,7 +1,8 @@
-import { NumberFormatLocaleInternalData, NumberFormatOptionsCompactDisplay, NumberFormatOptionsCurrencyDisplay, NumberFormatOptionsCurrencySign, NumberFormatOptionsNotation, NumberFormatOptionsStyle, NumberFormatOptionsUnitDisplay, NumberFormatPart, UseGroupingType } from '../types/number';
+import Decimal from 'decimal.js';
+import { NumberFormatLocaleInternalData, NumberFormatOptionsCompactDisplay, NumberFormatOptionsCurrencyDisplay, NumberFormatOptionsCurrencySign, NumberFormatOptionsNotation, NumberFormatOptionsStyle, NumberFormatOptionsUnitDisplay, NumberFormatPart, RoundingModeType, UseGroupingType } from '../types/number';
 interface NumberResult {
     formattedString: string;
-    roundedNumber: number;
+    roundedNumber: Decimal;
     sign: -1 | 0 | 1;
     exponent: number;
     magnitude: number;
@@ -17,5 +18,7 @@ export default function formatToParts(numberResult: NumberResult, data: NumberFo
     currencySign?: NumberFormatOptionsCurrencySign;
     unit?: string;
     unitDisplay?: NumberFormatOptionsUnitDisplay;
+    roundingIncrement: number;
+    roundingMode: RoundingModeType;
 }): NumberFormatPart[];
 export {};