@formatjs/ecma402-abstract 2.2.5 → 2.3.1

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 {};

package/lib/NumberFormat/format_to_parts.js

@@ -1,6 +1,9 @@
+import Decimal from 'decimal.js';
+import { TEN } from '../constants';
 import { S_UNICODE_REGEX } from '../regex.generated';
-import { ToRawFixed } from './ToRawFixed';
 import { digitMapping } from './digit-mapping.generated';
+import { GetUnsignedRoundingMode } from './GetUnsignedRoundingMode';
+import { ToRawFixed } from './ToRawFixed';
 // This is from: unicode-12.1.0/General_Category/Symbol/regex.js
 // IE11 does not support unicode flag, otherwise this is just /\p{S}/u.
 // /^\p{S}/u
@@ -9,6 +12,7 @@ var CARET_S_UNICODE_REGEX = new RegExp("^".concat(S_UNICODE_REGEX.source));
 var S_DOLLAR_UNICODE_REGEX = new RegExp("".concat(S_UNICODE_REGEX.source, "$"));
 var CLDR_NUMBER_PATTERN = /[#0](?:[\.,][#0]+)*/g;
 export default function formatToParts(numberResult, data, pl, options) {
+    var _a;
     var sign = numberResult.sign, exponent = numberResult.exponent, magnitude = numberResult.magnitude;
     var notation = options.notation, style = options.style, numberingSystem = options.numberingSystem;
     var defaultNumberingSystem = data.numbers.nu[0];
@@ -115,9 +119,9 @@ export default function formatToParts(numberResult, data, pl, options) {
         switch (part) {
             case '{0}': {
                 // We only need to handle scientific and engineering notation here.
-                numberParts.push.apply(numberParts, paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, 
+                numberParts.push.apply(numberParts, partitionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, 
                 // If compact number pattern exists, do not insert group separators.
-                !compactNumberPattern && Boolean(options.useGrouping), decimalNumberPattern, style));
+                !compactNumberPattern && ((_a = options.useGrouping) !== null && _a !== void 0 ? _a : true), decimalNumberPattern, style, options.roundingIncrement, GetUnsignedRoundingMode(options.roundingMode, sign === -1)));
                 break;
             }
             case '-':
@@ -160,7 +164,7 @@ 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 * Math.pow(10, exponent), currencyNameData.displayName);
+                    unitName = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), currencyNameData.displayName);
                 }
                 else {
                     // Fallback for unknown currency
@@ -169,8 +173,8 @@ export default function formatToParts(numberResult, data, pl, options) {
                 // Do {0} and {1} substitution
                 var unitPatternParts = unitPattern.split(/(\{[01]\})/g);
                 var result = [];
-                for (var _a = 0, unitPatternParts_1 = unitPatternParts; _a < unitPatternParts_1.length; _a++) {
-                    var part = unitPatternParts_1[_a];
+                for (var _b = 0, unitPatternParts_1 = unitPatternParts; _b < unitPatternParts_1.length; _b++) {
+                    var part = unitPatternParts_1[_b];
                     switch (part) {
                         case '{0}':
                             result.push.apply(result, numberParts);
@@ -197,15 +201,15 @@ export default function formatToParts(numberResult, data, pl, options) {
             var unitPattern = void 0;
             if (unitData) {
                 // Simple unit pattern
-                unitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[unit][unitDisplay]);
+                unitPattern = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), data.units.simple[unit][unitDisplay]);
             }
             else {
                 // See: http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
                 // If cannot find unit in the simple pattern, it must be "per" compound pattern.
                 // Implementation note: we are not following TR-35 here because we need to format to parts!
-                var _b = unit.split('-per-'), numeratorUnit = _b[0], denominatorUnit = _b[1];
+                var _c = unit.split('-per-'), numeratorUnit = _c[0], denominatorUnit = _c[1];
                 unitData = data.units.simple[numeratorUnit];
-                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[numeratorUnit][unitDisplay]);
+                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber.times(TEN.pow(exponent)).toNumber(), data.units.simple[numeratorUnit][unitDisplay]);
                 var perUnitPattern = data.units.simple[denominatorUnit].perUnit[unitDisplay];
                 if (perUnitPattern) {
                     // perUnitPattern exists, combine it with numeratorUnitPattern
@@ -223,8 +227,8 @@ export default function formatToParts(numberResult, data, pl, options) {
             }
             var result = [];
             // We need spacing around "{0}" because they are not treated as "unit" parts, but "literal".
-            for (var _c = 0, _d = unitPattern.split(/(\s*\{0\}\s*)/); _c < _d.length; _c++) {
-                var part = _d[_c];
+            for (var _d = 0, _e = unitPattern.split(/(\s*\{0\}\s*)/); _d < _e.length; _d++) {
+                var part = _e[_d];
                 var interpolateMatch = /^(\s*)\{0\}(\s*)$/.exec(part);
                 if (interpolateMatch) {
                     // Space before "{0}"
@@ -251,7 +255,7 @@ export default function formatToParts(numberResult, data, pl, options) {
 }
 // A subset of https://tc39.es/ecma402/#sec-partitionnotationsubpattern
 // Plus the exponent parts handling.
-function paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, useGrouping, 
+function partitionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, useGrouping, 
 /**
  * This is the decimal number pattern without signs or symbols.
  * It is used to infer the group size when `useGrouping` is true.
@@ -259,14 +263,14 @@ function paritionNumberIntoParts(symbols, numberResult, notation, exponent, numb
  * A typical value looks like "#,##0.00" (primary group size is 3).
  * Some locales like Hindi has secondary group size of 2 (e.g. "#,##,##0.00").
  */
-decimalNumberPattern, style) {
+decimalNumberPattern, style, roundingIncrement, unsignedRoundingMode) {
     var result = [];
     // eslint-disable-next-line prefer-const
     var n = numberResult.formattedString, x = numberResult.roundedNumber;
-    if (isNaN(x)) {
+    if (x.isNaN()) {
         return [{ type: 'nan', value: n }];
     }
-    else if (!isFinite(x)) {
+    else if (!x.isFinite()) {
         return [{ type: 'infinity', value: n }];
     }
     var digitReplacementTable = digitMapping[numberingSystem];
@@ -291,7 +295,17 @@ decimalNumberPattern, style) {
     // unless the rounded number is greater than 10000:
     //   NumberFormat('de', {notation: 'compact', compactDisplay: 'short'}).format(1234) //=> "1234"
     //   NumberFormat('de').format(1234) //=> "1.234"
-    if (useGrouping && (notation !== 'compact' || x >= 10000)) {
+    var shouldUseGrouping = false;
+    if (useGrouping === 'always') {
+        shouldUseGrouping = true;
+    }
+    else if (useGrouping === 'min2') {
+        shouldUseGrouping = x.greaterThanOrEqualTo(10000);
+    }
+    else if (useGrouping === 'auto' || useGrouping) {
+        shouldUseGrouping = notation !== 'compact' || x.greaterThanOrEqualTo(10000);
+    }
+    if (shouldUseGrouping) {
         // a. Let groupSepSymbol be the implementation-, locale-, and numbering system-dependent (ILND) String representing the grouping separator.
         // For currency we should use `currencyGroup` instead of generic `group`
         var groupSepSymbol = style === 'currency' && symbols.currencyGroup != null
@@ -346,13 +360,13 @@ decimalNumberPattern, style) {
         result.push({ type: 'decimal', value: decimalSepSymbol }, { type: 'fraction', value: fraction });
     }
     if ((notation === 'scientific' || notation === 'engineering') &&
-        isFinite(x)) {
+        x.isFinite()) {
         result.push({ type: 'exponentSeparator', value: symbols.exponential });
         if (exponent < 0) {
             result.push({ type: 'exponentMinusSign', value: symbols.minusSign });
             exponent = -exponent;
         }
-        var exponentResult = ToRawFixed(exponent, 0, 0);
+        var exponentResult = ToRawFixed(new Decimal(exponent), 0, 0, roundingIncrement, unsignedRoundingMode);
         result.push({
             type: 'exponentInteger',
             value: exponentResult.formattedString,
@@ -398,7 +412,7 @@ function getCompactDisplayPattern(numberResult, pl, data, style, compactDisplay,
         if (!compactPluralRules) {
             return null;
         }
-        pattern = selectPlural(pl, roundedNumber, compactPluralRules);
+        pattern = selectPlural(pl, roundedNumber.toNumber(), compactPluralRules);
     }
     else {
         var byNumberingSystem = data.numbers.decimal;
@@ -408,7 +422,7 @@ function getCompactDisplayPattern(numberResult, pl, data, style, compactDisplay,
         if (!compactPlaralRule) {
             return null;
         }
-        pattern = selectPlural(pl, roundedNumber, compactPlaralRule);
+        pattern = selectPlural(pl, roundedNumber.toNumber(), compactPlaralRule);
     }
     // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
     // > If the value is precisely “0”, either explicit or defaulted, then the normal number format

package/lib/constants.d.ts

@@ -0,0 +1,4 @@
+import Decimal from 'decimal.js';
+export declare const TEN: Decimal;
+export declare const ZERO: Decimal;
+export declare const NEGATIVE_ZERO: Decimal;

package/lib/constants.js

@@ -0,0 +1,4 @@
+import Decimal from 'decimal.js';
+export var TEN = new Decimal(10);
+export var ZERO = new Decimal(0);
+export var NEGATIVE_ZERO = new Decimal(-0);

package/lib/index.d.ts

@@ -30,7 +30,7 @@ export * from './NumberFormat/ToRawFixed';
 export * from './NumberFormat/ToRawPrecision';
 export * from './PartitionPattern';
 export * from './SupportedLocales';
-export { createDataProperty, defineProperty, getInternalSlot, getMagnitude, getMultiInternalSlots, isLiteralPart, setInternalSlot, setMultiInternalSlots, } from './utils';
+export { createDataProperty, defineProperty, getInternalSlot, getMultiInternalSlots, isLiteralPart, setInternalSlot, setMultiInternalSlots, } from './utils';
 export type { LiteralPart } from './utils';
 export * from './262';
 export { isMissingLocaleDataError } from './data';
@@ -42,3 +42,4 @@ export * from './types/number';
 export * from './types/plural-rules';
 export * from './types/relative-time';
 export { createMemoizedDateTimeFormat, createMemoizedListFormat, createMemoizedLocale, createMemoizedNumberFormat, createMemoizedPluralRules, invariant, } from './utils';
+export { ZERO } from './constants';

package/lib/index.js

@@ -30,7 +30,7 @@ export * from './NumberFormat/ToRawFixed';
 export * from './NumberFormat/ToRawPrecision';
 export * from './PartitionPattern';
 export * from './SupportedLocales';
-export { createDataProperty, defineProperty, getInternalSlot, getMagnitude, getMultiInternalSlots, isLiteralPart, setInternalSlot, setMultiInternalSlots, } from './utils';
+export { createDataProperty, defineProperty, getInternalSlot, getMultiInternalSlots, isLiteralPart, setInternalSlot, setMultiInternalSlots, } from './utils';
 export * from './262';
 export { isMissingLocaleDataError } from './data';
 export * from './types/date-time';
@@ -40,3 +40,4 @@ export * from './types/number';
 export * from './types/plural-rules';
 export * from './types/relative-time';
 export { createMemoizedDateTimeFormat, createMemoizedListFormat, createMemoizedLocale, createMemoizedNumberFormat, createMemoizedPluralRules, invariant, } from './utils';
+export { ZERO } from './constants';

package/lib/types/number.d.ts

@@ -1,3 +1,4 @@
+import Decimal from 'decimal.js';
 import { LocaleData } from './core';
 import { LDMLPluralRule } from './plural-rules';
 export type NumberFormatNotation = 'standard' | 'scientific' | 'engineering' | 'compact';
@@ -13,17 +14,22 @@ export interface NumberFormatDigitOptions {
     minimumFractionDigits?: number;
     maximumFractionDigits?: number;
     roundingPriority?: RoundingPriorityType;
+    roundingIncrement?: number;
+    roundingMode?: RoundingModeType;
+    trailingZeroDisplay?: TrailingZeroDisplay;
 }
 export interface NumberFormatDigitInternalSlots {
     minimumIntegerDigits: number;
-    minimumSignificantDigits?: number;
-    maximumSignificantDigits?: number;
+    minimumSignificantDigits: number;
+    maximumSignificantDigits: number;
     roundingType: NumberFormatRoundingType;
-    minimumFractionDigits?: number;
-    maximumFractionDigits?: number;
-    notation?: NumberFormatNotation;
-    roundingIncrement?: number;
-    trailingZeroDisplay?: TrailingZeroDisplay;
+    minimumFractionDigits: number;
+    maximumFractionDigits: number;
+    notation: NumberFormatNotation;
+    roundingIncrement: number;
+    roundingMode: RoundingModeType;
+    trailingZeroDisplay: TrailingZeroDisplay;
+    roundingPriority: RoundingPriorityType;
 }
 export type RawNumberLocaleData = LocaleData<NumberFormatLocaleInternalData>;
 export interface NumberFormatLocaleInternalData {
@@ -106,8 +112,9 @@ export type LDMLPluralRuleMap<T> = Omit<Partial<Record<LDMLPluralRule, T>>, 'oth
 };
 export interface RawNumberFormatResult {
     formattedString: string;
-    roundedNumber: number;
+    roundedNumber: Decimal;
     integerDigitsCount: number;
+    roundingMagnitude: number;
 }
 export type NumberFormatOptionsLocaleMatcher = 'lookup' | 'best fit';
 export type NumberFormatOptionsStyle = 'decimal' | 'percent' | 'currency' | 'unit';
@@ -135,7 +142,7 @@ export interface NumberFormatInternal extends NumberFormatDigitInternalSlots {
     boundFormat?: Intl.NumberFormat['format'];
     numberingSystem: string;
     dataLocaleData: NumberFormatLocaleInternalData;
-    roundingMode?: RoundingModeType;
+    roundingMode: RoundingModeType;
 }
 export type NumberFormatOptions = Omit<Intl.NumberFormatOptions, 'signDisplay' | 'useGrouping'> & NumberFormatDigitOptions & {
     localeMatcher?: NumberFormatOptionsLocaleMatcher;

package/lib/utils.d.ts

@@ -1,8 +1,3 @@
-/**
- * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue
- * @param x number
- */
-export declare function getMagnitude(x: number): number;
 export declare function repeat(s: string, times: number): string;
 export declare function setInternalSlot<Instance extends object, Internal extends object, Field extends keyof Internal>(map: WeakMap<Instance, Internal>, pl: Instance, field: Field, value: NonNullable<Internal>[Field]): void;
 export declare function setMultiInternalSlots<Instance extends object, Internal extends object, K extends keyof Internal>(map: WeakMap<Instance, Internal>, pl: Instance, props: Pick<NonNullable<Internal>, K>): void;

package/lib/utils.js

@@ -1,14 +1,5 @@
 import { __spreadArray } from "tslib";
 import { memoize, strategies } from '@formatjs/fast-memoize';
-/**
- * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue
- * @param x number
- */
-export function getMagnitude(x) {
-    // Cannot count string length via Number.toString because it may use scientific notation
-    // for very small or very large numbers.
-    return Math.floor(Math.log(x) * Math.LOG10E);
-}
 export function repeat(s, times) {
     if (typeof s.repeat === 'function') {
         return s.repeat(times);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/ecma402-abstract",
-  "version": "2.2.5",
+  "version": "2.3.1",
   "description": "A collection of implementation for ECMAScript abstract operations",
   "keywords": [
     "intl",
@@ -14,9 +14,10 @@
     "format"
   ],
   "dependencies": {
+    "decimal.js": "10",
     "tslib": "2",
-    "@formatjs/fast-memoize": "2.2.4",
-    "@formatjs/intl-localematcher": "0.5.8"
+    "@formatjs/intl-localematcher": "0.5.9",
+    "@formatjs/fast-memoize": "2.2.5"
   },
   "author": "Long Ho <holevietlong@gmail.com",
   "bugs": {

package/types/number.d.ts

@@ -1,3 +1,4 @@
+import Decimal from 'decimal.js';
 import { LocaleData } from './core';
 import { LDMLPluralRule } from './plural-rules';
 export type NumberFormatNotation = 'standard' | 'scientific' | 'engineering' | 'compact';
@@ -13,17 +14,22 @@ export interface NumberFormatDigitOptions {
     minimumFractionDigits?: number;
     maximumFractionDigits?: number;
     roundingPriority?: RoundingPriorityType;
+    roundingIncrement?: number;
+    roundingMode?: RoundingModeType;
+    trailingZeroDisplay?: TrailingZeroDisplay;
 }
 export interface NumberFormatDigitInternalSlots {
     minimumIntegerDigits: number;
-    minimumSignificantDigits?: number;
-    maximumSignificantDigits?: number;
+    minimumSignificantDigits: number;
+    maximumSignificantDigits: number;
     roundingType: NumberFormatRoundingType;
-    minimumFractionDigits?: number;
-    maximumFractionDigits?: number;
-    notation?: NumberFormatNotation;
-    roundingIncrement?: number;
-    trailingZeroDisplay?: TrailingZeroDisplay;
+    minimumFractionDigits: number;
+    maximumFractionDigits: number;
+    notation: NumberFormatNotation;
+    roundingIncrement: number;
+    roundingMode: RoundingModeType;
+    trailingZeroDisplay: TrailingZeroDisplay;
+    roundingPriority: RoundingPriorityType;
 }
 export type RawNumberLocaleData = LocaleData<NumberFormatLocaleInternalData>;
 export interface NumberFormatLocaleInternalData {
@@ -106,8 +112,9 @@ export type LDMLPluralRuleMap<T> = Omit<Partial<Record<LDMLPluralRule, T>>, 'oth
 };
 export interface RawNumberFormatResult {
     formattedString: string;
-    roundedNumber: number;
+    roundedNumber: Decimal;
     integerDigitsCount: number;
+    roundingMagnitude: number;
 }
 export type NumberFormatOptionsLocaleMatcher = 'lookup' | 'best fit';
 export type NumberFormatOptionsStyle = 'decimal' | 'percent' | 'currency' | 'unit';
@@ -135,7 +142,7 @@ export interface NumberFormatInternal extends NumberFormatDigitInternalSlots {
     boundFormat?: Intl.NumberFormat['format'];
     numberingSystem: string;
     dataLocaleData: NumberFormatLocaleInternalData;
-    roundingMode?: RoundingModeType;
+    roundingMode: RoundingModeType;
 }
 export type NumberFormatOptions = Omit<Intl.NumberFormatOptions, 'signDisplay' | 'useGrouping'> & NumberFormatDigitOptions & {
     localeMatcher?: NumberFormatOptionsLocaleMatcher;

package/utils.d.ts

@@ -1,8 +1,3 @@
-/**
- * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue
- * @param x number
- */
-export declare function getMagnitude(x: number): number;
 export declare function repeat(s: string, times: number): string;
 export declare function setInternalSlot<Instance extends object, Internal extends object, Field extends keyof Internal>(map: WeakMap<Instance, Internal>, pl: Instance, field: Field, value: NonNullable<Internal>[Field]): void;
 export declare function setMultiInternalSlots<Instance extends object, Internal extends object, K extends keyof Internal>(map: WeakMap<Instance, Internal>, pl: Instance, props: Pick<NonNullable<Internal>, K>): void;

package/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMemoizedListFormat = exports.createMemoizedLocale = exports.createMemoizedPluralRules = exports.createMemoizedDateTimeFormat = exports.createMemoizedNumberFormat = exports.UNICODE_EXTENSION_SEQUENCE_REGEX = void 0;
-exports.getMagnitude = getMagnitude;
 exports.repeat = repeat;
 exports.setInternalSlot = setInternalSlot;
 exports.setMultiInternalSlots = setMultiInternalSlots;
@@ -13,15 +12,6 @@ exports.createDataProperty = createDataProperty;
 exports.invariant = invariant;
 var tslib_1 = require("tslib");
 var fast_memoize_1 = require("@formatjs/fast-memoize");
-/**
- * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue
- * @param x number
- */
-function getMagnitude(x) {
-    // Cannot count string length via Number.toString because it may use scientific notation
-    // for very small or very large numbers.
-    return Math.floor(Math.log(x) * Math.LOG10E);
-}
 function repeat(s, times) {
     if (typeof s.repeat === 'function') {
         return s.repeat(times);