@formatjs/ecma402-abstract 2.3.1 → 2.3.2

package/lib/NumberFormat/SetNumberFormatDigitOptions.js

@@ -2,6 +2,7 @@ import { DefaultNumberOption } from '../DefaultNumberOption';
 import { GetNumberOption } from '../GetNumberOption';
 import { GetOption } from '../GetOption';
 import { invariant } from '../utils';
+//IMPL: Valid rounding increments as per implementation
 var VALID_ROUNDING_INCREMENTS = new Set([
     1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000, 2500, 5000,
 ]);
@@ -9,14 +10,23 @@ var VALID_ROUNDING_INCREMENTS = new Set([
  * https://tc39.es/ecma402/#sec-setnfdigitoptions
  */
 export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefault, notation) {
+    // 1. Let mnid be ? GetNumberOption(opts, "minimumIntegerDigits", 1, 21, 1).
     var mnid = GetNumberOption(opts, 'minimumIntegerDigits', 1, 21, 1);
+    // 2. Let mnfd be opts.[[MinimumFractionDigits]].
     var mnfd = opts.minimumFractionDigits;
+    // 3. Let mxfd be opts.[[MaximumFractionDigits]].
     var mxfd = opts.maximumFractionDigits;
+    // 4. Let mnsd be opts.[[MinimumSignificantDigits]].
     var mnsd = opts.minimumSignificantDigits;
+    // 5. Let mxsd be opts.[[MaximumSignificantDigits]].
     var mxsd = opts.maximumSignificantDigits;
+    // 6. Set internalSlots.[[MinimumIntegerDigits]] to mnid.
     internalSlots.minimumIntegerDigits = mnid;
+    // 7. Let roundingIncrement be ? GetNumberOption(opts, "roundingIncrement", 1, 5000, 1).
     var roundingIncrement = GetNumberOption(opts, 'roundingIncrement', 1, 5000, 1);
+    // 8. If roundingIncrement is not an element of the list {1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000, 2500, 5000}, throw a RangeError exception.
     invariant(VALID_ROUNDING_INCREMENTS.has(roundingIncrement), "Invalid rounding increment value: ".concat(roundingIncrement, ".\nValid values are ").concat(Array.from(VALID_ROUNDING_INCREMENTS).join(', '), "."));
+    // 9. Let roundingMode be ? GetOption(opts, "roundingMode", "string", « "ceil", "floor", "expand", "trunc", "halfCeil", "halfFloor", "halfExpand", "halfTrunc", "halfEven" », "halfExpand").
     var roundingMode = GetOption(opts, 'roundingMode', 'string', [
         'ceil',
         'floor',
@@ -28,82 +38,142 @@ export function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mx
         'halfTrunc',
         'halfEven',
     ], 'halfExpand');
+    // 10. Let roundingPriority be ? GetOption(opts, "roundingPriority", "string", « "auto", "morePrecision", "lessPrecision" », "auto").
     var roundingPriority = GetOption(opts, 'roundingPriority', 'string', ['auto', 'morePrecision', 'lessPrecision'], 'auto');
+    // 11. Let trailingZeroDisplay be ? GetOption(opts, "trailingZeroDisplay", "string", « "auto", "stripIfInteger" », "auto").
     var trailingZeroDisplay = GetOption(opts, 'trailingZeroDisplay', 'string', ['auto', 'stripIfInteger'], 'auto');
+    // 12. If roundingIncrement is not 1, then
     if (roundingIncrement !== 1) {
+        // 12.a. Set mxfdDefault to mnfdDefault.
         mxfdDefault = mnfdDefault;
     }
+    // 13. Set internalSlots.[[RoundingIncrement]] to roundingIncrement.
     internalSlots.roundingIncrement = roundingIncrement;
+    // 14. Set internalSlots.[[RoundingMode]] to roundingMode.
     internalSlots.roundingMode = roundingMode;
+    // 15. Set internalSlots.[[TrailingZeroDisplay]] to trailingZeroDisplay.
     internalSlots.trailingZeroDisplay = trailingZeroDisplay;
+    // 16. Let hasSd be true if mnsd is not undefined or mxsd is not undefined; otherwise, let hasSd be false.
     var hasSd = mnsd !== undefined || mxsd !== undefined;
+    // 17. Let hasFd be true if mnfd is not undefined or mxfd is not undefined; otherwise, let hasFd be false.
     var hasFd = mnfd !== undefined || mxfd !== undefined;
+    // 18. Let needSd be true.
     var needSd = true;
+    // 19. Let needFd be true.
     var needFd = true;
+    // 20. If roundingPriority is "auto", then
     if (roundingPriority === 'auto') {
+        // 20.a. Set needSd to hasSd.
         needSd = hasSd;
+        // 20.b. If hasSd is true or hasFd is false and notation is "compact", then
         if (hasSd || (!hasFd && notation === 'compact')) {
+            // 20.b.i. Set needFd to false.
             needFd = false;
         }
     }
+    // 21. If needSd is true, then
     if (needSd) {
+        // 21.a. If hasSd is true, then
         if (hasSd) {
+            // 21.a.i. Set internalSlots.[[MinimumSignificantDigits]] to ? DefaultNumberOption(mnsd, 1, 21, 1).
             internalSlots.minimumSignificantDigits = DefaultNumberOption(mnsd, 1, 21, 1);
+            // 21.a.ii. Set internalSlots.[[MaximumSignificantDigits]] to ? DefaultNumberOption(mxsd, internalSlots.[[MinimumSignificantDigits]], 21, 21).
             internalSlots.maximumSignificantDigits = DefaultNumberOption(mxsd, internalSlots.minimumSignificantDigits, 21, 21);
         }
         else {
+            // 21.b. Else,
+            // 21.b.i. Set internalSlots.[[MinimumSignificantDigits]] to 1.
             internalSlots.minimumSignificantDigits = 1;
+            // 21.b.ii. Set internalSlots.[[MaximumSignificantDigits]] to 21.
             internalSlots.maximumSignificantDigits = 21;
         }
     }
+    // 22. If needFd is true, then
     if (needFd) {
+        // 22.a. If hasFd is true, then
         if (hasFd) {
+            // 22.a.i. Set mnfd to ? DefaultNumberOption(mnfd, 0, 100, undefined).
             mnfd = DefaultNumberOption(mnfd, 0, 100, undefined);
+            // 22.a.ii. Set mxfd to ? DefaultNumberOption(mxfd, 0, 100, undefined).
             mxfd = DefaultNumberOption(mxfd, 0, 100, undefined);
+            // 22.a.iii. If mnfd is undefined, then
             if (mnfd === undefined) {
-                mnfd = Math.min(mnfdDefault, mxfd !== null && mxfd !== void 0 ? mxfd : 0);
+                // 22.a.iii.1. Assert: mxfd is not undefined.
+                invariant(mxfd !== undefined, 'maximumFractionDigits must be defined');
+                // 22.a.iii.2. Set mnfd to min(mnfdDefault, mxfd).
+                mnfd = Math.min(mnfdDefault, mxfd);
             }
             else if (mxfd === undefined) {
+                // 22.a.iv. Else if mxfd is undefined, then
+                // 22.a.iv.1. Set mxfd to max(mxfdDefault, mnfd).
                 mxfd = Math.max(mxfdDefault, mnfd);
             }
             else if (mnfd > mxfd) {
+                // 22.a.v. Else if mnfd > mxfd, throw a RangeError exception.
                 throw new RangeError("Invalid range, ".concat(mnfd, " > ").concat(mxfd));
             }
+            // 22.a.vi. Set internalSlots.[[MinimumFractionDigits]] to mnfd.
             internalSlots.minimumFractionDigits = mnfd;
+            // 22.a.vii. Set internalSlots.[[MaximumFractionDigits]] to mxfd.
             internalSlots.maximumFractionDigits = mxfd;
         }
         else {
+            // 22.b. Else,
+            // 22.b.i. Set internalSlots.[[MinimumFractionDigits]] to mnfdDefault.
             internalSlots.minimumFractionDigits = mnfdDefault;
+            // 22.b.ii. Set internalSlots.[[MaximumFractionDigits]] to mxfdDefault.
             internalSlots.maximumFractionDigits = mxfdDefault;
         }
     }
+    // 23. If needSd is false and needFd is false, then
     if (!needSd && !needFd) {
+        // 23.a. Set internalSlots.[[MinimumFractionDigits]] to 0.
         internalSlots.minimumFractionDigits = 0;
+        // 23.b. Set internalSlots.[[MaximumFractionDigits]] to 0.
         internalSlots.maximumFractionDigits = 0;
+        // 23.c. Set internalSlots.[[MinimumSignificantDigits]] to 1.
         internalSlots.minimumSignificantDigits = 1;
+        // 23.d. Set internalSlots.[[MaximumSignificantDigits]] to 2.
         internalSlots.maximumSignificantDigits = 2;
+        // 23.e. Set internalSlots.[[RoundingType]] to "morePrecision".
         internalSlots.roundingType = 'morePrecision';
+        // 23.f. Set internalSlots.[[RoundingPriority]] to "morePrecision".
         internalSlots.roundingPriority = 'morePrecision';
     }
     else if (roundingPriority === 'morePrecision') {
+        // 24. Else if roundingPriority is "morePrecision", then
+        // 24.a. Set internalSlots.[[RoundingType]] to "morePrecision".
         internalSlots.roundingType = 'morePrecision';
+        // 24.b. Set internalSlots.[[RoundingPriority]] to "morePrecision".
         internalSlots.roundingPriority = 'morePrecision';
     }
     else if (roundingPriority === 'lessPrecision') {
+        // 25. Else if roundingPriority is "lessPrecision", then
+        // 25.a. Set internalSlots.[[RoundingType]] to "lessPrecision".
         internalSlots.roundingType = 'lessPrecision';
+        // 25.b. Set internalSlots.[[RoundingPriority]] to "lessPrecision".
         internalSlots.roundingPriority = 'lessPrecision';
     }
     else if (hasSd) {
+        // 26. Else if hasSd is true, then
+        // 26.a. Set internalSlots.[[RoundingType]] to "significantDigits".
         internalSlots.roundingType = 'significantDigits';
+        // 26.b. Set internalSlots.[[RoundingPriority]] to "auto".
         internalSlots.roundingPriority = 'auto';
     }
     else {
+        // 27. Else,
+        // 27.a. Set internalSlots.[[RoundingType]] to "fractionDigits".
         internalSlots.roundingType = 'fractionDigits';
+        // 27.b. Set internalSlots.[[RoundingPriority]] to "auto".
         internalSlots.roundingPriority = 'auto';
     }
+    // 28. If roundingIncrement is not 1, then
     if (roundingIncrement !== 1) {
-        invariant(internalSlots.roundingType === 'fractionDigits', 'Invalid roundingType');
+        // 28.a. Assert: internalSlots.[[RoundingType]] is "fractionDigits".
+        invariant(internalSlots.roundingType === 'fractionDigits', 'Invalid roundingType', TypeError);
+        // 28.b. Assert: internalSlots.[[MaximumFractionDigits]] is equal to internalSlots.[[MinimumFractionDigits]].
         invariant(internalSlots.maximumFractionDigits ===
-            internalSlots.minimumFractionDigits, 'With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.');
+            internalSlots.minimumFractionDigits, 'With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.', RangeError);
     }
 }

