@formatjs/ecma402-abstract 1.11.9 → 1.11.10

package/GetOptionsObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOptionsObject = void 0;
+/**
+ * https://tc39.es/ecma402/#sec-getoptionsobject
+ * @param options
+ * @returns
+ */
+function GetOptionsObject(options) {
+    if (typeof options === 'undefined') {
+        return Object.create(null);
+    }
+    if (typeof options === 'object') {
+        return options;
+    }
+    throw new TypeError('Options must be an object');
+}
+exports.GetOptionsObject = GetOptionsObject;

package/IsSanctionedSimpleUnitIdentifier.d.ts

@@ -0,0 +1,14 @@
+/**
+ * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
+ */
+export declare const SANCTIONED_UNITS: string[];
+export declare function removeUnitNamespace(unit: string): string;
+/**
+ * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
+ */
+export declare const SIMPLE_UNITS: string[];
+/**
+ * https://tc39.es/ecma402/#sec-issanctionedsimpleunitidentifier
+ */
+export declare function IsSanctionedSimpleUnitIdentifier(unitIdentifier: string): boolean;
+//# sourceMappingURL=IsSanctionedSimpleUnitIdentifier.d.ts.map

package/IsSanctionedSimpleUnitIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsSanctionedSimpleUnitIdentifier.d.ts","sourceRoot":"","sources":["IsSanctionedSimpleUnitIdentifier.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB,UA4C5B,CAAA;AAID,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,UAE/C;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,UAA4C,CAAA;AAErE;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,cAAc,EAAE,MAAM,WAEtE"}

package/IsSanctionedSimpleUnitIdentifier.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsSanctionedSimpleUnitIdentifier = exports.SIMPLE_UNITS = exports.removeUnitNamespace = exports.SANCTIONED_UNITS = void 0;
+/**
+ * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
+ */
+exports.SANCTIONED_UNITS = [
+    'angle-degree',
+    'area-acre',
+    'area-hectare',
+    'concentr-percent',
+    'digital-bit',
+    'digital-byte',
+    'digital-gigabit',
+    'digital-gigabyte',
+    'digital-kilobit',
+    'digital-kilobyte',
+    'digital-megabit',
+    'digital-megabyte',
+    'digital-petabyte',
+    'digital-terabit',
+    'digital-terabyte',
+    'duration-day',
+    'duration-hour',
+    'duration-millisecond',
+    'duration-minute',
+    'duration-month',
+    'duration-second',
+    'duration-week',
+    'duration-year',
+    'length-centimeter',
+    'length-foot',
+    'length-inch',
+    'length-kilometer',
+    'length-meter',
+    'length-mile-scandinavian',
+    'length-mile',
+    'length-millimeter',
+    'length-yard',
+    'mass-gram',
+    'mass-kilogram',
+    'mass-ounce',
+    'mass-pound',
+    'mass-stone',
+    'temperature-celsius',
+    'temperature-fahrenheit',
+    'volume-fluid-ounce',
+    'volume-gallon',
+    'volume-liter',
+    'volume-milliliter',
+];
+// In CLDR, the unit name always follows the form `namespace-unit` pattern.
+// For example: `digital-bit` instead of `bit`. This function removes the namespace prefix.
+function removeUnitNamespace(unit) {
+    return unit.slice(unit.indexOf('-') + 1);
+}
+exports.removeUnitNamespace = removeUnitNamespace;
+/**
+ * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
+ */
+exports.SIMPLE_UNITS = exports.SANCTIONED_UNITS.map(removeUnitNamespace);
+/**
+ * https://tc39.es/ecma402/#sec-issanctionedsimpleunitidentifier
+ */
+function IsSanctionedSimpleUnitIdentifier(unitIdentifier) {
+    return exports.SIMPLE_UNITS.indexOf(unitIdentifier) > -1;
+}
+exports.IsSanctionedSimpleUnitIdentifier = IsSanctionedSimpleUnitIdentifier;

package/IsValidTimeZoneName.d.ts

