@formatjs/ecma402-abstract 1.0.3 → 1.2.2

package/src/DateTimeFormat/PartitionDateTimePattern.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartitionDateTimePattern = void 0;
+var _262_1 = require("../../262");
+var PartitionPattern_1 = require("../PartitionPattern");
+var utils_1 = require("./utils");
+var ToLocalTime_1 = require("./ToLocalTime");
+function pad(n) {
+    if (n < 10) {
+        return "0" + n;
+    }
+    return String(n);
+}
+function offsetToGmtString(gmtFormat, hourFormat, offsetInMs, style) {
+    var offsetInMinutes = Math.floor(offsetInMs / 60000);
+    var mins = Math.abs(offsetInMinutes) % 60;
+    var hours = Math.floor(Math.abs(offsetInMinutes) / 60);
+    var _a = hourFormat.split(';'), positivePattern = _a[0], negativePattern = _a[1];
+    var offsetStr = '';
+    var pattern = offsetInMs < 0 ? negativePattern : positivePattern;
+    if (style === 'long') {
+        offsetStr = pattern
+            .replace('HH', pad(hours))
+            .replace('H', String(hours))
+            .replace('mm', pad(mins))
+            .replace('m', String(mins));
+    }
+    else if (mins || hours) {
+        if (!mins) {
+            pattern = pattern.replace(/:?m+/, '');
+        }
+        offsetStr = pattern
+            .replace(/H+/, String(hours))
+            .replace(/m+/, String(mins));
+    }
+    return gmtFormat.replace('{0}', offsetStr);
+}
+/**
+ * https://tc39.es/ecma402/#sec-partitiondatetimepattern
+ * @param dtf
+ * @param x
+ */
+function PartitionDateTimePattern(dtf, x, _a) {
+    var getInternalSlots = _a.getInternalSlots, localeData = _a.localeData, getDefaultTimeZone = _a.getDefaultTimeZone, tzData = _a.tzData;
+    x = _262_1.TimeClip(x);
+    if (isNaN(x)) {
+        throw new RangeError('invalid time');
+    }
+    /** IMPL START */
+    var internalSlots = getInternalSlots(dtf);
+    var dataLocale = internalSlots.dataLocale;
+    var dataLocaleData = localeData[dataLocale];
+    /** IMPL END */
+    var locale = internalSlots.locale;
+    var nfOptions = Object.create(null);
+    nfOptions.useGrouping = false;
+    var nf = new Intl.NumberFormat(locale, nfOptions);
+    var nf2Options = Object.create(null);
+    nf2Options.minimumIntegerDigits = 2;
+    nf2Options.useGrouping = false;
+    var nf2 = new Intl.NumberFormat(locale, nf2Options);
+    var tm = ToLocalTime_1.ToLocalTime(x, 
+    // @ts-ignore
+    internalSlots.calendar, internalSlots.timeZone, { tzData: tzData });
+    var result = [];
+    var patternParts = PartitionPattern_1.PartitionPattern(internalSlots.pattern);
+    for (var _i = 0, patternParts_1 = patternParts; _i < patternParts_1.length; _i++) {
+        var patternPart = patternParts_1[_i];
+        var p = patternPart.type;
+        if (p === 'literal') {
+            result.push({
+                type: 'literal',
+                value: patternPart.value,
+            });
+        }
+        else if (utils_1.DATE_TIME_PROPS.indexOf(p) > -1) {
+            var fv = '';
+            var f = internalSlots[p];
+            // @ts-ignore
+            var v = tm[p];
+            if (p === 'year' && v <= 0) {
+                v = 1 - v;
+            }
+            if (p === 'month') {
+                v++;
+            }
+            var hourCycle = internalSlots.hourCycle;
+            if (p === 'hour' && (hourCycle === 'h11' || hourCycle === 'h12')) {
+                v = v % 12;
+                if (v === 0 && hourCycle === 'h12') {
+                    v = 12;
+                }
+            }
+            if (p === 'hour' && hourCycle === 'h24') {
+                if (v === 0) {
+                    v = 24;
+                }
+            }
+            if (f === 'numeric') {
+                fv = nf.format(v);
+            }
+            else if (f === '2-digit') {
+                fv = nf2.format(v);
+                if (fv.length > 2) {
+                    fv = fv.slice(fv.length - 2, fv.length);
+                }
+            }
+            else if (f === 'narrow' || f === 'short' || f === 'long') {
+                if (p === 'era') {
+                    fv = dataLocaleData[p][f][v];
+                }
+                else if (p === 'timeZoneName') {
+                    var timeZoneName = dataLocaleData.timeZoneName, gmtFormat = dataLocaleData.gmtFormat, hourFormat = dataLocaleData.hourFormat;
+                    var timeZone = internalSlots.timeZone || getDefaultTimeZone();
+                    var timeZoneData = timeZoneName[timeZone];
+                    if (timeZoneData && timeZoneData[f]) {
+                        fv = timeZoneData[f][+tm.inDST];
+                    }
+                    else {
+                        // Fallback to gmtFormat
+                        fv = offsetToGmtString(gmtFormat, hourFormat, tm.timeZoneOffset, f);
+                    }
+                }
+                else if (p === 'month') {
+                    fv = dataLocaleData.month[f][v - 1];
+                }
+                else {
+                    fv = dataLocaleData[p][f][v];
+                }
+            }
+            result.push({
+                type: p,
+                value: fv,
+            });
+        }
+        else if (p === 'ampm') {
+            var v = tm.hour;
+            var fv = void 0;
+            if (v > 11) {
+                fv = dataLocaleData.pm;
+            }
+            else {
+                fv = dataLocaleData.am;
+            }
+            result.push({
+                type: 'dayPeriod',
+                value: fv,
+            });
+        }
+        else if (p === 'relatedYear') {
+            var v = tm.relatedYear;
+            // @ts-ignore
+            var fv = nf.format(v);
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'relatedYear',
+                value: fv,
+            });
+        }
+        else if (p === 'yearName') {
+            var v = tm.yearName;
+            // @ts-ignore
+            var fv = nf.format(v);
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'yearName',
+                value: fv,
+            });
+        }
+        else {
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'unknown',
+                value: String(x),
+            });
+        }
+    }
+    return result;
+}
+exports.PartitionDateTimePattern = PartitionDateTimePattern;

