@formatjs/intl-datetimeformat 6.18.2 → 7.0.1

package/lib/src/abstract/skeleton.js

@@ -1,294 +0,0 @@
-import { __assign } from "tslib";
-import { RangePatternType, } from '@formatjs/ecma402-abstract';
-/**
- * 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) {
-    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 = [
-                undefined,
-                undefined,
-                'short',
-                'long',
-                'narrow',
-                'short',
-            ][len - 1];
-            return '{weekday}';
-        case 'c':
-            result.weekday = [
-                undefined,
-                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];
-            result.hour12 = true;
-            return '{hour}';
-        case 'H':
-            result.hour = ['numeric', '2-digit'][len - 1];
-            return '{hour}';
-        case 'K':
-            result.hour = ['numeric', '2-digit'][len - 1];
-            result.hour12 = true;
-            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: milliseconds 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 '';
-}
-function skeletonTokenToTable2(c) {
-    switch (c) {
-        // Era
-        case 'G':
-            return 'era';
-        // Year
-        case 'y':
-        case 'Y':
-        case 'u':
-        case 'U':
-        case 'r':
-            return 'year';
-        // Month
-        case 'M':
-        case 'L':
-            return 'month';
-        // Day
-        case 'd':
-        case 'D':
-        case 'F':
-        case 'g':
-            return 'day';
-        // Period
-        case 'a': // AM, PM
-        case 'b': // am, pm, noon, midnight
-        case 'B': // flexible day periods
-            return 'ampm';
-        // Hour
-        case 'h':
-        case 'H':
-        case 'K':
-        case 'k':
-            return 'hour';
-        // Minute
-        case 'm':
-            return 'minute';
-        // Second
-        case 's':
-        case 'S':
-        case 'A':
-            return 'second';
-        default:
-            throw new RangeError('Invalid range pattern token');
-    }
-}
-export function processDateTimePattern(pattern, result) {
-    var literals = [];
-    // Use skeleton to populate result, but use mapped pattern to populate pattern
-    var pattern12 = pattern
-        // Double apostrophe
-        .replace(/'{2}/g, '{apostrophe}')
-        // Apostrophe-escaped
-        .replace(/'(.*?)'/g, function (_, literal) {
-        literals.push(literal);
-        return "$$".concat(literals.length - 1, "$$");
-    })
-        .replace(DATE_TIME_REGEX, function (m) { return matchSkeletonPattern(m, result || {}); });
-    //Restore literals
-    if (literals.length) {
-        pattern12 = pattern12
-            .replace(/\$\$(\d+)\$\$/g, function (_, i) {
-            return literals[+i];
-        })
-            .replace(/\{apostrophe\}/g, "'");
-    }
-    // Handle apostrophe-escaped things
-    return [
-        pattern12
-            .replace(/([\s\uFEFF\xA0])\{ampm\}([\s\uFEFF\xA0])/, '$1')
-            .replace('{ampm}', '')
-            .replace(expPatternTrimmer, ''),
-        pattern12,
-    ];
-}
-/**
- * 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, rawPattern, rangePatterns, intervalFormatFallback) {
-    if (rawPattern === void 0) { rawPattern = skeleton; }
-    var result = {
-        pattern: '',
-        pattern12: '',
-        skeleton: skeleton,
-        rawPattern: rawPattern,
-        rangePatterns: {},
-        rangePatterns12: {},
-    };
-    if (rangePatterns) {
-        for (var k in rangePatterns) {
-            var key = skeletonTokenToTable2(k);
-            var rawPattern_1 = rangePatterns[k];
-            var intervalResult = {
-                patternParts: [],
-            };
-            var _a = processDateTimePattern(rawPattern_1, intervalResult), pattern_1 = _a[0], pattern12_1 = _a[1];
-            result.rangePatterns[key] = __assign(__assign({}, intervalResult), { patternParts: splitRangePattern(pattern_1) });
-            result.rangePatterns12[key] = __assign(__assign({}, intervalResult), { patternParts: splitRangePattern(pattern12_1) });
-        }
-    }
-    if (intervalFormatFallback) {
-        var patternParts = splitFallbackRangePattern(intervalFormatFallback);
-        result.rangePatterns.default = {
-            patternParts: patternParts,
-        };
-        result.rangePatterns12.default = {
-            patternParts: patternParts,
-        };
-    }
-    // Process skeleton
-    skeleton.replace(DATE_TIME_REGEX, function (m) { return matchSkeletonPattern(m, result); });
-    var _b = processDateTimePattern(rawPattern), pattern = _b[0], pattern12 = _b[1];
-    result.pattern = pattern;
-    result.pattern12 = pattern12;
-    return result;
-}
-export function splitFallbackRangePattern(pattern) {
-    var parts = pattern.split(/(\{[0|1]\})/g).filter(Boolean);
-    return parts.map(function (pattern) {
-        switch (pattern) {
-            case '{0}':
-                return {
-                    source: RangePatternType.startRange,
-                    pattern: pattern,
-                };
-            case '{1}':
-                return {
-                    source: RangePatternType.endRange,
-                    pattern: pattern,
-                };
-            default:
-                return {
-                    source: RangePatternType.shared,
-                    pattern: pattern,
-                };
-        }
-    });
-}
-export function splitRangePattern(pattern) {
-    var PART_REGEX = /\{(.*?)\}/g;
-    // Map of part and index within the string
-    var parts = {};
-    var match;
-    var splitIndex = 0;
-    while ((match = PART_REGEX.exec(pattern))) {
-        if (!(match[0] in parts)) {
-            parts[match[0]] = match.index;
-        }
-        else {
-            splitIndex = match.index;
-            break;
-        }
-    }
-    if (!splitIndex) {
-        return [
-            {
-                source: RangePatternType.startRange,
-                pattern: pattern,
-            },
-        ];
-    }
-    return [
-        {
-            source: RangePatternType.startRange,
-            pattern: pattern.slice(0, splitIndex),
-        },
-        {
-            source: RangePatternType.endRange,
-            pattern: pattern.slice(splitIndex),
-        },
-    ];
-}

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

@@ -1,10 +0,0 @@
-import { IntlDateTimeFormatInternal, TABLE_6 } from '@formatjs/ecma402-abstract';
-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;
-export declare const offsetPenalty = 1;

package/lib/src/abstract/utils.js

@@ -1,21 +0,0 @@
-export var DATE_TIME_PROPS = [
-    'weekday',
-    'era',
-    'year',
-    'month',
-    'day',
-    'dayPeriod',
-    'hour',
-    'minute',
-    'second',
-    'fractionalSecondDigits',
-    '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;
-export var offsetPenalty = 1;

package/lib/src/core.d.ts

@@ -1,20 +0,0 @@
-import { DateTimeFormatLocaleInternalData, DateTimeFormat as IDateTimeFormat, UnpackedZoneData } from '@formatjs/ecma402-abstract';
-import { PackedData, RawDateTimeLocaleData } from './types';
-export interface DateTimeFormatConstructor {
-    new (locales?: string | string[], options?: Intl.DateTimeFormatOptions): IDateTimeFormat;
-    (locales?: string | string[], options?: Intl.DateTimeFormatOptions): IDateTimeFormat;
-    __addLocaleData(...data: RawDateTimeLocaleData[]): void;
-    supportedLocalesOf(locales: string | string[], options?: Pick<Intl.DateTimeFormatOptions, 'localeMatcher'>): string[];
-    getDefaultLocale(): string;
-    relevantExtensionKeys: string[];
-    __defaultLocale: string;
-    __defaultTimeZone: string;
-    __setDefaultTimeZone(tz: string): void;
-    getDefaultTimeZone(): string;
-    localeData: Record<string, DateTimeFormatLocaleInternalData>;
-    availableLocales: Set<string>;
-    polyfilled: boolean;
-    tzData: Record<string, UnpackedZoneData[]>;
-    __addTZData(d: PackedData): void;
-}
-export declare const DateTimeFormat: DateTimeFormatConstructor;

package/lib/src/core.js

@@ -1,300 +0,0 @@
-import { __assign, __rest } from "tslib";
-import { CanonicalizeLocaleList, CanonicalizeTimeZoneName, IsValidTimeZoneName, OrdinaryHasInstance, SupportedLocales, ToNumber, defineProperty, invariant, } from '@formatjs/ecma402-abstract';
-import Decimal from 'decimal.js';
-import { FormatDateTime } from './abstract/FormatDateTime';
-import { FormatDateTimeRange } from './abstract/FormatDateTimeRange';
-import { FormatDateTimeRangeToParts } from './abstract/FormatDateTimeRangeToParts';
-import { FormatDateTimeToParts } from './abstract/FormatDateTimeToParts';
-import { InitializeDateTimeFormat } from './abstract/InitializeDateTimeFormat';
-import { parseDateTimeSkeleton } from './abstract/skeleton';
-import { DATE_TIME_PROPS } from './abstract/utils';
-import links from './data/links';
-import getInternalSlots from './get_internal_slots';
-import { unpack } from './packer';
-var UPPERCASED_LINKS = Object.keys(links).reduce(function (all, l) {
-    all[l.toUpperCase()] = links[l];
-    return all;
-}, {});
-var RESOLVED_OPTIONS_KEYS = [
-    'locale',
-    'calendar',
-    'numberingSystem',
-    'dateStyle',
-    'timeStyle',
-    'timeZone',
-    'hourCycle',
-    'weekday',
-    'era',
-    'year',
-    'month',
-    'day',
-    'hour',
-    'minute',
-    'second',
-    'timeZoneName',
-];
-var formatDescriptor = {
-    enumerable: false,
-    configurable: true,
-    get: function () {
-        if (typeof this !== 'object' ||
-            !OrdinaryHasInstance(DateTimeFormat, this)) {
-            throw TypeError('Intl.DateTimeFormat format property accessor called on incompatible receiver');
-        }
-        var internalSlots = getInternalSlots(this);
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var dtf = this;
-        var boundFormat = internalSlots.boundFormat;
-        if (boundFormat === undefined) {
-            // https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_diff_out.html#sec-number-format-functions
-            boundFormat = function (date) {
-                var x;
-                if (date === undefined) {
-                    x = new Decimal(Date.now());
-                }
-                else {
-                    x = ToNumber(date);
-                }
-                return FormatDateTime(dtf, x, {
-                    getInternalSlots: getInternalSlots,
-                    localeData: DateTimeFormat.localeData,
-                    tzData: DateTimeFormat.tzData,
-                    getDefaultTimeZone: DateTimeFormat.getDefaultTimeZone,
-                });
-            };
-            try {
-                // https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/prototype/format/format-function-name.js
-                Object.defineProperty(boundFormat, 'name', {
-                    configurable: true,
-                    enumerable: false,
-                    writable: false,
-                    value: '',
-                });
-            }
-            catch (e) {
-                // In older browser (e.g Chrome 36 like polyfill-fastly.io)
-                // TypeError: Cannot redefine property: name
-            }
-            internalSlots.boundFormat = boundFormat;
-        }
-        return boundFormat;
-    },
-};
-try {
-    // https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/prototype/format/name.js
-    Object.defineProperty(formatDescriptor.get, 'name', {
-        configurable: true,
-        enumerable: false,
-        writable: false,
-        value: 'get format',
-    });
-}
-catch (e) {
-    // In older browser (e.g Chrome 36 like polyfill-fastly.io)
-    // TypeError: Cannot redefine property: name
-}
-export var DateTimeFormat = function (locales, options) {
-    // Cannot use `new.target` bc of IE11 & TS transpiles it to something else
-    if (!this || !OrdinaryHasInstance(DateTimeFormat, this)) {
-        return new DateTimeFormat(locales, options);
-    }
-    InitializeDateTimeFormat(this, locales, options, {
-        tzData: DateTimeFormat.tzData,
-        uppercaseLinks: UPPERCASED_LINKS,
-        availableLocales: DateTimeFormat.availableLocales,
-        relevantExtensionKeys: DateTimeFormat.relevantExtensionKeys,
-        getDefaultLocale: DateTimeFormat.getDefaultLocale,
-        getDefaultTimeZone: DateTimeFormat.getDefaultTimeZone,
-        getInternalSlots: getInternalSlots,
-        localeData: DateTimeFormat.localeData,
-    });
-    /** IMPL START */
-    var internalSlots = getInternalSlots(this);
-    var dataLocale = internalSlots.dataLocale;
-    var dataLocaleData = DateTimeFormat.localeData[dataLocale];
-    invariant(dataLocaleData !== undefined, "Cannot load locale-dependent data for ".concat(dataLocale, "."));
-    /** IMPL END */
-};
-// Static properties
-defineProperty(DateTimeFormat, 'supportedLocalesOf', {
-    value: function supportedLocalesOf(locales, options) {
-        return SupportedLocales(DateTimeFormat.availableLocales, CanonicalizeLocaleList(locales), options);
-    },
-});
-defineProperty(DateTimeFormat.prototype, 'resolvedOptions', {
-    value: function resolvedOptions() {
-        if (typeof this !== 'object' ||
-            !OrdinaryHasInstance(DateTimeFormat, this)) {
-            throw TypeError('Method Intl.DateTimeFormat.prototype.resolvedOptions called on incompatible receiver');
-        }
-        var internalSlots = getInternalSlots(this);
-        var ro = {};
-        for (var _i = 0, RESOLVED_OPTIONS_KEYS_1 = RESOLVED_OPTIONS_KEYS; _i < RESOLVED_OPTIONS_KEYS_1.length; _i++) {
-            var key = RESOLVED_OPTIONS_KEYS_1[_i];
-            var value = internalSlots[key];
-            if (key === 'hourCycle') {
-                var hour12 = value === 'h11' || value === 'h12'
-                    ? true
-                    : value === 'h23' || value === 'h24'
-                        ? false
-                        : undefined;
-                if (hour12 !== undefined) {
-                    ro.hour12 = hour12;
-                }
-            }
-            if (DATE_TIME_PROPS.indexOf(key) > -1) {
-                if (internalSlots.dateStyle !== undefined ||
-                    internalSlots.timeStyle !== undefined) {
-                    value = undefined;
-                }
-            }
-            if (value !== undefined) {
-                ro[key] = value;
-            }
-        }
-        return ro;
-    },
-});
-defineProperty(DateTimeFormat.prototype, 'formatToParts', {
-    value: function formatToParts(date) {
-        var x;
-        if (date === undefined) {
-            x = new Decimal(Date.now());
-        }
-        else {
-            x = ToNumber(date);
-        }
-        return FormatDateTimeToParts(this, x, {
-            getInternalSlots: getInternalSlots,
-            localeData: DateTimeFormat.localeData,
-            tzData: DateTimeFormat.tzData,
-            getDefaultTimeZone: DateTimeFormat.getDefaultTimeZone,
-        });
-    },
-});
-defineProperty(DateTimeFormat.prototype, 'formatRangeToParts', {
-    value: function formatRangeToParts(startDate, endDate) {
-        var dtf = this;
-        invariant(typeof dtf === 'object', 'receiver is not an object', TypeError);
-        invariant(startDate !== undefined && endDate !== undefined, 'startDate/endDate cannot be undefined', TypeError);
-        return FormatDateTimeRangeToParts(dtf, ToNumber(startDate), ToNumber(endDate), {
-            getInternalSlots: getInternalSlots,
-            localeData: DateTimeFormat.localeData,
-            tzData: DateTimeFormat.tzData,
-            getDefaultTimeZone: DateTimeFormat.getDefaultTimeZone,
-        });
-    },
-});
-defineProperty(DateTimeFormat.prototype, 'formatRange', {
-    value: function formatRange(startDate, endDate) {
-        var dtf = this;
-        invariant(typeof dtf === 'object', 'receiver is not an object', TypeError);
-        invariant(startDate !== undefined && endDate !== undefined, 'startDate/endDate cannot be undefined', TypeError);
-        return FormatDateTimeRange(dtf, ToNumber(startDate), ToNumber(endDate), {
-            getInternalSlots: getInternalSlots,
-            localeData: DateTimeFormat.localeData,
-            tzData: DateTimeFormat.tzData,
-            getDefaultTimeZone: DateTimeFormat.getDefaultTimeZone,
-        });
-    },
-});
-var DEFAULT_TIMEZONE = 'UTC';
-DateTimeFormat.__setDefaultTimeZone = function (timeZone) {
-    if (timeZone !== undefined) {
-        timeZone = String(timeZone);
-        if (!IsValidTimeZoneName(timeZone, {
-            zoneNamesFromData: Object.keys(DateTimeFormat.tzData),
-            uppercaseLinks: UPPERCASED_LINKS,
-        })) {
-            throw new RangeError('Invalid timeZoneName');
-        }
-        timeZone = CanonicalizeTimeZoneName(timeZone, {
-            zoneNames: Object.keys(DateTimeFormat.tzData),
-            uppercaseLinks: UPPERCASED_LINKS,
-        });
-    }
-    else {
-        timeZone = DEFAULT_TIMEZONE;
-    }
-    DateTimeFormat.__defaultTimeZone = timeZone;
-};
-DateTimeFormat.relevantExtensionKeys = ['nu', 'ca', 'hc'];
-DateTimeFormat.__defaultTimeZone = DEFAULT_TIMEZONE;
-DateTimeFormat.getDefaultTimeZone = function () { return DateTimeFormat.__defaultTimeZone; };
-DateTimeFormat.__addLocaleData = function __addLocaleData() {
-    var data = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        data[_i] = arguments[_i];
-    }
-    var _loop_1 = function (d, locale) {
-        var dateFormat = d.dateFormat, timeFormat = d.timeFormat, dateTimeFormat = d.dateTimeFormat, formats = d.formats, intervalFormats = d.intervalFormats, rawData = __rest(d, ["dateFormat", "timeFormat", "dateTimeFormat", "formats", "intervalFormats"]);
-        var processedData = __assign(__assign({}, rawData), { dateFormat: {
-                full: parseDateTimeSkeleton(dateFormat.full),
-                long: parseDateTimeSkeleton(dateFormat.long),
-                medium: parseDateTimeSkeleton(dateFormat.medium),
-                short: parseDateTimeSkeleton(dateFormat.short),
-            }, timeFormat: {
-                full: parseDateTimeSkeleton(timeFormat.full),
-                long: parseDateTimeSkeleton(timeFormat.long),
-                medium: parseDateTimeSkeleton(timeFormat.medium),
-                short: parseDateTimeSkeleton(timeFormat.short),
-            }, dateTimeFormat: {
-                full: parseDateTimeSkeleton(dateTimeFormat.full).pattern,
-                long: parseDateTimeSkeleton(dateTimeFormat.long).pattern,
-                medium: parseDateTimeSkeleton(dateTimeFormat.medium).pattern,
-                short: parseDateTimeSkeleton(dateTimeFormat.short).pattern,
-            }, formats: {} });
-        var _loop_2 = function (calendar) {
-            processedData.formats[calendar] = Object.keys(formats[calendar]).map(function (skeleton) {
-                return parseDateTimeSkeleton(skeleton, formats[calendar][skeleton], intervalFormats[skeleton], intervalFormats.intervalFormatFallback);
-            });
-        };
-        for (var calendar in formats) {
-            _loop_2(calendar);
-        }
-        var minimizedLocale = new Intl.Locale(locale)
-            .minimize()
-            .toString();
-        DateTimeFormat.localeData[locale] = DateTimeFormat.localeData[minimizedLocale] = processedData;
-        DateTimeFormat.availableLocales.add(locale);
-        DateTimeFormat.availableLocales.add(minimizedLocale);
-        if (!DateTimeFormat.__defaultLocale) {
-            DateTimeFormat.__defaultLocale = minimizedLocale;
-        }
-    };
-    for (var _a = 0, data_1 = data; _a < data_1.length; _a++) {
-        var _b = data_1[_a], d = _b.data, locale = _b.locale;
-        _loop_1(d, locale);
-    }
-};
-Object.defineProperty(DateTimeFormat.prototype, 'format', formatDescriptor);
-DateTimeFormat.__defaultLocale = '';
-DateTimeFormat.localeData = {};
-DateTimeFormat.availableLocales = new Set();
-DateTimeFormat.getDefaultLocale = function () {
-    return DateTimeFormat.__defaultLocale;
-};
-DateTimeFormat.polyfilled = true;
-DateTimeFormat.tzData = {};
-DateTimeFormat.__addTZData = function (d) {
-    DateTimeFormat.tzData = unpack(d);
-};
-try {
-    if (typeof Symbol !== 'undefined') {
-        Object.defineProperty(DateTimeFormat.prototype, Symbol.toStringTag, {
-            value: 'Intl.DateTimeFormat',
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    Object.defineProperty(DateTimeFormat.prototype.constructor, 'length', {
-        value: 1,
-        writable: false,
-        enumerable: false,
-        configurable: true,
-    });
-}
-catch (e) {
-    // Meta fix so we're test262-compliant, not important
-}

package/lib/src/data/all-tz.d.ts

@@ -1,6 +0,0 @@
-declare const data: {
-    abbrvs: string;
-    offsets: string;
-    zones: string[];
-};
-export default data;