@formatjs/ecma402-abstract 1.0.3 → 1.2.2

package/lib/src/DateTimeFormat/ToDateTimeOptions.js

@@ -0,0 +1,57 @@
+import { ToObject } from '../../262';
+/**
+ * https://tc39.es/ecma402/#sec-todatetimeoptions
+ * @param options
+ * @param required
+ * @param defaults
+ */
+export function ToDateTimeOptions(options, required, defaults) {
+    if (options === undefined) {
+        options = null;
+    }
+    else {
+        options = ToObject(options);
+    }
+    options = Object.create(options);
+    var needDefaults = true;
+    if (required === 'date' || required === 'any') {
+        for (var _i = 0, _a = ['weekday', 'year', 'month', 'day']; _i < _a.length; _i++) {
+            var prop = _a[_i];
+            var value = options[prop];
+            if (value !== undefined) {
+                needDefaults = false;
+            }
+        }
+    }
+    if (required === 'time' || required === 'any') {
+        for (var _b = 0, _c = ['hour', 'minute', 'second']; _b < _c.length; _b++) {
+            var prop = _c[_b];
+            var value = options[prop];
+            if (value !== undefined) {
+                needDefaults = false;
+            }
+        }
+    }
+    if (options.dateStyle !== undefined || options.timeStyle !== undefined) {
+        needDefaults = false;
+    }
+    if (required === 'date' && options.timeStyle) {
+        throw new TypeError('Intl.DateTimeFormat date was required but timeStyle was included');
+    }
+    if (required === 'time' && options.dateStyle) {
+        throw new TypeError('Intl.DateTimeFormat time was required but dateStyle was included');
+    }
+    if (needDefaults && (defaults === 'date' || defaults === 'all')) {
+        for (var _d = 0, _e = ['year', 'month', 'day']; _d < _e.length; _d++) {
+            var prop = _e[_d];
+            options[prop] = 'numeric';
+        }
+    }
+    if (needDefaults && (defaults === 'time' || defaults === 'all')) {
+        for (var _f = 0, _g = ['hour', 'minute', 'second']; _f < _g.length; _f++) {
+            var prop = _g[_f];
+            options[prop] = 'numeric';
+        }
+    }
+    return options;
+}

package/lib/src/DateTimeFormat/ToLocalTime.d.ts

@@ -0,0 +1,24 @@
+import { UnpackedZoneData } from '../../types/date-time';
+/**
+ * https://tc39.es/ecma402/#sec-tolocaltime
+ * @param t
+ * @param calendar
+ * @param timeZone
+ */
+export declare function ToLocalTime(t: number, calendar: string, timeZone: string, { tzData }: {
+    tzData: Record<string, UnpackedZoneData[]>;
+}): {
+    weekday: number;
+    era: string;
+    year: number;
+    relatedYear: undefined;
+    yearName: undefined;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    inDST: boolean;
+    timeZoneOffset: number;
+};
+//# sourceMappingURL=ToLocalTime.d.ts.map

package/lib/src/DateTimeFormat/ToLocalTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToLocalTime.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/ToLocalTime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAkCvD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,EAAC,MAAM,EAAC,EAAE;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAA;CAAC,GACrD;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,SAAS,CAAC;IACvB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;CACxB,CAyBA"}

package/lib/src/DateTimeFormat/ToLocalTime.js