@@ -0,0 +1,10 @@
+/**
+ * https://tc39.es/ecma402/#sec-isvalidtimezonename
+ * @param tz
+ * @param implDetails implementation details
+ */
+export declare function IsValidTimeZoneName(tz: string, { tzData, uppercaseLinks, }: {
+    tzData: Record<string, unknown>;
+    uppercaseLinks: Record<string, string>;
+}): boolean;
+//# sourceMappingURL=IsValidTimeZoneName.d.ts.map

package/IsValidTimeZoneName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsValidTimeZoneName.d.ts","sourceRoot":"","sources":["IsValidTimeZoneName.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EACE,MAAM,EACN,cAAc,GACf,EAAE;IACD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,GACA,OAAO,CAYT"}

package/IsValidTimeZoneName.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsValidTimeZoneName = void 0;
+/**
+ * https://tc39.es/ecma402/#sec-isvalidtimezonename
+ * @param tz
+ * @param implDetails implementation details
+ */
+function IsValidTimeZoneName(tz, _a) {
+    var tzData = _a.tzData, uppercaseLinks = _a.uppercaseLinks;
+    var uppercasedTz = tz.toUpperCase();
+    var zoneNames = new Set();
+    var linkNames = new Set();
+    Object.keys(tzData)
+        .map(function (z) { return z.toUpperCase(); })
+        .forEach(function (z) { return zoneNames.add(z); });
+    Object.keys(uppercaseLinks).forEach(function (linkName) {
+        linkNames.add(linkName.toUpperCase());
+        zoneNames.add(uppercaseLinks[linkName].toUpperCase());
+    });
+    return zoneNames.has(uppercasedTz) || linkNames.has(uppercasedTz);
+}
+exports.IsValidTimeZoneName = IsValidTimeZoneName;

package/IsWellFormedCurrencyCode.d.ts

@@ -0,0 +1,5 @@
+/**
+ * https://tc39.es/ecma402/#sec-iswellformedcurrencycode
+ */
+export declare function IsWellFormedCurrencyCode(currency: string): boolean;
+//# sourceMappingURL=IsWellFormedCurrencyCode.d.ts.map

package/IsWellFormedCurrencyCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsWellFormedCurrencyCode.d.ts","sourceRoot":"","sources":["IsWellFormedCurrencyCode.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CASlE"}

package/IsWellFormedCurrencyCode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsWellFormedCurrencyCode = void 0;
+/**
+ * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping
+ * @param str string to convert
+ */
+function toUpperCase(str) {
+    return str.replace(/([a-z])/g, function (_, c) { return c.toUpperCase(); });
+}
+var NOT_A_Z_REGEX = /[^A-Z]/;
+/**
+ * https://tc39.es/ecma402/#sec-iswellformedcurrencycode
+ */
+function IsWellFormedCurrencyCode(currency) {
+    currency = toUpperCase(currency);
+    if (currency.length !== 3) {
+        return false;
+    }
+    if (NOT_A_Z_REGEX.test(currency)) {
+        return false;
+    }
+    return true;
+}
+exports.IsWellFormedCurrencyCode = IsWellFormedCurrencyCode;

package/IsWellFormedUnitIdentifier.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://tc39.es/ecma402/#sec-iswellformedunitidentifier
+ * @param unit
+ */
+export declare function IsWellFormedUnitIdentifier(unit: string): boolean;
+//# sourceMappingURL=IsWellFormedUnitIdentifier.d.ts.map

package/IsWellFormedUnitIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsWellFormedUnitIdentifier.d.ts","sourceRoot":"","sources":["IsWellFormedUnitIdentifier.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,WAiBtD"}