package/lib/NumberFormat/SetNumberFormatUnitOptions.d.ts

@@ -2,6 +2,4 @@ import { NumberFormatInternal, NumberFormatOptions } from '../types/number';
 /**
  * https://tc39.es/ecma402/#sec-setnumberformatunitoptions
  */
-export declare function SetNumberFormatUnitOptions(nf: Intl.NumberFormat, options: NumberFormatOptions | undefined, { getInternalSlots, }: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
-}): void;
+export declare function SetNumberFormatUnitOptions(internalSlots: NumberFormatInternal, options?: NumberFormatOptions | undefined): void;

package/lib/NumberFormat/SetNumberFormatUnitOptions.js

@@ -1,39 +1,50 @@
 import { GetOption } from '../GetOption';
 import { IsWellFormedCurrencyCode } from '../IsWellFormedCurrencyCode';
 import { IsWellFormedUnitIdentifier } from '../IsWellFormedUnitIdentifier';
+import { invariant } from '../utils';
 /**
  * https://tc39.es/ecma402/#sec-setnumberformatunitoptions
  */
-export function SetNumberFormatUnitOptions(nf, options, _a) {
+export function SetNumberFormatUnitOptions(internalSlots, options) {
     if (options === void 0) { options = Object.create(null); }
-    var getInternalSlots = _a.getInternalSlots;
-    var internalSlots = getInternalSlots(nf);
+    // 1. Let style be ? GetOption(options, "style", "string", « "decimal", "percent", "currency", "unit" », "decimal").
     var style = GetOption(options, 'style', 'string', ['decimal', 'percent', 'currency', 'unit'], 'decimal');
+    // 2. Set internalSlots.[[Style]] to style.
     internalSlots.style = style;
+    // 3. Let currency be ? GetOption(options, "currency", "string", undefined, undefined).
     var currency = GetOption(options, 'currency', 'string', undefined, undefined);
-    if (currency !== undefined && !IsWellFormedCurrencyCode(currency)) {
-        throw RangeError('Malformed currency code');
-    }
-    if (style === 'currency' && currency === undefined) {
-        throw TypeError('currency cannot be undefined');
-    }
+    // 4. If currency is not undefined, then
+    // a. If the result of IsWellFormedCurrencyCode(currency) is false, throw a RangeError exception.
+    invariant(currency === undefined || IsWellFormedCurrencyCode(currency), 'Malformed currency code', RangeError);
+    // 5. If style is "currency" and currency is undefined, throw a TypeError exception.
+    invariant(style !== 'currency' || currency !== undefined, 'currency cannot be undefined', TypeError);
+    // 6. Let currencyDisplay be ? GetOption(options, "currencyDisplay", "string", « "code", "symbol", "narrowSymbol", "name" », "symbol").
     var currencyDisplay = GetOption(options, 'currencyDisplay', 'string', ['code', 'symbol', 'narrowSymbol', 'name'], 'symbol');
+    // 7. Let currencySign be ? GetOption(options, "currencySign", "string", « "standard", "accounting" », "standard").
     var currencySign = GetOption(options, 'currencySign', 'string', ['standard', 'accounting'], 'standard');
+    // 8. Let unit be ? GetOption(options, "unit", "string", undefined, undefined).
     var unit = GetOption(options, 'unit', 'string', undefined, undefined);
-    if (unit !== undefined && !IsWellFormedUnitIdentifier(unit)) {
-        throw RangeError('Invalid unit argument for Intl.NumberFormat()');
-    }
-    if (style === 'unit' && unit === undefined) {
-        throw TypeError('unit cannot be undefined');
-    }
+    // 9. If unit is not undefined, then
+    // a. If the result of IsWellFormedUnitIdentifier(unit) is false, throw a RangeError exception.
+    invariant(unit === undefined || IsWellFormedUnitIdentifier(unit), 'Invalid unit argument for Intl.NumberFormat()', RangeError);
+    // 10. If style is "unit" and unit is undefined, throw a TypeError exception.
+    invariant(style !== 'unit' || unit !== undefined, 'unit cannot be undefined', TypeError);
+    // 11. Let unitDisplay be ? GetOption(options, "unitDisplay", "string", « "short", "narrow", "long" », "short").
     var unitDisplay = GetOption(options, 'unitDisplay', 'string', ['short', 'narrow', 'long'], 'short');
+    // 12. If style is "currency", then
     if (style === 'currency') {
+        // a. Set internalSlots.[[Currency]] to the result of converting currency to upper case as specified in 6.1.
         internalSlots.currency = currency.toUpperCase();
+        // b. Set internalSlots.[[CurrencyDisplay]] to currencyDisplay.
         internalSlots.currencyDisplay = currencyDisplay;
+        // c. Set internalSlots.[[CurrencySign]] to currencySign.
         internalSlots.currencySign = currencySign;
     }
+    // 13. If style is "unit", then
     if (style === 'unit') {
+        // a. Set internalSlots.[[Unit]] to unit.
         internalSlots.unit = unit;
+        // b. Set internalSlots.[[UnitDisplay]] to unitDisplay.
         internalSlots.unitDisplay = unitDisplay;
     }
 }

package/lib/NumberFormat/ToRawFixed.d.ts

@@ -1,10 +1,9 @@
 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
  * @param x a finite non-negative Number or BigInt
- * @param minFraction and integer between 0 and 20
- * @param maxFraction and integer between 0 and 20
+ * @param minFraction an integer between 0 and 20
+ * @param maxFraction an integer between 0 and 20
  */
 export declare function ToRawFixed(x: Decimal, minFraction: number, maxFraction: number, roundingIncrement: number, unsignedRoundingMode: UnsignedRoundingModeType): RawNumberFormatResult;

package/lib/NumberFormat/ToRawFixed.js

@@ -1,15 +1,17 @@
 import Decimal from 'decimal.js';
-import { TEN } from '../constants';
 import { repeat } from '../utils';
 import { ApplyUnsignedRoundingMode } from './ApplyUnsignedRoundingMode';
+//IMPL: Setting Decimal configuration
 Decimal.set({
     toExpPos: 100,
 });
+//IMPL: Helper function to calculate raw fixed value
 function ToRawFixedFn(n, f) {
-    return n.times(TEN.pow(-f));
+    return n.times(Decimal.pow(10, -f));
 }
+//IMPL: Helper function to find n1 and r1
 function findN1R1(x, f, roundingIncrement) {
-    var nx = x.times(TEN.pow(f)).floor();
+    var nx = x.times(Decimal.pow(10, f)).floor();
     var n1 = nx.div(roundingIncrement).floor().times(roundingIncrement);
     var r1 = ToRawFixedFn(n1, f);
     return {
@@ -17,8 +19,9 @@ function findN1R1(x, f, roundingIncrement) {
         r1: r1,
     };
 }
+//IMPL: Helper function to find n2 and r2
 function findN2R2(x, f, roundingIncrement) {
-    var nx = x.times(TEN.pow(f)).ceil();
+    var nx = x.times(Decimal.pow(10, f)).ceil();
     var n2 = nx.div(roundingIncrement).ceil().times(roundingIncrement);
     var r2 = ToRawFixedFn(n2, f);
     return {
@@ -27,57 +30,86 @@ function findN2R2(x, f, roundingIncrement) {
     };
 }
 /**
- * TODO: dedup with intl-pluralrules and support BigInt
  * https://tc39.es/ecma402/#sec-torawfixed
  * @param x a finite non-negative Number or BigInt
- * @param minFraction and integer between 0 and 20
- * @param maxFraction and integer between 0 and 20
+ * @param minFraction an integer between 0 and 20
+ * @param maxFraction an integer between 0 and 20
  */
 export function ToRawFixed(x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode) {
+    // 1. Let f be maxFraction.
     var f = maxFraction;
+    // 2. Let n1 and r1 be the results of performing the maximized rounding of x to f fraction digits.
     var _a = findN1R1(x, f, roundingIncrement), n1 = _a.n1, r1 = _a.r1;
+    // 3. Let n2 and r2 be the results of performing the minimized rounding of x to f fraction digits.
     var _b = findN2R2(x, f, roundingIncrement), n2 = _b.n2, r2 = _b.r2;
+    // 4. Let r be ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode).
     var r = ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode);
     var n, xFinal;
     var m;
+    // 5. If r is equal to r1, then
     if (r.eq(r1)) {
+        // a. Let n be n1.
         n = n1;
+        // b. Let xFinal be r1.
         xFinal = r1;
     }
     else {
+        // 6. Else,
+        // a. Let n be n2.
         n = n2;
+        // b. Let xFinal be r2.
         xFinal = r2;
     }
+    // 7. If n is 0, let m be "0".
     if (n.isZero()) {
         m = '0';
     }
     else {
+        // 8. Else, let m be the String representation of n.
         m = n.toString();
     }
     var int;
+    // 9. If f is not 0, then
     if (f !== 0) {
+        // a. Let k be the length of m.
         var k = m.length;
+        // b. If k < f, then
         if (k <= f) {
+            // i. Let z be the String value consisting of f + 1 - k occurrences of the character "0".
             var z = repeat('0', f - k + 1);
+            // ii. Set m to the string-concatenation of z and m.
             m = z + m;
+            // iii. Set k to f + 1.
             k = f + 1;
         }
+        // c. Let a be the substring of m from 0 to k - f.
         var a = m.slice(0, k - f);
+        // d. Let b be the substring of m from k - f to k.
         var b = m.slice(m.length - f);
+        // e. Set m to the string-concatenation of a, ".", and b.
         m = a + '.' + b;
+        // f. Let int be the length of a.
         int = a.length;
     }
     else {
+        // 10. Else, let int be the length of m.
         int = m.length;
     }
+    // 11. Let cut be maxFraction - minFraction.
     var cut = maxFraction - minFraction;
+    // 12. Repeat, while cut > 0 and the last character of m is "0",
     while (cut > 0 && m[m.length - 1] === '0') {
+        // a. Remove the last character from m.
         m = m.slice(0, m.length - 1);
+        // b. Decrease cut by 1.
         cut--;
     }
+    // 13. If the last character of m is ".", then
     if (m[m.length - 1] === '\u002e') {
+        // a. Remove the last character from m.
         m = m.slice(0, m.length - 1);
     }
+    // 14. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int, [[RoundingMagnitude]]: -f }.
     return {
         formattedString: m,
         roundedNumber: xFinal,

package/lib/NumberFormat/ToRawPrecision.d.ts

@@ -1,3 +1,9 @@
 import Decimal from 'decimal.js';
 import { RawNumberFormatResult, UnsignedRoundingModeType } from '../types/number';
+/**
+ * https://tc39.es/ecma402/#sec-torawprecision
+ * @param x a finite non-negative Number or BigInt
+ * @param minPrecision an integer between 1 and 21
+ * @param maxPrecision an integer between 1 and 21
+ */
 export declare function ToRawPrecision(x: Decimal, minPrecision: number, maxPrecision: number, unsignedRoundingMode: UnsignedRoundingModeType): RawNumberFormatResult;

package/lib/NumberFormat/ToRawPrecision.js

@@ -1,23 +1,17 @@
 import Decimal from 'decimal.js';
-import { TEN, ZERO } from '../constants';
+import { 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)));
-}
+//IMPL: Helper function to find n1, e1, and r1
 function findN1E1R1(x, p) {
-    var maxN1 = TEN.pow(p);
-    var minN1 = TEN.pow(p - 1);
+    var maxN1 = Decimal.pow(10, p);
+    var minN1 = Decimal.pow(10, 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();
+    var currentE1 = maxE1;
+    while (true) {
+        var currentN1 = x.div(Decimal.pow(10, currentE1.minus(p).plus(1))).floor();
         if (currentN1.lessThan(maxN1) && currentN1.greaterThanOrEqualTo(minN1)) {
-            var currentR1 = ToRawPrecisionFn(currentN1, currentE1, p);
+            var currentR1 = currentN1.times(Decimal.pow(10, currentE1.minus(p).plus(1)));
             if (currentR1.lessThanOrEqualTo(x)) {
                 return {
                     n1: currentN1,
@@ -26,16 +20,19 @@ function findN1E1R1(x, p) {
                 };
             }
         }
+        currentE1 = currentE1.minus(1);
     }
 }
+//IMPL: Helper function to find n2, e2, and r2
 function findN2E2R2(x, p) {
-    var maxN2 = TEN.pow(p);
-    var minN2 = TEN.pow(p - 1);
+    var maxN2 = Decimal.pow(10, p);
+    var minN2 = Decimal.pow(10, 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();
+    var currentE2 = minE2;
+    while (true) {
+        var currentN2 = x.div(Decimal.pow(10, currentE2.minus(p).plus(1))).ceil();
         if (currentN2.lessThan(maxN2) && currentN2.greaterThanOrEqualTo(minN2)) {
-            var currentR2 = ToRawPrecisionFn(currentN2, currentE2, p);
+            var currentR2 = currentN2.times(Decimal.pow(10, currentE2.minus(p).plus(1)));
             if (currentR2.greaterThanOrEqualTo(x)) {
                 return {
                     n2: currentN2,
@@ -44,59 +41,104 @@ function findN2E2R2(x, p) {
                 };
             }
         }
+        currentE2 = currentE2.plus(1);
     }
 }
+/**
+ * https://tc39.es/ecma402/#sec-torawprecision
+ * @param x a finite non-negative Number or BigInt
+ * @param minPrecision an integer between 1 and 21
+ * @param maxPrecision an integer between 1 and 21
+ */
 export function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
+    // 1. Let p be maxPrecision.
     var p = maxPrecision;
     var m;
     var e;
     var xFinal;
+    // 2. If x = 0, then
     if (x.isZero()) {
+        // a. Let m be the String value consisting of p occurrences of the character "0".
         m = repeat('0', p);
+        // b. Let e be 0.
         e = 0;
+        // c. Let xFinal be 0.
         xFinal = ZERO;
     }
     else {
+        // 3. Else,
+        // a. Let {n1, e1, r1} be the result of findN1E1R1(x, p).
         var _a = findN1E1R1(x, p), n1 = _a.n1, e1 = _a.e1, r1 = _a.r1;
+        // b. Let {n2, e2, r2} be the result of findN2E2R2(x, p).
         var _b = findN2E2R2(x, p), n2 = _b.n2, e2 = _b.e2, r2 = _b.r2;
+        // c. Let r be ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode).
         var r = ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode);
-        var n = void 0;
+        var n 
+        // d. If r = r1, then
+        = void 0;
+        // d. If r = r1, then
         if (r.eq(r1)) {
+            // i. Let n be n1.
             n = n1;
+            // ii. Let e be e1.
             e = e1.toNumber();
+            // iii. Let xFinal be r1.
             xFinal = r1;
         }
         else {
+            // e. Else,
+            // i. Let n be n2.
             n = n2;
+            // ii. Let e be e2.
             e = e2.toNumber();
+            // iii. Let xFinal be r2.
             xFinal = r2;
         }
+        // f. Let m be the String representation of n.
         m = n.toString();
     }
     var int;
+    // 4. If e ≥ p - 1, then
     if (e >= p - 1) {
+        // a. Let m be the string-concatenation of m and p - 1 - e occurrences of the character "0".
         m = m + repeat('0', e - p + 1);
+        // b. Let int be e + 1.
         int = e + 1;
     }
     else if (e >= 0) {
+        // 5. Else if e ≥ 0, then
+        // a. Let m be the string-concatenation of the first e + 1 characters of m, ".", and the remaining p - (e + 1) characters of m.
         m = m.slice(0, e + 1) + '.' + m.slice(m.length - (p - (e + 1)));
+        // b. Let int be e + 1.
         int = e + 1;
     }
     else {
+        // 6. Else,
+        // a. Assert: e < 0.
         invariant(e < 0, 'e should be less than 0');
+        // b. Let m be the string-concatenation of "0.", -e - 1 occurrences of the character "0", and m.
         m = '0.' + repeat('0', -e - 1) + m;
+        // c. Let int be 1.
         int = 1;
     }
+    // 7. If m contains ".", and maxPrecision > minPrecision, then
     if (m.includes('.') && maxPrecision > minPrecision) {
+        // a. Let cut be maxPrecision - minPrecision.
         var cut = maxPrecision - minPrecision;
+        // b. Repeat, while cut > 0 and the last character of m is "0",
         while (cut > 0 && m[m.length - 1] === '0') {
+            // i. Remove the last character from m.
             m = m.slice(0, m.length - 1);
+            // ii. Decrease cut by 1.
             cut--;
         }
+        // c. If the last character of m is ".", then
         if (m[m.length - 1] === '.') {
+            // i. Remove the last character from m.
             m = m.slice(0, m.length - 1);
         }
     }
+    // 8. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int, [[RoundingMagnitude]]: e }.
     return {
         formattedString: m,
         roundedNumber: xFinal,

package/lib/NumberFormat/format_to_parts.js

@@ -1,5 +1,4 @@
 import Decimal from 'decimal.js';
-import { TEN } from '../constants';
 import { S_UNICODE_REGEX } from '../regex.generated';
 import { digitMapping } from './digit-mapping.generated';
 import { GetUnsignedRoundingMode } from './GetUnsignedRoundingMode';
@@ -164,7 +163,9 @@ export default function formatToParts(numberResult, data, pl, options) {
                 var unitName = void 0;
                 var currencyNameData = data.currencies[options.currency];
                 if (currencyNameData) {
-                    unitName = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), currencyNameData.displayName);
+                    unitName = selectPlural(pl, numberResult.roundedNumber
+                        .times(Decimal.pow(10, exponent))
+                        .toNumber(), currencyNameData.displayName);
                 }
                 else {
                     // Fallback for unknown currency
@@ -201,7 +202,9 @@ export default function formatToParts(numberResult, data, pl, options) {
             var unitPattern = void 0;
             if (unitData) {
                 // Simple unit pattern
-                unitPattern = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), data.units.simple[unit][unitDisplay]);
+                unitPattern = selectPlural(pl, numberResult.roundedNumber
+                    .times(Decimal.pow(10, exponent))
+                    .toNumber(), data.units.simple[unit][unitDisplay]);
             }
             else {
                 // See: http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
@@ -209,7 +212,9 @@ export default function formatToParts(numberResult, data, pl, options) {
                 // Implementation note: we are not following TR-35 here because we need to format to parts!
                 var _c = unit.split('-per-'), numeratorUnit = _c[0], denominatorUnit = _c[1];
                 unitData = data.units.simple[numeratorUnit];
-                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), data.units.simple[numeratorUnit][unitDisplay]);
+                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber
+                    .times(Decimal.pow(10, exponent))
+                    .toNumber(), data.units.simple[numeratorUnit][unitDisplay]);
                 var perUnitPattern = data.units.simple[denominatorUnit].perUnit[unitDisplay];
                 if (perUnitPattern) {
                     // perUnitPattern exists, combine it with numeratorUnitPattern

package/lib/ToIntlMathematicalValue.d.ts

@@ -0,0 +1,2 @@
+import Decimal from 'decimal.js';
+export declare function ToIntlMathematicalValue(input: unknown): Decimal;

package/lib/ToIntlMathematicalValue.js

@@ -0,0 +1,27 @@
+import Decimal from 'decimal.js';
+import { ToPrimitive } from './262';
+export function ToIntlMathematicalValue(input) {
+    var primValue = ToPrimitive(input, 'number');
+    if (typeof primValue === 'bigint') {
+        return new Decimal(primValue);
+    }
+    // IMPL
+    if (primValue === undefined) {
+        return new Decimal(NaN);
+    }
+    if (primValue === true) {
+        return new Decimal(1);
+    }
+    if (primValue === false) {
+        return new Decimal(0);
+    }
+    if (primValue === null) {
+        return new Decimal(0);
+    }
+    try {
+        return new Decimal(primValue);
+    }
+    catch (e) {
+        return new Decimal(NaN);
+    }
+}

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export * from './NumberFormat/ComputeExponentForMagnitude';
 export * from './NumberFormat/CurrencyDigits';
 export { default as _formatToParts } from './NumberFormat/format_to_parts';
 export * from './NumberFormat/FormatApproximately';
+export * from './NumberFormat/FormatNumeric';
 export * from './NumberFormat/FormatNumericRange';
 export * from './NumberFormat/FormatNumericRangeToParts';
 export * from './NumberFormat/FormatNumericToParts';
@@ -43,3 +44,4 @@ export * from './types/plural-rules';
 export * from './types/relative-time';
 export { createMemoizedDateTimeFormat, createMemoizedListFormat, createMemoizedLocale, createMemoizedNumberFormat, createMemoizedPluralRules, invariant, } from './utils';
 export { ZERO } from './constants';
+export { ToIntlMathematicalValue } from './ToIntlMathematicalValue';