@formatjs/ecma402-abstract 2.2.5 → 2.3.1

package/lib/NumberFormat/FormatNumericToString.js

@@ -1,41 +1,83 @@
-import { SameValue } from '../262';
-import { ToRawPrecision } from './ToRawPrecision';
-import { repeat } from '../utils';
+import { NEGATIVE_ZERO, ZERO } from '../constants';
+import { invariant, repeat } from '../utils';
+import { GetUnsignedRoundingMode } from './GetUnsignedRoundingMode';
 import { ToRawFixed } from './ToRawFixed';
+import { ToRawPrecision } from './ToRawPrecision';
 /**
  * https://tc39.es/ecma402/#sec-formatnumberstring
  */
 export function FormatNumericToString(intlObject, x) {
-    var isNegative = x < 0 || SameValue(x, -0);
-    if (isNegative) {
-        x = -x;
+    var sign;
+    // -0
+    if (x.isZero() && x.isNegative()) {
+        sign = 'negative';
+        x = ZERO;
+    }
+    else {
+        invariant(x.isFinite(), 'NumberFormatDigitInternalSlots value is not finite');
+        if (x.lessThan(0)) {
+            sign = 'negative';
+        }
+        else {
+            sign = 'positive';
+        }
+        if (sign === 'negative') {
+            x = x.negated();
+        }
     }
     var result;
-    var rourndingType = intlObject.roundingType;
-    switch (rourndingType) {
+    var roundingType = intlObject.roundingType;
+    var unsignedRoundingMode = GetUnsignedRoundingMode(intlObject.roundingMode, sign === 'negative');
+    switch (roundingType) {
         case 'significantDigits':
-            result = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits);
+            result = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
             break;
         case 'fractionDigits':
-            result = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits);
+            result = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits, intlObject.roundingIncrement, unsignedRoundingMode);
             break;
         default:
-            result = ToRawPrecision(x, 1, 2);
-            if (result.integerDigitsCount > 1) {
-                result = ToRawFixed(x, 0, 0);
+            var sResult = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
+            var fResult = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits, intlObject.roundingIncrement, unsignedRoundingMode);
+            if (intlObject.roundingType === 'morePrecision') {
+                if (sResult.roundingMagnitude <= fResult.roundingMagnitude) {
+                    result = sResult;
+                }
+                else {
+                    result = fResult;
+                }
+            }
+            else {
+                invariant(intlObject.roundingType === 'lessPrecision', 'Invalid roundingType');
+                if (sResult.roundingMagnitude <= fResult.roundingMagnitude) {
+                    result = fResult;
+                }
+                else {
+                    result = sResult;
+                }
             }
             break;
     }
     x = result.roundedNumber;
     var string = result.formattedString;
+    if (intlObject.trailingZeroDisplay === 'stripIfInteger' && x.isInteger()) {
+        var i = string.indexOf('.');
+        if (i > -1) {
+            string = string.slice(0, i);
+        }
+    }
     var int = result.integerDigitsCount;
     var minInteger = intlObject.minimumIntegerDigits;
     if (int < minInteger) {
         var forwardZeros = repeat('0', minInteger - int);
         string = forwardZeros + string;
     }
-    if (isNegative) {
-        x = -x;
+    if (sign === 'negative') {
+        if (x.isZero()) {
+            x = NEGATIVE_ZERO;
+        }
+        else {
+            x = x.negated();
+        }
     }
     return { roundedNumber: x, formattedString: string };
 }

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;