package/IsWellFormedUnitIdentifier.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsWellFormedUnitIdentifier = void 0;
+var IsSanctionedSimpleUnitIdentifier_1 = require("./IsSanctionedSimpleUnitIdentifier");
+/**
+ * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping
+ * @param str string to convert
+ */
+function toLowerCase(str) {
+    return str.replace(/([A-Z])/g, function (_, c) { return c.toLowerCase(); });
+}
+/**
+ * https://tc39.es/ecma402/#sec-iswellformedunitidentifier
+ * @param unit
+ */
+function IsWellFormedUnitIdentifier(unit) {
+    unit = toLowerCase(unit);
+    if ((0, IsSanctionedSimpleUnitIdentifier_1.IsSanctionedSimpleUnitIdentifier)(unit)) {
+        return true;
+    }
+    var units = unit.split('-per-');
+    if (units.length !== 2) {
+        return false;
+    }
+    var numerator = units[0], denominator = units[1];
+    if (!(0, IsSanctionedSimpleUnitIdentifier_1.IsSanctionedSimpleUnitIdentifier)(numerator) ||
+        !(0, IsSanctionedSimpleUnitIdentifier_1.IsSanctionedSimpleUnitIdentifier)(denominator)) {
+        return false;
+    }
+    return true;
+}
+exports.IsWellFormedUnitIdentifier = IsWellFormedUnitIdentifier;

package/NumberFormat/ComputeExponent.d.ts

@@ -0,0 +1,12 @@
+import { NumberFormatInternal } from '../types/number';
+/**
+ * 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,
+ * requiring a different exponent.
+ *
+ * NOT IN SPEC: it returns [exponent, magnitude].
+ */
+export declare function ComputeExponent(numberFormat: Intl.NumberFormat, x: number, { getInternalSlots, }: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+}): [number, number];
+//# sourceMappingURL=ComputeExponent.d.ts.map

package/NumberFormat/ComputeExponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComputeExponent.d.ts","sourceRoot":"","sources":["ComputeExponent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,oBAAoB,EAAC,MAAM,iBAAiB,CAAA;AAEpD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,IAAI,CAAC,YAAY,EAC/B,CAAC,EAAE,MAAM,EACT,EACE,gBAAgB,GACjB,EAAE;IAAC,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAA;CAAC,GACjE,CAAC,MAAM,EAAE,MAAM,CAAC,CA8BlB"}

package/NumberFormat/ComputeExponent.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputeExponent = void 0;
+var utils_1 = require("../utils");
+var ComputeExponentForMagnitude_1 = require("./ComputeExponentForMagnitude");
+var FormatNumericToString_1 = require("./FormatNumericToString");
+/**
+ * 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,
+ * requiring a different exponent.
+ *
+ * NOT IN SPEC: it returns [exponent, magnitude].
+ */
+function ComputeExponent(numberFormat, x, _a) {
+    var getInternalSlots = _a.getInternalSlots;
+    if (x === 0) {
+        return [0, 0];
+    }
+    if (x < 0) {
+        x = -x;
+    }
+    var magnitude = (0, utils_1.getMagnitude)(x);
+    var exponent = (0, ComputeExponentForMagnitude_1.ComputeExponentForMagnitude)(numberFormat, magnitude, {
+        getInternalSlots: getInternalSlots,
+    });
+    // Preserve more precision by doing multiplication when exponent is negative.
+    x = exponent < 0 ? x * Math.pow(10, -exponent) : x / Math.pow(10, exponent);
+    var formatNumberResult = (0, FormatNumericToString_1.FormatNumericToString)(getInternalSlots(numberFormat), x);
+    if (formatNumberResult.roundedNumber === 0) {
+        return [exponent, magnitude];
+    }
+    var newMagnitude = (0, utils_1.getMagnitude)(formatNumberResult.roundedNumber);
+    if (newMagnitude === magnitude - exponent) {
+        return [exponent, magnitude];
+    }
+    return [
+        (0, ComputeExponentForMagnitude_1.ComputeExponentForMagnitude)(numberFormat, magnitude + 1, {
+            getInternalSlots: getInternalSlots,
+        }),
+        magnitude + 1,
+    ];
+}
+exports.ComputeExponent = ComputeExponent;

package/NumberFormat/ComputeExponentForMagnitude.d.ts

