@formatjs/ecma402-abstract 3.0.2 → 3.0.4

package/NumberFormat/ComputeExponent.js

@@ -1,6 +1,7 @@
 import { Decimal } from 'decimal.js';
 import { ComputeExponentForMagnitude } from './ComputeExponentForMagnitude.js';
 import { FormatNumericToString } from './FormatNumericToString.js';
+import { getPowerOf10 } from './decimal-cache.js';
 /**
  * The abstract operation ComputeExponent computes an exponent (power of ten) by which to scale x
  * according to the number formatting settings. It handles cases such as 999 rounding up to 1000,
@@ -15,15 +16,41 @@ export function ComputeExponent(internalSlots, x) {
     if (x.isNegative()) {
         x = x.negated();
     }
-    var magnitude = x.log(10).floor();
+    // Fast path for simple numbers
+    // If x can be represented as a safe integer, use native Math.log10
+    var xNum = x.toNumber();
+    var magnitude;
+    if (Number.isFinite(xNum) &&
+        Number.isSafeInteger(xNum) &&
+        xNum > 0 &&
+        xNum <= 999999) {
+        // Use fast native logarithm for simple positive integers
+        var magNum = Math.floor(Math.log10(xNum));
+        magnitude = new Decimal(magNum);
+    }
+    else {
+        magnitude = x.log(10).floor();
+    }
     var exponent = ComputeExponentForMagnitude(internalSlots, magnitude);
     // Preserve more precision by doing multiplication when exponent is negative.
-    x = x.times(Decimal.pow(10, -exponent));
+    x = x.times(getPowerOf10(-exponent));
     var formatNumberResult = FormatNumericToString(internalSlots, x);
     if (formatNumberResult.roundedNumber.isZero()) {
         return [exponent, magnitude.toNumber()];
     }
-    var newMagnitude = formatNumberResult.roundedNumber.log(10).floor();
+    // Fast path for simple rounded numbers
+    var roundedNum = formatNumberResult.roundedNumber.toNumber();
+    var newMagnitude;
+    if (Number.isFinite(roundedNum) &&
+        Number.isSafeInteger(roundedNum) &&
+        roundedNum > 0 &&
+        roundedNum <= 999999) {
+        var newMagNum = Math.floor(Math.log10(roundedNum));
+        newMagnitude = new Decimal(newMagNum);
+    }
+    else {
+        newMagnitude = formatNumberResult.roundedNumber.log(10).floor();
+    }
     if (newMagnitude.eq(magnitude.minus(exponent))) {
         return [exponent, magnitude.toNumber()];
     }

package/NumberFormat/ComputeExponentForMagnitude.js

@@ -1,5 +1,6 @@
 import { Decimal } from 'decimal.js';
 import { invariant } from '../utils.js';
+import { getPowerOf10 } from './decimal-cache.js';
 Decimal.set({
     toExpPos: 100,
 });
@@ -37,7 +38,7 @@ export function ComputeExponentForMagnitude(internalSlots, magnitude) {
             if (!thresholdMap) {
                 return 0;
             }
-            var num = Decimal.pow(10, magnitude).toString();
+            var num = getPowerOf10(magnitude).toString();
             var thresholds = Object.keys(thresholdMap); // TODO: this can be pre-processed
             if (num < thresholds[0]) {
                 return 0;

package/NumberFormat/PartitionNumberPattern.js

@@ -1,8 +1,8 @@
-import { Decimal } from 'decimal.js';
 import { invariant } from '../utils.js';
 import { ComputeExponent } from './ComputeExponent.js';
 import formatToParts from './format_to_parts.js';
 import { FormatNumericToString } from './FormatNumericToString.js';
+import { getPowerOf10 } from './decimal-cache.js';
 /**
  * https://tc39.es/ecma402/#sec-partitionnumberpattern
  */
@@ -45,7 +45,7 @@ export function PartitionNumberPattern(internalSlots, _x) {
             // IMPL: We need to record the magnitude of the number
             magnitude = _a[1];
             // 8.d. Let x be x × 10^(-exponent).
-            x = x.times(Decimal.pow(10, -exponent));
+            x = x.times(getPowerOf10(-exponent));
         }
         // 8.e. Let formatNumberResult be FormatNumericToString(internalSlots, x).
         var formatNumberResult = FormatNumericToString(internalSlots, x);