package/src/DateTimeFormat/ToDateTimeOptions.d.ts

@@ -0,0 +1,9 @@
+import { DateTimeFormatOptions } from '../../types/date-time';
+/**
+ * https://tc39.es/ecma402/#sec-todatetimeoptions
+ * @param options
+ * @param required
+ * @param defaults
+ */
+export declare function ToDateTimeOptions(options?: DateTimeFormatOptions | null, required?: string, defaults?: string): DateTimeFormatOptions;
+//# sourceMappingURL=ToDateTimeOptions.d.ts.map

package/src/DateTimeFormat/ToDateTimeOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToDateTimeOptions.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/ToDateTimeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG5D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,qBAAqB,GAAG,IAAI,EACtC,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,qBAAqB,CAyDvB"}

package/src/DateTimeFormat/ToDateTimeOptions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToDateTimeOptions = void 0;
+var _262_1 = require("../../262");
+/**
+ * https://tc39.es/ecma402/#sec-todatetimeoptions
+ * @param options
+ * @param required
+ * @param defaults
+ */
+function ToDateTimeOptions(options, required, defaults) {
+    if (options === undefined) {
+        options = null;
+    }
+    else {
+        options = _262_1.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;
+}
+exports.ToDateTimeOptions = ToDateTimeOptions;

package/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/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/src/DateTimeFormat/ToLocalTime.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToLocalTime = void 0;
+var utils_1 = require("../utils");
+var _262_1 = require("../../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
+ */
+function ToLocalTime(t, calendar, timeZone, _a) {
+    var tzData = _a.tzData;
+    utils_1.invariant(_262_1.Type(t) === 'Number', 'invalid time');
+    utils_1.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 = _262_1.YearFromTime(tz);
+    return {
+        weekday: _262_1.WeekDay(tz),
+        era: year < 0 ? 'BC' : 'AD',
+        year: year,
+        relatedYear: undefined,
+        yearName: undefined,
+        month: _262_1.MonthFromTime(tz),
+        day: _262_1.DateFromTime(tz),
+        hour: _262_1.HourFromTime(tz),
+        minute: _262_1.MinFromTime(tz),
+        second: _262_1.SecFromTime(tz),
+        inDST: inDST,
+        // IMPORTANT: Not in spec
+        timeZoneOffset: timeZoneOffset,
+    };
+}
+exports.ToLocalTime = ToLocalTime;

package/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/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/src/DateTimeFormat/skeleton.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateTimeSkeleton = void 0;
+/**
+ * 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
+ */
+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;
+}
+exports.parseDateTimeSkeleton = parseDateTimeSkeleton;

package/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/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/src/DateTimeFormat/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortMorePenalty = exports.shortLessPenalty = exports.longMorePenalty = exports.longLessPenalty = exports.differentNumericTypePenalty = exports.additionPenalty = exports.removalPenalty = exports.DATE_TIME_PROPS = void 0;
+exports.DATE_TIME_PROPS = [
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+];
+exports.removalPenalty = 120;
+exports.additionPenalty = 20;
+exports.differentNumericTypePenalty = 15;
+exports.longLessPenalty = 8;
+exports.longMorePenalty = 6;
+exports.shortLessPenalty = 6;
+exports.shortMorePenalty = 3;

package/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/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/src/DisplayNames/CanonicalCodeForDisplayNames.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonicalCodeForDisplayNames = void 0;
+var CanonicalizeLocaleList_1 = require("../CanonicalizeLocaleList");
+var utils_1 = require("../utils");
+var IsWellFormedCurrencyCode_1 = require("../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);
+}
+function CanonicalCodeForDisplayNames(type, code) {
+    if (type === 'language') {
+        return CanonicalizeLocaleList_1.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);
+    }
+    utils_1.invariant(type === 'currency', 'invalid type');
+    if (!IsWellFormedCurrencyCode_1.IsWellFormedCurrencyCode(code)) {
+        throw RangeError('invalid currency');
+    }
+    return code.toUpperCase();
+}
+exports.CanonicalCodeForDisplayNames = CanonicalCodeForDisplayNames;

package/src/GetOption.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetOption = void 0;
-var ToString_1 = __importDefault(require("es-abstract/2019/ToString"));
+var _262_1 = require("../262");
 /**
  * https://tc39.es/ecma402/#sec-getoption
  * @param opts
@@ -24,7 +21,7 @@ function GetOption(opts, prop, type, values, fallback) {
             value = Boolean(value);
         }
         if (type === 'string') {
-            value = ToString_1.default(value);
+            value = _262_1.ToString(value);
         }
         if (values !== undefined && !values.filter(function (val) { return val == value; }).length) {
             throw new RangeError(value + " is not within " + values.join(', '));

package/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/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/src/IsValidTimeZoneName.js

@@ -0,0 +1,15 @@
+"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(Object.keys(tzData).map(function (z) { return z.toUpperCase(); }));
+    return zoneNames.has(uppercasedTz) || uppercasedTz in uppercaseLinks;
+}
+exports.IsValidTimeZoneName = IsValidTimeZoneName;

package/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