@@ -0,0 +1,10 @@
+import { NumberFormatInternal } from '../types/number';
+/**
+ * The abstract operation ComputeExponentForMagnitude computes an exponent by which to scale a
+ * number of the given magnitude (power of ten of the most significant digit) according to the
+ * locale and the desired notation (scientific, engineering, or compact).
+ */
+export declare function ComputeExponentForMagnitude(numberFormat: Intl.NumberFormat, magnitude: number, { getInternalSlots, }: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+}): number;
+//# sourceMappingURL=ComputeExponentForMagnitude.d.ts.map

package/NumberFormat/ComputeExponentForMagnitude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComputeExponentForMagnitude.d.ts","sourceRoot":"","sources":["ComputeExponentForMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAmB,MAAM,iBAAiB,CAAA;AAEtE;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,IAAI,CAAC,YAAY,EAC/B,SAAS,EAAE,MAAM,EACjB,EACE,gBAAgB,GACjB,EAAE;IAAC,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAA;CAAC,GACjE,MAAM,CAyDR"}

package/NumberFormat/ComputeExponentForMagnitude.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputeExponentForMagnitude = void 0;
+/**
+ * The abstract operation ComputeExponentForMagnitude computes an exponent by which to scale a
+ * number of the given magnitude (power of ten of the most significant digit) according to the
+ * locale and the desired notation (scientific, engineering, or compact).
+ */
+function ComputeExponentForMagnitude(numberFormat, magnitude, _a) {
+    var getInternalSlots = _a.getInternalSlots;
+    var internalSlots = getInternalSlots(numberFormat);
+    var notation = internalSlots.notation, dataLocaleData = internalSlots.dataLocaleData, numberingSystem = internalSlots.numberingSystem;
+    switch (notation) {
+        case 'standard':
+            return 0;
+        case 'scientific':
+            return magnitude;
+        case 'engineering':
+            return Math.floor(magnitude / 3) * 3;
+        default: {
+            // Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a
+            // number of the given magnitude in compact notation for the current locale.
+            var compactDisplay = internalSlots.compactDisplay, style = internalSlots.style, currencyDisplay = internalSlots.currencyDisplay;
+            var thresholdMap = void 0;
+            if (style === 'currency' && currencyDisplay !== 'name') {
+                var currency = dataLocaleData.numbers.currency[numberingSystem] ||
+                    dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]];
+                thresholdMap = currency.short;
+            }
+            else {
+                var decimal = dataLocaleData.numbers.decimal[numberingSystem] ||
+                    dataLocaleData.numbers.decimal[dataLocaleData.numbers.nu[0]];
+                thresholdMap = compactDisplay === 'long' ? decimal.long : decimal.short;
+            }
+            if (!thresholdMap) {
+                return 0;
+            }
+            var num = String(Math.pow(10, magnitude));
+            var thresholds = Object.keys(thresholdMap); // TODO: this can be pre-processed
+            if (num < thresholds[0]) {
+                return 0;
+            }
+            if (num > thresholds[thresholds.length - 1]) {
+                return thresholds[thresholds.length - 1].length - 1;
+            }
+            var i = thresholds.indexOf(num);
+            if (i === -1) {
+                return 0;
+            }
+            // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
+            // Special handling if the pattern is precisely `0`.
+            var magnitudeKey = thresholds[i];
+            // TODO: do we need to handle plural here?
+            var compactPattern = thresholdMap[magnitudeKey].other;
+            if (compactPattern === '0') {
+                return 0;
+            }
+            // Example: in zh-TW, `10000000` maps to `0000萬`. So we need to return 8 - 4 = 4 here.
+            return (magnitudeKey.length -
+                thresholdMap[magnitudeKey].other.match(/0+/)[0].length);
+        }
+    }
+}
+exports.ComputeExponentForMagnitude = ComputeExponentForMagnitude;

package/NumberFormat/CurrencyDigits.d.ts