package/NumberFormat/ToRawFixed.js

@@ -1,17 +1,18 @@
 import { Decimal } from 'decimal.js';
 import { repeat } from '../utils.js';
 import { ApplyUnsignedRoundingMode } from './ApplyUnsignedRoundingMode.js';
+import { getPowerOf10 } from './decimal-cache.js';
 //IMPL: Setting Decimal configuration
 Decimal.set({
     toExpPos: 100,
 });
 //IMPL: Helper function to calculate raw fixed value
 function ToRawFixedFn(n, f) {
-    return n.times(Decimal.pow(10, -f));
+    return n.times(getPowerOf10(-f));
 }
 //IMPL: Helper function to find n1 and r1
 function findN1R1(x, f, roundingIncrement) {
-    var nx = x.times(Decimal.pow(10, f)).floor();
+    var nx = x.times(getPowerOf10(f)).floor();
     var n1 = nx.div(roundingIncrement).floor().times(roundingIncrement);
     var r1 = ToRawFixedFn(n1, f);
     return {
@@ -21,7 +22,7 @@ function findN1R1(x, f, roundingIncrement) {
 }
 //IMPL: Helper function to find n2 and r2
 function findN2R2(x, f, roundingIncrement) {
-    var nx = x.times(Decimal.pow(10, f)).ceil();
+    var nx = x.times(getPowerOf10(f)).ceil();
     var n2 = nx.div(roundingIncrement).ceil().times(roundingIncrement);
     var r2 = ToRawFixedFn(n2, f);
     return {

package/NumberFormat/ToRawPrecision.js

@@ -1,17 +1,52 @@
-import { Decimal } from 'decimal.js';
 import { ZERO } from '../constants.js';
 import { invariant, repeat } from '../utils.js';
 import { ApplyUnsignedRoundingMode } from './ApplyUnsignedRoundingMode.js';
-//IMPL: Helper function to find n1, e1, and r1
+import { getPowerOf10 } from './decimal-cache.js';
+//IMPL: Helper function to find n1, e1, and r1 using direct calculation
 function findN1E1R1(x, p) {
-    var maxN1 = Decimal.pow(10, p);
-    var minN1 = Decimal.pow(10, p - 1);
+    var maxN1 = getPowerOf10(p);
+    var minN1 = getPowerOf10(p - 1);
+    // Direct calculation: compute e1 from logarithm
+    // e1 is the exponent such that n1 * 10^(e1-p+1) <= x
+    // Taking log: log(n1) + (e1-p+1)*log(10) <= log(x)
+    // Since n1 is between 10^(p-1) and 10^p, we have:
+    // (p-1) + (e1-p+1) <= log10(x) < p + (e1-p+1)
+    // Simplifying: e1 <= log10(x) < e1 + 1
+    // Therefore: e1 = floor(log10(x))
+    var log10x = x.log(10);
+    var e1 = log10x.floor();
+    // Calculate n1 and r1 from e1
+    var divisor = getPowerOf10(e1.minus(p).plus(1));
+    var n1 = x.div(divisor).floor();
+    var r1 = n1.times(divisor);
+    // Verify and adjust if n1 is out of bounds
+    // This handles edge cases near powers of 10
+    if (n1.greaterThanOrEqualTo(maxN1)) {
+        e1 = e1.plus(1);
+        var newDivisor = getPowerOf10(e1.minus(p).plus(1));
+        n1 = x.div(newDivisor).floor();
+        r1 = n1.times(newDivisor);
+    }
+    else if (n1.lessThan(minN1)) {
+        e1 = e1.minus(1);
+        var newDivisor = getPowerOf10(e1.minus(p).plus(1));
+        n1 = x.div(newDivisor).floor();
+        r1 = n1.times(newDivisor);
+    }
+    // Final verification with fallback to iterative search if needed
+    if (r1.lessThanOrEqualTo(x) &&
+        n1.lessThan(maxN1) &&
+        n1.greaterThanOrEqualTo(minN1)) {
+        return { n1: n1, e1: e1, r1: r1 };
+    }
+    // Fallback: iterative search (should rarely be needed)
     var maxE1 = x.div(minN1).log(10).plus(p).minus(1).ceil();
     var currentE1 = maxE1;
     while (true) {
-        var currentN1 = x.div(Decimal.pow(10, currentE1.minus(p).plus(1))).floor();
+        var currentDivisor = getPowerOf10(currentE1.minus(p).plus(1));
+        var currentN1 = x.div(currentDivisor).floor();
         if (currentN1.lessThan(maxN1) && currentN1.greaterThanOrEqualTo(minN1)) {
-            var currentR1 = currentN1.times(Decimal.pow(10, currentE1.minus(p).plus(1)));
+            var currentR1 = currentN1.times(currentDivisor);
             if (currentR1.lessThanOrEqualTo(x)) {
                 return {
                     n1: currentN1,
@@ -23,16 +58,44 @@ function findN1E1R1(x, p) {
         currentE1 = currentE1.minus(1);
     }
 }
-//IMPL: Helper function to find n2, e2, and r2
+//IMPL: Helper function to find n2, e2, and r2 using direct calculation
 function findN2E2R2(x, p) {
-    var maxN2 = Decimal.pow(10, p);
-    var minN2 = Decimal.pow(10, p - 1);
+    var maxN2 = getPowerOf10(p);
+    var minN2 = getPowerOf10(p - 1);
+    // Direct calculation: similar to findN1E1R1 but with ceiling
+    var log10x = x.log(10);
+    var e2 = log10x.floor();
+    // Calculate n2 and r2 from e2
+    var divisor = getPowerOf10(e2.minus(p).plus(1));
+    var n2 = x.div(divisor).ceil();
+    var r2 = n2.times(divisor);
+    // Verify and adjust if n2 is out of bounds
+    if (n2.greaterThanOrEqualTo(maxN2)) {
+        e2 = e2.plus(1);
+        var newDivisor = getPowerOf10(e2.minus(p).plus(1));
+        n2 = x.div(newDivisor).ceil();
+        r2 = n2.times(newDivisor);
+    }
+    else if (n2.lessThan(minN2)) {
+        e2 = e2.minus(1);
+        var newDivisor = getPowerOf10(e2.minus(p).plus(1));
+        n2 = x.div(newDivisor).ceil();
+        r2 = n2.times(newDivisor);
+    }
+    // Final verification with fallback to iterative search if needed
+    if (r2.greaterThanOrEqualTo(x) &&
+        n2.lessThan(maxN2) &&
+        n2.greaterThanOrEqualTo(minN2)) {
+        return { n2: n2, e2: e2, r2: r2 };
+    }
+    // Fallback: iterative search (should rarely be needed)
     var minE2 = x.div(maxN2).log(10).plus(p).minus(1).floor();
     var currentE2 = minE2;
     while (true) {
-        var currentN2 = x.div(Decimal.pow(10, currentE2.minus(p).plus(1))).ceil();
+        var currentDivisor = getPowerOf10(currentE2.minus(p).plus(1));
+        var currentN2 = x.div(currentDivisor).ceil();
         if (currentN2.lessThan(maxN2) && currentN2.greaterThanOrEqualTo(minN2)) {
-            var currentR2 = currentN2.times(Decimal.pow(10, currentE2.minus(p).plus(1)));
+            var currentR2 = currentN2.times(currentDivisor);
             if (currentR2.greaterThanOrEqualTo(x)) {
                 return {
                     n2: currentN2,

package/NumberFormat/decimal-cache.d.ts

@@ -0,0 +1,12 @@
+import { Decimal } from 'decimal.js';
+/**
+ * Cached function to compute powers of 10 for Decimal.js operations.
+ * This cache significantly reduces overhead in ComputeExponent and ToRawFixed
+ * by memoizing expensive Decimal.pow(10, n) calculations.
+ *
+ * Common exponents (e.g., -20 to 20) are used repeatedly in number formatting,
+ * so caching provides substantial performance benefits.
+ *
+ * @param exponent - Can be a number or Decimal. If Decimal, it will be converted to string for cache key.
+ */
+export declare const getPowerOf10: (exponent: number | Decimal) => Decimal;

package/NumberFormat/decimal-cache.js

@@ -0,0 +1,15 @@
+import { Decimal } from 'decimal.js';
+import { memoize } from '@formatjs/fast-memoize';
+/**
+ * Cached function to compute powers of 10 for Decimal.js operations.
+ * This cache significantly reduces overhead in ComputeExponent and ToRawFixed
+ * by memoizing expensive Decimal.pow(10, n) calculations.
+ *
+ * Common exponents (e.g., -20 to 20) are used repeatedly in number formatting,
+ * so caching provides substantial performance benefits.
+ *
+ * @param exponent - Can be a number or Decimal. If Decimal, it will be converted to string for cache key.
+ */
+export var getPowerOf10 = memoize(function (exponent) {
+    return Decimal.pow(10, exponent);
+});

package/NumberFormat/format_to_parts.js

@@ -1,5 +1,6 @@
 import { Decimal } from 'decimal.js';
 import { S_UNICODE_REGEX } from '../regex.generated.js';
+import { getPowerOf10 } from './decimal-cache.js';
 import { digitMapping } from './digit-mapping.generated.js';
 import { GetUnsignedRoundingMode } from './GetUnsignedRoundingMode.js';
 import { ToRawFixed } from './ToRawFixed.js';
@@ -163,9 +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
-                        .times(Decimal.pow(10, exponent))
-                        .toNumber(), currencyNameData.displayName);
+                    unitName = selectPlural(pl, numberResult.roundedNumber.times(getPowerOf10(exponent)).toNumber(), currencyNameData.displayName);
                 }
                 else {
                     // Fallback for unknown currency
@@ -202,9 +201,7 @@ export default function formatToParts(numberResult, data, pl, options) {
             var unitPattern = void 0;
             if (unitData) {
                 // Simple unit pattern
-                unitPattern = selectPlural(pl, numberResult.roundedNumber
-                    .times(Decimal.pow(10, exponent))
-                    .toNumber(), data.units.simple[unit][unitDisplay]);
+                unitPattern = selectPlural(pl, numberResult.roundedNumber.times(getPowerOf10(exponent)).toNumber(), data.units.simple[unit][unitDisplay]);
             }
             else {
                 // See: http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
@@ -212,9 +209,7 @@ 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(Decimal.pow(10, exponent))
-                    .toNumber(), data.units.simple[numeratorUnit][unitDisplay]);
+                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber.times(getPowerOf10(exponent)).toNumber(), data.units.simple[numeratorUnit][unitDisplay]);
                 var perUnitPattern = data.units.simple[denominatorUnit].perUnit[unitDisplay];
                 if (perUnitPattern) {
                     // perUnitPattern exists, combine it with numeratorUnitPattern

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formatjs/ecma402-abstract",
   "description": "A collection of implementation for ECMAScript abstract operations",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "license": "MIT",
   "author": "Long Ho <holevietlong@gmail.com",
   "type": "module",
@@ -13,8 +13,8 @@
   "dependencies": {
     "decimal.js": "^10.4.3",
     "tslib": "^2.8.0",
-    "@formatjs/intl-localematcher": "0.7.2",
-    "@formatjs/fast-memoize": "3.0.1"
+    "@formatjs/fast-memoize": "3.0.1",
+    "@formatjs/intl-localematcher": "0.7.2"
   },
   "bugs": "https://github.com/formatjs/formatjs/issues",
   "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c",

package/types/date-time.d.ts

@@ -74,6 +74,15 @@ export interface DateTimeFormatLocaleInternalData {
         long: string[];
         short: string[];
     };
+    /**
+     * Stand-alone month names (used when month appears without other date fields)
+     * Falls back to format month if not provided
+     */
+    monthStandalone?: {
+        narrow: string[];
+        long: string[];
+        short: string[];
+    };
     timeZoneName: TimeZoneNameData;
     /**
      * So we can construct GMT+08:00