@formatjs/intl-numberformat 4.2.1 → 4.2.6

package/dist/umd/polyfill-with-locales.js

@@ -252,13 +252,7 @@
      */
     function toRawFixed(x, minFraction, maxFraction) {
         var f = maxFraction;
-        var n;
-        {
-            var exactSolve = x * Math.pow(10, f);
-            var roundDown = Math.floor(exactSolve);
-            var roundUp = Math.ceil(exactSolve);
-            n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;
-        }
+        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.
@@ -269,13 +263,9 @@
         }
         else {
             m = n.toString();
-            var idx1 = m.indexOf('.');
-            var idx2 = m.indexOf('e+');
-            var exponent = parseInt(m.substring(idx2 + 2), 10);
-            m =
-                m.substring(0, idx1) +
-                    m.substring(idx1 + 1, idx2) +
-                    repeat('0', exponent - (idx2 - idx1 - 1));
+            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) {
@@ -315,23 +305,38 @@
             xFinal = 0;
         }
         else {
-            e = getMagnitude(x);
-            var n = void 0;
-            {
-                var magnitude = e - p + 1;
-                var exactSolve = 
-                // Preserve floating point precision as much as possible with multiplication.
-                magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);
-                var roundDown = Math.floor(exactSolve);
-                var roundUp = Math.ceil(exactSolve);
-                n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;
+            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;
+            }
+            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);
             }
-            // See: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
-            // No need to worry about scientific notation because it only happens for values >= 1e21,
-            // which has 22 significant digits. So it will at least be divided by 10 here to bring the
-            // value back into non-scientific-notation range.
-            m = n.toString();
-            xFinal = n * Math.pow(10, (e - p + 1));
         }
         var int;
         if (e >= p - 1) {
@@ -357,6 +362,10 @@
             }
         }
         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);
+        }
     }
     function repeat(s, times) {
         if (typeof s.repeat === 'function') {
@@ -4692,6 +4701,18 @@
     var polyfill = createCommonjsModule(function (module, exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
 
+    if (typeof Intl === 'undefined') {
+        if (typeof window !== 'undefined') {
+            Object.defineProperty(window, 'Intl', {
+                value: {},
+            });
+        }
+        else if (typeof commonjsGlobal !== 'undefined') {
+            Object.defineProperty(commonjsGlobal, 'Intl', {
+                value: {},
+            });
+        }
+    }
     if (!('getCanonicalLocales' in Intl) ||
         // Native Intl.getCanonicalLocales is just buggy
         Intl.getCanonicalLocales('und-x-private')[0] === 'x-private') {