@@ -0,0 +1,49 @@
+import { invariant } from '../utils';
+import { Type, YearFromTime, WeekDay, MonthFromTime, DateFromTime, HourFromTime, MinFromTime, SecFromTime, } from '../../262';
+function getApplicableZoneData(t, timeZone, tzData) {
+    var _a;
+    var zoneData = tzData[timeZone];
+    // We don't have data for this so just say it's UTC
+    if (!zoneData) {
+        return [0, false];
+    }
+    var i = 0;
+    var offset = 0;
+    var dst = false;
+    for (; i <= zoneData.length; i++) {
+        if (i === zoneData.length || zoneData[i][0] * 1e3 >= t) {
+            _a = zoneData[i - 1], offset = _a[2], dst = _a[3];
+            break;
+        }
+    }
+    return [offset * 1e3, dst];
+}
+/**
+ * https://tc39.es/ecma402/#sec-tolocaltime
+ * @param t
+ * @param calendar
+ * @param timeZone
+ */
+export function ToLocalTime(t, calendar, timeZone, _a) {
+    var tzData = _a.tzData;
+    invariant(Type(t) === 'Number', 'invalid time');
+    invariant(calendar === 'gregory', 'We only support Gregory calendar right now');
+    var _b = getApplicableZoneData(t, timeZone, tzData), timeZoneOffset = _b[0], inDST = _b[1];
+    var tz = t + timeZoneOffset;
+    var year = YearFromTime(tz);
+    return {
+        weekday: WeekDay(tz),
+        era: year < 0 ? 'BC' : 'AD',
+        year: year,
+        relatedYear: undefined,
+        yearName: undefined,
+        month: MonthFromTime(tz),
+        day: DateFromTime(tz),
+        hour: HourFromTime(tz),
+        minute: MinFromTime(tz),
+        second: SecFromTime(tz),
+        inDST: inDST,
+        // IMPORTANT: Not in spec
+        timeZoneOffset: timeZoneOffset,
+    };
+}

package/lib/src/DateTimeFormat/skeleton.d.ts

@@ -0,0 +1,9 @@
+import { Formats } from '../../types/date-time';
+/**
+ * Parse Date time skeleton into Intl.DateTimeFormatOptions
+ * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ * @public
+ * @param skeleton skeleton string
+ */
+export declare function parseDateTimeSkeleton(skeleton: string, pattern?: string): Formats;
+//# sourceMappingURL=skeleton.d.ts.map

package/lib/src/DateTimeFormat/skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/skeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAiJ9C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAiB,GACzB,OAAO,CAqCT"}

package/lib/src/DateTimeFormat/skeleton.js