@@ -0,0 +1,7 @@
+/**
+ * https://tc39.es/ecma402/#sec-currencydigits
+ */
+export declare function CurrencyDigits(c: string, { currencyDigitsData }: {
+    currencyDigitsData: Record<string, number>;
+}): number;
+//# sourceMappingURL=CurrencyDigits.d.ts.map

package/NumberFormat/CurrencyDigits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CurrencyDigits.d.ts","sourceRoot":"","sources":["CurrencyDigits.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,MAAM,EACT,EAAC,kBAAkB,EAAC,EAAE;IAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAC,GACjE,MAAM,CAIR"}

package/NumberFormat/CurrencyDigits.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyDigits = void 0;
+var _262_1 = require("../262");
+/**
+ * https://tc39.es/ecma402/#sec-currencydigits
+ */
+function CurrencyDigits(c, _a) {
+    var currencyDigitsData = _a.currencyDigitsData;
+    return (0, _262_1.HasOwnProperty)(currencyDigitsData, c)
+        ? currencyDigitsData[c]
+        : 2;
+}
+exports.CurrencyDigits = CurrencyDigits;

package/NumberFormat/FormatNumericToParts.d.ts

@@ -0,0 +1,5 @@
+import { NumberFormatInternal, NumberFormatPart } from '../types/number';
+export declare function FormatNumericToParts(nf: Intl.NumberFormat, x: number, implDetails: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+}): NumberFormatPart[];
+//# sourceMappingURL=FormatNumericToParts.d.ts.map

package/NumberFormat/FormatNumericToParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatNumericToParts.d.ts","sourceRoot":"","sources":["FormatNumericToParts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,oBAAoB,EAAE,gBAAgB,EAAC,MAAM,iBAAiB,CAAA;AAEtE,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,IAAI,CAAC,YAAY,EACrB,CAAC,EAAE,MAAM,EACT,WAAW,EAAE;IACX,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAA;CAC9D,GACA,gBAAgB,EAAE,CAWpB"}

package/NumberFormat/FormatNumericToParts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatNumericToParts = void 0;
+var PartitionNumberPattern_1 = require("./PartitionNumberPattern");
+var _262_1 = require("../262");
+function FormatNumericToParts(nf, x, implDetails) {
+    var parts = (0, PartitionNumberPattern_1.PartitionNumberPattern)(nf, x, implDetails);
+    var result = (0, _262_1.ArrayCreate)(0);
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        result.push({
+            type: part.type,
+            value: part.value,
+        });
+    }
+    return result;
+}
+exports.FormatNumericToParts = FormatNumericToParts;

package/NumberFormat/FormatNumericToString.d.ts

@@ -0,0 +1,9 @@
+import { NumberFormatDigitInternalSlots } from '../types/number';
+/**
+ * https://tc39.es/ecma402/#sec-formatnumberstring
+ */
+export declare function FormatNumericToString(intlObject: Pick<NumberFormatDigitInternalSlots, 'roundingType' | 'minimumSignificantDigits' | 'maximumSignificantDigits' | 'minimumIntegerDigits' | 'minimumFractionDigits' | 'maximumFractionDigits'>, x: number): {
+    roundedNumber: number;
+    formattedString: string;
+};
+//# sourceMappingURL=FormatNumericToString.d.ts.map

package/NumberFormat/FormatNumericToString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatNumericToString.d.ts","sourceRoot":"","sources":["FormatNumericToString.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,8BAA8B,EAE/B,MAAM,iBAAiB,CAAA;AAGxB;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,IAAI,CACd,8BAA8B,EAC5B,cAAc,GACd,0BAA0B,GAC1B,0BAA0B,GAC1B,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAC1B,EACD,CAAC,EAAE,MAAM;;;EAgDV"}

