@formatjs/ecma402-abstract 2.2.4 → 2.3.0

package/lib/NumberFormat/InitializeNumberFormat.js

@@ -1,22 +1,17 @@
 import { ResolveLocale } from '@formatjs/intl-localematcher';
 import { CanonicalizeLocaleList } from '../CanonicalizeLocaleList';
 import { CoerceOptionsToObject } from '../CoerceOptionsToObject';
-import { GetNumberOption } from '../GetNumberOption';
 import { GetOption } from '../GetOption';
 import { GetStringOrBooleanOption } from '../GetStringOrBooleanOption';
 import { invariant } from '../utils';
 import { CurrencyDigits } from './CurrencyDigits';
 import { SetNumberFormatDigitOptions } from './SetNumberFormatDigitOptions';
 import { SetNumberFormatUnitOptions } from './SetNumberFormatUnitOptions';
-var VALID_ROUND_INCREMENT_VALUES = [
-    1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000,
-];
 /**
  * https://tc39.es/ecma402/#sec-initializenumberformat
  */
 export function InitializeNumberFormat(nf, locales, opts, _a) {
     var getInternalSlots = _a.getInternalSlots, localeData = _a.localeData, availableLocales = _a.availableLocales, numberingSystemNames = _a.numberingSystemNames, getDefaultLocale = _a.getDefaultLocale, currencyDigitsData = _a.currencyDigitsData;
-    // @ts-ignore
     var requestedLocales = CanonicalizeLocaleList(locales);
     var options = CoerceOptionsToObject(opts);
     var opt = Object.create(null);
@@ -42,9 +37,11 @@ export function InitializeNumberFormat(nf, locales, opts, _a) {
     internalSlots.dataLocaleData = dataLocaleData;
     SetNumberFormatUnitOptions(nf, options, { getInternalSlots: getInternalSlots });
     var style = internalSlots.style;
+    var notation = GetOption(options, 'notation', 'string', ['standard', 'scientific', 'engineering', 'compact'], 'standard');
+    internalSlots.notation = notation;
     var mnfdDefault;
     var mxfdDefault;
-    if (style === 'currency') {
+    if (style === 'currency' && notation === 'standard') {
         var currency = internalSlots.currency;
         var cDigits = CurrencyDigits(currency, { currencyDigitsData: currencyDigitsData });
         mnfdDefault = cDigits;
@@ -54,42 +51,16 @@ export function InitializeNumberFormat(nf, locales, opts, _a) {
         mnfdDefault = 0;
         mxfdDefault = style === 'percent' ? 0 : 3;
     }
-    var notation = GetOption(options, 'notation', 'string', ['standard', 'scientific', 'engineering', 'compact'], 'standard');
-    internalSlots.notation = notation;
     SetNumberFormatDigitOptions(internalSlots, options, mnfdDefault, mxfdDefault, notation);
-    var roundingIncrement = GetNumberOption(options, 'roundingIncrement', 1, 5000, 1);
-    if (VALID_ROUND_INCREMENT_VALUES.indexOf(roundingIncrement) === -1) {
-        throw new RangeError("Invalid rounding increment value: ".concat(roundingIncrement, ".\nValid values are ").concat(VALID_ROUND_INCREMENT_VALUES, "."));
-    }
-    if (roundingIncrement !== 1 &&
-        internalSlots.roundingType !== 'fractionDigits') {
-        throw new TypeError("For roundingIncrement > 1 only fractionDigits is a valid roundingType");
-    }
-    if (roundingIncrement !== 1 &&
-        internalSlots.maximumFractionDigits !== internalSlots.minimumFractionDigits) {
-        throw new RangeError('With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.');
-    }
-    internalSlots.roundingIncrement = roundingIncrement;
-    var trailingZeroDisplay = GetOption(options, 'trailingZeroDisplay', 'string', ['auto', 'stripIfInteger'], 'auto');
-    internalSlots.trailingZeroDisplay = trailingZeroDisplay;
     var compactDisplay = GetOption(options, 'compactDisplay', 'string', ['short', 'long'], 'short');
     var defaultUseGrouping = 'auto';
     if (notation === 'compact') {
         internalSlots.compactDisplay = compactDisplay;
         defaultUseGrouping = 'min2';
     }
-    internalSlots.useGrouping = GetStringOrBooleanOption(options, 'useGrouping', ['min2', 'auto', 'always'], 'always', false, defaultUseGrouping);
-    internalSlots.signDisplay = GetOption(options, 'signDisplay', 'string', ['auto', 'never', 'always', 'exceptZero', 'negative'], 'auto');
-    internalSlots.roundingMode = GetOption(options, 'roundingMode', 'string', [
-        'ceil',
-        'floor',
-        'expand',
-        'trunc',
-        'halfCeil',
-        'halfFloor',
-        'halfExpand',
-        'halfTrunc',
-        'halfEven',
-    ], 'halfExpand');
+    var useGrouping = GetStringOrBooleanOption(options, 'useGrouping', ['min2', 'auto', 'always'], 'always', false, defaultUseGrouping);
+    internalSlots.useGrouping = useGrouping;
+    var signDisplay = GetOption(options, 'signDisplay', 'string', ['auto', 'never', 'always', 'exceptZero', 'negative'], 'auto');
+    internalSlots.signDisplay = signDisplay;
     return nf;
 }

package/lib/NumberFormat/PartitionNumberPattern.d.ts

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

package/lib/NumberFormat/PartitionNumberPattern.js

@@ -1,7 +1,8 @@
-import { FormatNumericToString } from './FormatNumericToString';
-import { SameValue } from '../262';
+import { TEN } from '../constants';
+import { invariant } from '../utils';
 import { ComputeExponent } from './ComputeExponent';
 import formatToParts from './format_to_parts';
+import { FormatNumericToString } from './FormatNumericToString';
 /**
  * https://tc39.es/ecma402/#sec-formatnumberstring
  */
@@ -15,26 +16,23 @@ export 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 (!SameValue(x, -0)) {
-            if (!isFinite(x)) {
-                throw new Error('Input must be a mathematical value');
-            }
+        if (!x.isZero()) {
+            invariant(x.isFinite(), 'Input must be a mathematical value');
             if (internalSlots.style == 'percent') {
-                x *= 100;
+                x = x.times(100);
             }
             ;
             _b = 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(TEN.pow(-exponent));
         }
         var formatNumberResult = FormatNumericToString(internalSlots, x);
         n = formatNumberResult.formattedString;
@@ -49,7 +47,7 @@ export function PartitionNumberPattern(numberFormat, x, _a) {
             sign = 0;
             break;
         case 'auto':
-            if (SameValue(x, 0) || x > 0 || isNaN(x)) {
+            if (x.isPositive() || x.isNaN()) {
                 sign = 0;
             }
             else {
@@ -57,24 +55,33 @@ export function PartitionNumberPattern(numberFormat, x, _a) {
             }
             break;
         case 'always':
-            if (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:
+            invariant(signDisplay === 'negative', 'signDisplay must be "negative"');
+            if (x.isNegative() && !x.isZero()) {
                 sign = -1;
             }
+            else {
+                sign = 0;
+            }
+            break;
     }
     return formatToParts({ roundedNumber: x, formattedString: n, exponent: exponent, magnitude: magnitude, sign: sign }, internalSlots.dataLocaleData, pl, internalSlots);
 }

package/lib/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/lib/NumberFormat/PartitionNumberRangePattern.js

@@ -1,3 +1,4 @@
+import { invariant } from '../utils';
 import { CollapseNumberRange } from './CollapseNumberRange';
 import { FormatApproximately } from './FormatApproximately';
 import { PartitionNumberPattern } from './PartitionNumberPattern';
@@ -6,9 +7,7 @@ import { PartitionNumberPattern } from './PartitionNumberPattern';
  */
 export function PartitionNumberRangePattern(numberFormat, x, y, _a) {
     var getInternalSlots = _a.getInternalSlots;
-    if (isNaN(x) || isNaN(y)) {
-        throw new RangeError('Input must be a number');
-    }
+    invariant(!x.isNaN() && !y.isNaN(), 'Input must be a number');
     var result = [];
     var xResult = PartitionNumberPattern(numberFormat, x, { getInternalSlots: getInternalSlots });
     var yResult = PartitionNumberPattern(numberFormat, y, { getInternalSlots: getInternalSlots });

package/lib/NumberFormat/SetNumberFormatDigitOptions.js

@@ -1,6 +1,10 @@
 import { DefaultNumberOption } from '../DefaultNumberOption';
 import { GetNumberOption } from '../GetNumberOption';
 import { GetOption } from '../GetOption';
+import { invariant } from '../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
  */
@@ -11,7 +15,27 @@ export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mx
     var mnsd = opts.minimumSignificantDigits;
     var mxsd = opts.maximumSignificantDigits;
     internalSlots.minimumIntegerDigits = mnid;
+    var roundingIncrement = GetNumberOption(opts, 'roundingIncrement', 1, 5000, 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 = GetOption(opts, 'roundingMode', 'string', [
+        'ceil',
+        'floor',
+        'expand',
+        'trunc',
+        'halfCeil',
+        'halfFloor',
+        'halfExpand',
+        'halfTrunc',
+        'halfEven',
+    ], 'halfExpand');
     var roundingPriority = GetOption(opts, 'roundingPriority', 'string', ['auto', 'morePrecision', 'lessPrecision'], 'auto');
+    var trailingZeroDisplay = 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;
@@ -24,10 +48,8 @@ export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mx
     }
     if (needSd) {
         if (hasSd) {
-            mnsd = DefaultNumberOption(mnsd, 1, 21, 1);
-            mxsd = DefaultNumberOption(mxsd, mnsd, 21, 21);
-            internalSlots.minimumSignificantDigits = mnsd;
-            internalSlots.maximumSignificantDigits = mxsd;
+            internalSlots.minimumSignificantDigits = DefaultNumberOption(mnsd, 1, 21, 1);
+            internalSlots.maximumSignificantDigits = DefaultNumberOption(mxsd, internalSlots.minimumSignificantDigits, 21, 21);
         }
         else {
             internalSlots.minimumSignificantDigits = 1;
@@ -36,11 +58,10 @@ export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mx
     }
     if (needFd) {
         if (hasFd) {
-            mnfd = DefaultNumberOption(mnfd, 0, 20, undefined);
-            mxfd = DefaultNumberOption(mxfd, 0, 20, undefined);
+            mnfd = DefaultNumberOption(mnfd, 0, 100, undefined);
+            mxfd = 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);
@@ -56,25 +77,33 @@ export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mx
             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) {
+        invariant(internalSlots.roundingType === 'fractionDigits', 'Invalid roundingType');
+        invariant(internalSlots.maximumFractionDigits ===
+            internalSlots.minimumFractionDigits, 'With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.');
     }
 }

package/lib/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/lib/NumberFormat/ToRawFixed.js

@@ -1,4 +1,31 @@
+import Decimal from 'decimal.js';
+import { TEN } from '../constants';
 import { repeat } from '../utils';
+import { ApplyUnsignedRoundingMode } from './ApplyUnsignedRoundingMode';
+Decimal.set({
+    toExpPos: 100,
+});
+function ToRawFixedFn(n, f) {
+    return n.times(TEN.pow(-f));
+}
+function findN1R1(x, f, roundingIncrement) {
+    var nx = x.times(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(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
@@ -6,34 +33,38 @@ import { repeat } from '../utils';
  * @param minFraction and integer between 0 and 20
  * @param maxFraction and integer between 0 and 20
  */
-export function ToRawFixed(x, minFraction, maxFraction) {
+export 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 = 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 + repeat('0', Math.max(+exponent - m.length + 1, 0));
     }
     var int;
     if (f !== 0) {
         var k = m.length;
         if (k <= f) {
-            var z = repeat('0', f + 1 - k);
+            var z = 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 {
@@ -41,11 +72,16 @@ export 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/lib/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/lib/NumberFormat/ToRawPrecision.js

@@ -1,47 +1,77 @@
-import { repeat, getMagnitude } from '../utils';
-export function ToRawPrecision(x, minPrecision, maxPrecision) {
+import Decimal from 'decimal.js';
+import { TEN, ZERO } from '../constants';
+import { invariant, repeat } from '../utils';
+import { ApplyUnsignedRoundingMode } from './ApplyUnsignedRoundingMode';
+Decimal.set({
+    toExpPos: 100,
+});
+function ToRawPrecisionFn(n, e, p) {
+    invariant(TEN.pow(p - 1).lessThanOrEqualTo(n) && n.lessThan(TEN.pow(p)), "n should be in the range ".concat(TEN.pow(p - 1), " <= n < ").concat(TEN.pow(p), " but got ").concat(n));
+    // n * 10^(e - p + 1)
+    return n.times(TEN.pow(e.minus(p).plus(1)));
+}
+function findN1E1R1(x, p) {
+    var maxN1 = TEN.pow(p);
+    var minN1 = 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(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 = TEN.pow(p);
+    var minN2 = 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(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,
+                };
+            }
+        }
+    }
+}
+export function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
     var p = maxPrecision;
     var m;
     var e;
     var xFinal;
-    if (x === 0) {
+    if (x.isZero()) {
         m = repeat('0', p);
         e = 0;
-        xFinal = 0;
+        xFinal = 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 +
-                    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 = ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode);
+        var n = void 0;
+        if (r.eq(r1)) {
+            n = n1;
+            e = e1.toNumber();
+            xFinal = r1;
         }
         else {
-            e = 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) {
@@ -49,26 +79,28 @@ export 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(repeat('0', -e - 1)).concat(m);
+        invariant(e < 0, 'e should be less than 0');
+        m = '0.' + 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/lib/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 {};