@@ -0,0 +1,163 @@
+/**
+ * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ * Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js
+ * with some tweaks
+ */
+var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
+// trim patterns after transformations
+var expPatternTrimmer = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+function matchSkeletonPattern(match, result) {
+    if (result === void 0) { result = {
+        pattern: '',
+        pattern12: '',
+        skeleton: '',
+        rawPattern: '',
+    }; }
+    var len = match.length;
+    switch (match[0]) {
+        // Era
+        case 'G':
+            result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
+            return '{era}';
+        // Year
+        case 'y':
+        case 'Y':
+        case 'u':
+        case 'U':
+        case 'r':
+            result.year = len === 2 ? '2-digit' : 'numeric';
+            return '{year}';
+        // Quarter
+        case 'q':
+        case 'Q':
+            throw new RangeError('`w/Q` (quarter) patterns are not supported');
+        // Month
+        case 'M':
+        case 'L':
+            result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];
+            return '{month}';
+        // Week
+        case 'w':
+        case 'W':
+            throw new RangeError('`w/W` (week of year) patterns are not supported');
+        case 'd':
+            result.day = ['numeric', '2-digit'][len - 1];
+            return '{day}';
+        case 'D':
+        case 'F':
+        case 'g':
+            result.day = 'numeric';
+            return '{day}';
+        // Weekday
+        case 'E':
+            result.weekday = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
+            return '{weekday}';
+        case 'e':
+            result.weekday = [
+                'numeric',
+                '2-digit',
+                'short',
+                'long',
+                'narrow',
+                'short',
+            ][len - 1];
+            return '{weekday}';
+        case 'c':
+            result.weekday = [
+                'numeric',
+                undefined,
+                'short',
+                'long',
+                'narrow',
+                'short',
+            ][len - 1];
+            return '{weekday}';
+        // Period
+        case 'a': // AM, PM
+        case 'b': // am, pm, noon, midnight
+        case 'B': // flexible day periods
+            result.hour12 = true;
+            return '{ampm}';
+        // Hour
+        case 'h':
+            result.hour = ['numeric', '2-digit'][len - 1];
+            return '{hour}';
+        case 'H':
+            result.hour = ['numeric', '2-digit'][len - 1];
+            return '{hour}';
+        case 'K':
+            result.hour = ['numeric', '2-digit'][len - 1];
+            return '{hour}';
+        case 'k':
+            result.hour = ['numeric', '2-digit'][len - 1];
+            return '{hour}';
+        case 'j':
+        case 'J':
+        case 'C':
+            throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');
+        // Minute
+        case 'm':
+            result.minute = ['numeric', '2-digit'][len - 1];
+            return '{minute}';
+        // Second
+        case 's':
+            result.second = ['numeric', '2-digit'][len - 1];
+            return '{second}';
+        case 'S':
+        case 'A':
+            result.second = 'numeric';
+            return '{second}';
+        // Zone
+        case 'z': // 1..3, 4: specific non-location format
+        case 'Z': // 1..3, 4, 5: The ISO8601 varios formats
+        case 'O': // 1, 4: miliseconds in day short, long
+        case 'v': // 1, 4: generic non-location format
+        case 'V': // 1, 2, 3, 4: time zone ID or city
+        case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
+        case 'x': // 1, 2, 3, 4: The ISO8601 varios formats
+            result.timeZoneName = len < 4 ? 'short' : 'long';
+            return '{timeZoneName}';
+    }
+    return '';
+}
+/**
+ * Parse Date time skeleton into Intl.DateTimeFormatOptions
+ * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ * @public
+ * @param skeleton skeleton string
+ */
+export function parseDateTimeSkeleton(skeleton, pattern) {
+    if (pattern === void 0) { pattern = skeleton; }
+    var result = {
+        pattern: '',
+        pattern12: '',
+        skeleton: skeleton,
+        rawPattern: pattern,
+    };
+    var literals = [];
+    // Use skeleton to populate result, but use mapped pattern to populate pattern
+    result.pattern12 = pattern
+        // Double apostrophe
+        .replace(/'{2}/g, '{apostrophe}')
+        // Apostrophe-escaped
+        .replace(/'(.*?)'/g, function (_, literal) {
+        literals.push(literal);
+        return "$$" + (literals.length - 1) + "$$";
+    })
+        .replace(DATE_TIME_REGEX, matchSkeletonPattern);
+    skeleton.replace(DATE_TIME_REGEX, function (m) { return matchSkeletonPattern(m, result); });
+    //Restore literals
+    if (literals.length) {
+        result.pattern12 = result.pattern12
+            .replace(/\$\$(\d+)\$\$/g, function (_, i) {
+            return literals[+i];
+        })
+            .replace(/\{apostrophe\}/g, "'");
+    }
+    // Handle apostrophe-escaped things
+    result.pattern = result.pattern12
+        .replace(/([\s\uFEFF\xA0])\{ampm\}([\s\uFEFF\xA0])/, '$1')
+        .replace('{ampm}', '')
+        .replace(expPatternTrimmer, '');
+    return result;
+}

package/lib/src/DateTimeFormat/utils.d.ts

@@ -0,0 +1,10 @@
+import { IntlDateTimeFormatInternal, TABLE_6 } from '../../types/date-time';
+export declare const DATE_TIME_PROPS: Array<keyof Pick<IntlDateTimeFormatInternal, TABLE_6>>;
+export declare const removalPenalty = 120;
+export declare const additionPenalty = 20;
+export declare const differentNumericTypePenalty = 15;
+export declare const longLessPenalty = 8;
+export declare const longMorePenalty = 6;
+export declare const shortLessPenalty = 6;
+export declare const shortMorePenalty = 3;
+//# sourceMappingURL=utils.d.ts.map

package/lib/src/DateTimeFormat/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,0BAA0B,EAAE,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAE1E,eAAO,MAAM,eAAe,EAAE,KAAK,CACjC,MAAM,IAAI,CAAC,0BAA0B,EAAE,OAAO,CAAC,CAWhD,CAAC;AAEF,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,gBAAgB,IAAI,CAAC"}

package/lib/src/DateTimeFormat/utils.js

@@ -0,0 +1,18 @@
+export var DATE_TIME_PROPS = [
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+];
+export var removalPenalty = 120;
+export var additionPenalty = 20;
+export var differentNumericTypePenalty = 15;
+export var longLessPenalty = 8;
+export var longMorePenalty = 6;
+export var shortLessPenalty = 6;
+export var shortMorePenalty = 3;

package/lib/src/DisplayNames/CanonicalCodeForDisplayNames.d.ts

@@ -0,0 +1,2 @@
+export declare function CanonicalCodeForDisplayNames(type: 'language' | 'region' | 'script' | 'currency', code: string): any;
+//# sourceMappingURL=CanonicalCodeForDisplayNames.d.ts.map

package/lib/src/DisplayNames/CanonicalCodeForDisplayNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanonicalCodeForDisplayNames.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DisplayNames/CanonicalCodeForDisplayNames.ts"],"names":[],"mappings":"AAcA,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,EACnD,IAAI,EAAE,MAAM,OAsBb"}

package/lib/src/DisplayNames/CanonicalCodeForDisplayNames.js

@@ -0,0 +1,33 @@
+import { CanonicalizeLocaleList } from '../CanonicalizeLocaleList';
+import { invariant } from '../utils';
+import { IsWellFormedCurrencyCode } from '../IsWellFormedCurrencyCode';
+var UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
+var ALPHA_4 = /^[a-z]{4}$/i;
+function isUnicodeRegionSubtag(region) {
+    return UNICODE_REGION_SUBTAG_REGEX.test(region);
+}
+function isUnicodeScriptSubtag(script) {
+    return ALPHA_4.test(script);
+}
+export function CanonicalCodeForDisplayNames(type, code) {
+    if (type === 'language') {
+        return CanonicalizeLocaleList([code])[0];
+    }
+    if (type === 'region') {
+        if (!isUnicodeRegionSubtag(code)) {
+            throw RangeError('invalid region');
+        }
+        return code.toUpperCase();
+    }
+    if (type === 'script') {
+        if (!isUnicodeScriptSubtag(code)) {
+            throw RangeError('invalid script');
+        }
+        return "" + code[0].toUpperCase() + code.slice(1);
+    }
+    invariant(type === 'currency', 'invalid type');
+    if (!IsWellFormedCurrencyCode(code)) {
+        throw RangeError('invalid currency');
+    }
+    return code.toUpperCase();
+}

package/lib/src/GetOption.js

@@ -1,4 +1,4 @@
-import ToString from 'es-abstract/2019/ToString';
+import { ToString } from '../262';
 /**
  * https://tc39.es/ecma402/#sec-getoption
  * @param opts

package/lib/src/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, unknown>;
+}): boolean;
+//# sourceMappingURL=IsValidTimeZoneName.d.ts.map

package/lib/src/IsValidTimeZoneName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsValidTimeZoneName.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ecma402-abstract/src/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,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC,GACA,OAAO,CAIT"}

package/lib/src/IsValidTimeZoneName.js

@@ -0,0 +1,11 @@
+/**
+ * https://tc39.es/ecma402/#sec-isvalidtimezonename
+ * @param tz
+ * @param implDetails implementation details
+ */
+export function IsValidTimeZoneName(tz, _a) {
+    var tzData = _a.tzData, uppercaseLinks = _a.uppercaseLinks;
+    var uppercasedTz = tz.toUpperCase();
+    var zoneNames = new Set(Object.keys(tzData).map(function (z) { return z.toUpperCase(); }));
+    return zoneNames.has(uppercasedTz) || uppercasedTz in uppercaseLinks;
+}

package/lib/src/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/lib/src/NumberFormat/ComputeExponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComputeExponent.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/NumberFormat/ComputeExponent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,oBAAoB,EAAC,MAAM,oBAAoB,CAAC;AAExD;;;;;;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/lib/src/NumberFormat/ComputeExponent.js

@@ -0,0 +1,39 @@
+import { getMagnitude } from '../utils';
+import { ComputeExponentForMagnitude } from './ComputeExponentForMagnitude';
+import { FormatNumericToString } from './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].
+ */
+export function ComputeExponent(numberFormat, x, _a) {
+    var getInternalSlots = _a.getInternalSlots;
+    if (x === 0) {
+        return [0, 0];
+    }
+    if (x < 0) {
+        x = -x;
+    }
+    var magnitude = getMagnitude(x);
+    var exponent = 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 = FormatNumericToString(getInternalSlots(numberFormat), x);
+    if (formatNumberResult.roundedNumber === 0) {
+        return [exponent, magnitude];
+    }
+    var newMagnitude = getMagnitude(formatNumberResult.roundedNumber);
+    if (newMagnitude === magnitude - exponent) {
+        return [exponent, magnitude];
+    }
+    return [
+        ComputeExponentForMagnitude(numberFormat, magnitude + 1, {
+            getInternalSlots: getInternalSlots,
+        }),
+        magnitude + 1,
+    ];
+}

package/lib/src/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/lib/src/NumberFormat/ComputeExponentForMagnitude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComputeExponentForMagnitude.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/NumberFormat/ComputeExponentForMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAmB,MAAM,oBAAoB,CAAC;AAE1E;;;;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/lib/src/NumberFormat/ComputeExponentForMagnitude.js

@@ -0,0 +1,60 @@
+/**
+ * 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 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);
+        }
+    }
+}

package/lib/src/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/lib/src/NumberFormat/CurrencyDigits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CurrencyDigits.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/NumberFormat/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/lib/src/NumberFormat/CurrencyDigits.js

@@ -0,0 +1,10 @@
+import { HasOwnProperty } from '../../262';
+/**
+ * https://tc39.es/ecma402/#sec-currencydigits
+ */
+export function CurrencyDigits(c, _a) {
+    var currencyDigitsData = _a.currencyDigitsData;
+    return HasOwnProperty(currencyDigitsData, c)
+        ? currencyDigitsData[c]
+        : 2;
+}

package/lib/src/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/lib/src/NumberFormat/FormatNumericToParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatNumericToParts.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/NumberFormat/FormatNumericToParts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,oBAAoB,EAAE,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAE1E,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,CAAC;CAC/D,GACA,gBAAgB,EAAE,CAWpB"}

package/lib/src/NumberFormat/FormatNumericToParts.js

@@ -0,0 +1,14 @@
+import { PartitionNumberPattern } from './PartitionNumberPattern';
+import { ArrayCreate } from '../../262';
+export function FormatNumericToParts(nf, x, implDetails) {
+    var parts = PartitionNumberPattern(nf, x, implDetails);
+    var result = 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;
+}

package/lib/src/NumberFormat/FormatNumericToString.js

@@ -1,4 +1,4 @@
-import SameValue from 'es-abstract/5/SameValue';
+import { SameValue } from '../../262';
 import { ToRawPrecision } from './ToRawPrecision';
 import { repeat } from '../utils';
 import { ToRawFixed } from './ToRawFixed';

package/lib/src/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 | string[] | undefined, opts: NumberFormatOptions | undefined, { getInternalSlots, localeData, availableLocales, numberingSystemNames, getDefaultLocale, currencyDigitsData, }: {
+    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal;
+    localeData: Record<string, NumberFormatLocaleInternalData>;
+    availableLocales: string[];
+    numberingSystemNames: string[];
+    getDefaultLocale(): string;
+    currencyDigitsData: Record<string, number>;
+}): Intl.NumberFormat;
+//# sourceMappingURL=InitializeNumberFormat.d.ts.map

package/lib/src/NumberFormat/InitializeNumberFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializeNumberFormat.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/NumberFormat/InitializeNumberFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,oBAAoB,CAAC;AAmB5B;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,IAAI,CAAC,YAAY,EACrB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,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,CAAC;IAC9D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;IAC3D,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,gBAAgB,IAAI,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,qBAgHF"}