package/NumberFormat/FormatNumericToString.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatNumericToString = void 0;
+var _262_1 = require("../262");
+var ToRawPrecision_1 = require("./ToRawPrecision");
+var utils_1 = require("../utils");
+var ToRawFixed_1 = require("./ToRawFixed");
+/**
+ * https://tc39.es/ecma402/#sec-formatnumberstring
+ */
+function FormatNumericToString(intlObject, x) {
+    var isNegative = x < 0 || (0, _262_1.SameValue)(x, -0);
+    if (isNegative) {
+        x = -x;
+    }
+    var result;
+    var rourndingType = intlObject.roundingType;
+    switch (rourndingType) {
+        case 'significantDigits':
+            result = (0, ToRawPrecision_1.ToRawPrecision)(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits);
+            break;
+        case 'fractionDigits':
+            result = (0, ToRawFixed_1.ToRawFixed)(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits);
+            break;
+        default:
+            result = (0, ToRawPrecision_1.ToRawPrecision)(x, 1, 2);
+            if (result.integerDigitsCount > 1) {
+                result = (0, ToRawFixed_1.ToRawFixed)(x, 0, 0);
+            }
+            break;
+    }
+    x = result.roundedNumber;
+    var string = result.formattedString;
+    var int = result.integerDigitsCount;
+    var minInteger = intlObject.minimumIntegerDigits;
+    if (int < minInteger) {
+        var forwardZeros = (0, utils_1.repeat)('0', minInteger - int);
+        string = forwardZeros + string;
+    }
+    if (isNegative) {
+        x = -x;
+    }
+    return { roundedNumber: x, formattedString: string };
+}
+exports.FormatNumericToString = FormatNumericToString;

package/NumberFormat/InitializeNumberFormat.d.ts

@@ -0,0 +1,13 @@
+import { NumberFormatInternal, NumberFormatOptions, NumberFormatLocaleInternalData } from '../types/number';
+/**
+ * https://tc39.es/ecma402/#sec-initializenumberformat
+ */
+export declare function InitializeNumberFormat(nf: Intl.NumberFormat, locales: string | ReadonlyArray<string> | undefined, opts: NumberFormatOptions | undefined, { getInternalSlots, localeData, availableLocales, numberingSystemNames, getDefaultLocale, currencyDigitsData, }: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+    localeData: Record<string, NumberFormatLocaleInternalData | undefined>;
+    availableLocales: Set<string>;
+    numberingSystemNames: ReadonlyArray<string>;
+    getDefaultLocale(): string;
+    currencyDigitsData: Record<string, number>;
+}): Intl.NumberFormat;
+//# sourceMappingURL=InitializeNumberFormat.d.ts.map

package/NumberFormat/InitializeNumberFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializeNumberFormat.d.ts","sourceRoot":"","sources":["InitializeNumberFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,iBAAiB,CAAA;AAUxB;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,IAAI,CAAC,YAAY,EACrB,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,EACnD,IAAI,EAAE,mBAAmB,GAAG,SAAS,EACrC,EACE,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,GACnB,EAAE;IACD,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAA;IAC7D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,GAAG,SAAS,CAAC,CAAA;IACtE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3C,gBAAgB,IAAI,MAAM,CAAA;IAC1B,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3C,qBA+GF"}

package/NumberFormat/InitializeNumberFormat.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializeNumberFormat = void 0;
+var CanonicalizeLocaleList_1 = require("../CanonicalizeLocaleList");
+var GetOption_1 = require("../GetOption");
+var intl_localematcher_1 = require("@formatjs/intl-localematcher");
+var SetNumberFormatUnitOptions_1 = require("./SetNumberFormatUnitOptions");
+var CurrencyDigits_1 = require("./CurrencyDigits");
+var SetNumberFormatDigitOptions_1 = require("./SetNumberFormatDigitOptions");
+var utils_1 = require("../utils");
+var CoerceOptionsToObject_1 = require("../CoerceOptionsToObject");
+/**
+ * https://tc39.es/ecma402/#sec-initializenumberformat
+ */
+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 = (0, CanonicalizeLocaleList_1.CanonicalizeLocaleList)(locales);
+    var options = (0, CoerceOptionsToObject_1.CoerceOptionsToObject)(opts);
+    var opt = Object.create(null);
+    var matcher = (0, GetOption_1.GetOption)(options, 'localeMatcher', 'string', ['lookup', 'best fit'], 'best fit');
+    opt.localeMatcher = matcher;
+    var numberingSystem = (0, GetOption_1.GetOption)(options, 'numberingSystem', 'string', undefined, undefined);
+    if (numberingSystem !== undefined &&
+        numberingSystemNames.indexOf(numberingSystem) < 0) {
+        // 8.a. If numberingSystem does not match the Unicode Locale Identifier type nonterminal,
+        // throw a RangeError exception.
+        throw RangeError("Invalid numberingSystems: ".concat(numberingSystem));
+    }
+    opt.nu = numberingSystem;
+    var r = (0, intl_localematcher_1.ResolveLocale)(availableLocales, requestedLocales, opt, 
+    // [[RelevantExtensionKeys]] slot, which is a constant
+    ['nu'], localeData, getDefaultLocale);
+    var dataLocaleData = localeData[r.dataLocale];
+    (0, utils_1.invariant)(!!dataLocaleData, "Missing locale data for ".concat(r.dataLocale));
+    var internalSlots = getInternalSlots(nf);
+    internalSlots.locale = r.locale;
+    internalSlots.dataLocale = r.dataLocale;
+    internalSlots.numberingSystem = r.nu;
+    internalSlots.dataLocaleData = dataLocaleData;
+    (0, SetNumberFormatUnitOptions_1.SetNumberFormatUnitOptions)(nf, options, { getInternalSlots: getInternalSlots });
+    var style = internalSlots.style;
+    var mnfdDefault;
+    var mxfdDefault;
+    if (style === 'currency') {
+        var currency = internalSlots.currency;
+        var cDigits = (0, CurrencyDigits_1.CurrencyDigits)(currency, { currencyDigitsData: currencyDigitsData });
+        mnfdDefault = cDigits;
+        mxfdDefault = cDigits;
+    }
+    else {
+        mnfdDefault = 0;
+        mxfdDefault = style === 'percent' ? 0 : 3;
+    }
+    var notation = (0, GetOption_1.GetOption)(options, 'notation', 'string', ['standard', 'scientific', 'engineering', 'compact'], 'standard');
+    internalSlots.notation = notation;
+    (0, SetNumberFormatDigitOptions_1.SetNumberFormatDigitOptions)(internalSlots, options, mnfdDefault, mxfdDefault, notation);
+    var compactDisplay = (0, GetOption_1.GetOption)(options, 'compactDisplay', 'string', ['short', 'long'], 'short');
+    if (notation === 'compact') {
+        internalSlots.compactDisplay = compactDisplay;
+    }
+    var useGrouping = (0, GetOption_1.GetOption)(options, 'useGrouping', 'boolean', undefined, true);
+    internalSlots.useGrouping = useGrouping;
+    var signDisplay = (0, GetOption_1.GetOption)(options, 'signDisplay', 'string', ['auto', 'never', 'always', 'exceptZero'], 'auto');
+    internalSlots.signDisplay = signDisplay;
+    return nf;
+}
+exports.InitializeNumberFormat = InitializeNumberFormat;

package/NumberFormat/PartitionNumberPattern.d.ts

@@ -0,0 +1,8 @@
+import { NumberFormatInternal } from '../types/number';
+/**
+ * https://tc39.es/ecma402/#sec-formatnumberstring
+ */
+export declare function PartitionNumberPattern(numberFormat: Intl.NumberFormat, x: number, { getInternalSlots, }: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+}): import("../types/number").NumberFormatPart[];
+//# sourceMappingURL=PartitionNumberPattern.d.ts.map

package/NumberFormat/PartitionNumberPattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartitionNumberPattern.d.ts","sourceRoot":"","sources":["PartitionNumberPattern.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAC,MAAM,iBAAiB,CAAA;AAMpD;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,IAAI,CAAC,YAAY,EAC/B,CAAC,EAAE,MAAM,EACT,EACE,gBAAgB,GACjB,EAAE;IACD,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAA;CAC9D,gDAqEF"}