@dan-uni/dan-any 1.2.2 → 1.2.7

package/dist/umd/plugins/index.umd.min.js

@@ -14045,10 +14045,13 @@
                                     i += 7;
                                     let entityName, val;
                                     [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
-                                    if (-1 === val.indexOf("&")) entities[entityName] = {
-                                        regx: RegExp(`&${entityName};`, "g"),
-                                        val: val
-                                    };
+                                    if (-1 === val.indexOf("&")) {
+                                        const escaped = entityName.replace(/[.\-+*:]/g, '\\.');
+                                        entities[entityName] = {
+                                            regx: RegExp(`&${escaped};`, "g"),
+                                            val: val
+                                        };
+                                    }
                                 } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
                                     i += 8;
                                     const { index } = this.readElementExp(xmlData, i + 1);
@@ -14398,11 +14401,11 @@
                             },
                             num_dec: {
                                 regex: /&#([0-9]{1,7});/g,
-                                val: (_, str)=>String.fromCodePoint(Number.parseInt(str, 10))
+                                val: (_, str)=>fromCodePoint(str, 10, "&#")
                             },
                             num_hex: {
                                 regex: /&#x([0-9a-fA-F]{1,6});/g,
-                                val: (_, str)=>String.fromCodePoint(Number.parseInt(str, 16))
+                                val: (_, str)=>fromCodePoint(str, 16, "&#x")
                             }
                         };
                         this.addExternalEntities = addExternalEntities;
@@ -14431,8 +14434,9 @@
                     const entKeys = Object.keys(externalEntities);
                     for(let i = 0; i < entKeys.length; i++){
                         const ent = entKeys[i];
+                        const escaped = ent.replace(/[.\-+*:]/g, '\\.');
                         this.lastEntities[ent] = {
-                            regex: new RegExp("&" + ent + ";", "g"),
+                            regex: new RegExp("&" + escaped + ";", "g"),
                             val: externalEntities[ent]
                         };
                     }
@@ -14778,6 +14782,11 @@
                     if (isExist(val)) return val;
                     return '';
                 }
+                function fromCodePoint(str, base, prefix) {
+                    const codePoint = Number.parseInt(str, base);
+                    if (codePoint >= 0 && codePoint <= 0x10FFFF) return String.fromCodePoint(codePoint);
+                    return prefix + str + ";";
+                }
                 const node2json_METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
                 function prettify(node, options) {
                     return node2json_compress(node, options);
@@ -20334,7 +20343,7 @@
                 function timestamp_timestampMs(timestamp) {
                     return 1000 * Number(timestamp.seconds) + Math.round(timestamp.nanos / 1000000);
                 }
-                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.2.2","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
+                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.2.7","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
                 const color_pad = (s)=>s.length < 2 ? `0${s}` : s;
                 const decimalToHex = (n)=>color_pad(n.toString(16));
                 const isDarkColor = ({ r, g, b })=>0.299 * r + 0.587 * g + 0.114 * b < 0x30;
@@ -22799,7 +22808,7 @@
                         if (this.attr.length > 0) result.attr = this.attr;
                         if (void 0 !== this.platform) result.platform = this.platform;
                         if (this.extraStr && '{}' !== this.extraStr) result.extraStr = this.extraStr;
-                        if (void 0 !== this.DMID) result.DMID = this.DMID;
+                        if (void 0 !== this.DMID && this.options.dmid) result.DMID = this.DMID;
                         return result;
                     }
                     downgradeAdvcancedDan({ include, exclude, cleanExtra = false } = {}) {
@@ -22915,7 +22924,7 @@
                         }) ? args.midHash : id_gen_UniID.fromBili({
                             midHash: args.midHash
                         });
-                        let mode = 0;
+                        let mode;
                         const pool = args.pool;
                         const extra = {
                             bili: {
@@ -23763,10 +23772,7 @@
                         if (false !== options.dedupe) options.dedupe = true;
                         if (this.options.dedupe) this.dedupe();
                     }
-                    async pipe(fn) {
-                        return fn(this);
-                    }
-                    pipeSync(fn) {
+                    pipe(fn) {
                         return fn(this);
                     }
                     get shared() {
@@ -23978,23 +23984,23 @@
                             try {
                                 if (Array.isArray(json) && json.every((d)=>d.SOID)) return {
                                     pool: new UniPool(json, options),
-                                    fmt: 'danuni.json'
+                                    fmt: "danuni.json"
                                 };
                                 if (json.danmuku && json.danmuku.every((d)=>d.text)) return {
                                     pool: this.fromArtplayer(json, json.danuni?.data ?? '', void 0, options),
-                                    fmt: 'artplayer.json'
+                                    fmt: "artplayer.json"
                                 };
                                 if (json.count && json.comments && Array.isArray(json.comments) && json.comments.every((d)=>d.m)) return {
                                     pool: this.fromDDPlay(json, json.danuni?.data ?? '', options),
-                                    fmt: 'ddplay.json'
+                                    fmt: "ddplay.json"
                                 };
                                 else if (0 == json.code && json.data && Array.isArray(json.data) && json.data.every((d)=>Array.isArray(d))) return {
                                     pool: this.fromDplayer(json, json.danuni?.data ?? '', void 0, options),
-                                    fmt: 'dplayer.json'
+                                    fmt: "dplayer.json"
                                 };
                                 else if (0 == json.code && '0' == json.message && json.data && json.data.page && json.data.result && Array.isArray(json.data.result) && json.data.result.every((d)=>d.id && d.oid)) return {
                                     pool: this.fromBiliUp(json, options),
-                                    fmt: 'bili.up.json'
+                                    fmt: "bili.up.json"
                                 };
                             } catch  {}
                         };
@@ -24013,13 +24019,13 @@
                                     const xml = xmlParser.parse(file);
                                     if (xml?.i?.d) return {
                                         pool: this.fromBiliXML(file, options),
-                                        fmt: 'bili.xml'
+                                        fmt: "bili.xml"
                                     };
                                 } catch  {}
                                 try {
                                     return {
                                         pool: this.fromASS(file, options),
-                                        fmt: 'common.ass'
+                                        fmt: "common.ass"
                                     };
                                 } catch  {}
                             }
@@ -24031,19 +24037,19 @@
                                     try {
                                         return {
                                             pool: this.fromPb(file),
-                                            fmt: 'danuni.pb.bin'
+                                            fmt: "danuni.pb.bin"
                                         };
                                     } catch  {}
                                     try {
                                         return {
                                             pool: this.fromBiliGrpc(file),
-                                            fmt: 'bili.pb.bin'
+                                            fmt: "bili.pb.bin"
                                         };
                                     } catch  {}
                                     try {
                                         return {
                                             pool: this.fromBiliCommandGrpc(file),
-                                            fmt: 'bili.cmd.pb.bin'
+                                            fmt: "bili.cmd.pb.bin"
                                         };
                                     } catch  {}
                                 }
@@ -24311,18 +24317,24 @@
                     }
                 }
             },
-            "./src/plugins/bili-dedupe/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            "./src/plugins/bili/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
                 "use strict";
                 __webpack_require__.r(__webpack_exports__);
                 __webpack_require__.d(__webpack_exports__, {
+                    bili_dedupe: ()=>dedupe_namespaceObject,
+                    bili_history_fast_forward: ()=>bili_history_fast_forward
+                });
+                var dedupe_namespaceObject = {};
+                __webpack_require__.r(dedupe_namespaceObject);
+                __webpack_require__.d(dedupe_namespaceObject, {
                     bili_dedupe: ()=>bili_dedupe,
                     to_bili_deduped: ()=>to_bili_deduped
                 });
-                var ___rspack_import_0 = __webpack_require__("./src/index.ts");
-                var _utils_platform__rspack_import_1 = __webpack_require__("./src/utils/platform.ts");
+                var src = __webpack_require__("./src/index.ts");
+                var platform = __webpack_require__("./src/utils/platform.ts");
                 function main(that) {
                     that.dans.forEach((d)=>{
-                        if (d.platform !== _utils_platform__rspack_import_1.PlatformVideoSource.Bilibili) throw new Error('bili-dedupe: 仅支持B站(主站)的弹幕');
+                        if (d.platform !== platform.PlatformVideoSource.Bilibili) throw new Error('bili-dedupe: 仅支持B站(主站)的弹幕');
                         if (!d.extra.bili?.dmid) throw new Error('bili-dedupe: 弹幕缺少bili extra dmid字段');
                     });
                     const map = new Map();
@@ -24331,7 +24343,7 @@
                 }
                 function to_bili_deduped(that) {
                     const map = main(that);
-                    return new ___rspack_import_0.UniPool([
+                    return new src.UniPool([
                         ...map.values()
                     ], that.options, that.info);
                 }
@@ -24341,6 +24353,4609 @@
                         ...map.values()
                     ];
                 }
+                class LuxonError extends Error {
+                }
+                class InvalidDateTimeError extends LuxonError {
+                    constructor(reason){
+                        super(`Invalid DateTime: ${reason.toMessage()}`);
+                    }
+                }
+                class InvalidIntervalError extends LuxonError {
+                    constructor(reason){
+                        super(`Invalid Interval: ${reason.toMessage()}`);
+                    }
+                }
+                class InvalidDurationError extends LuxonError {
+                    constructor(reason){
+                        super(`Invalid Duration: ${reason.toMessage()}`);
+                    }
+                }
+                class ConflictingSpecificationError extends LuxonError {
+                }
+                class InvalidUnitError extends LuxonError {
+                    constructor(unit){
+                        super(`Invalid unit ${unit}`);
+                    }
+                }
+                class InvalidArgumentError extends LuxonError {
+                }
+                class ZoneIsAbstractError extends LuxonError {
+                    constructor(){
+                        super("Zone is an abstract class");
+                    }
+                }
+                const luxon_n = "numeric", luxon_s = "short", luxon_l = "long";
+                const DATE_SHORT = {
+                    year: luxon_n,
+                    month: luxon_n,
+                    day: luxon_n
+                };
+                const DATE_MED = {
+                    year: luxon_n,
+                    month: luxon_s,
+                    day: luxon_n
+                };
+                const DATE_MED_WITH_WEEKDAY = {
+                    year: luxon_n,
+                    month: luxon_s,
+                    day: luxon_n,
+                    weekday: luxon_s
+                };
+                const DATE_FULL = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n
+                };
+                const DATE_HUGE = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n,
+                    weekday: luxon_l
+                };
+                const TIME_SIMPLE = {
+                    hour: luxon_n,
+                    minute: luxon_n
+                };
+                const TIME_WITH_SECONDS = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n
+                };
+                const TIME_WITH_SHORT_OFFSET = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    timeZoneName: luxon_s
+                };
+                const TIME_WITH_LONG_OFFSET = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    timeZoneName: luxon_l
+                };
+                const TIME_24_SIMPLE = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    hourCycle: "h23"
+                };
+                const TIME_24_WITH_SECONDS = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    hourCycle: "h23"
+                };
+                const TIME_24_WITH_SHORT_OFFSET = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    hourCycle: "h23",
+                    timeZoneName: luxon_s
+                };
+                const TIME_24_WITH_LONG_OFFSET = {
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    hourCycle: "h23",
+                    timeZoneName: luxon_l
+                };
+                const DATETIME_SHORT = {
+                    year: luxon_n,
+                    month: luxon_n,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n
+                };
+                const DATETIME_SHORT_WITH_SECONDS = {
+                    year: luxon_n,
+                    month: luxon_n,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n
+                };
+                const DATETIME_MED = {
+                    year: luxon_n,
+                    month: luxon_s,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n
+                };
+                const DATETIME_MED_WITH_SECONDS = {
+                    year: luxon_n,
+                    month: luxon_s,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n
+                };
+                const DATETIME_MED_WITH_WEEKDAY = {
+                    year: luxon_n,
+                    month: luxon_s,
+                    day: luxon_n,
+                    weekday: luxon_s,
+                    hour: luxon_n,
+                    minute: luxon_n
+                };
+                const DATETIME_FULL = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    timeZoneName: luxon_s
+                };
+                const DATETIME_FULL_WITH_SECONDS = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    timeZoneName: luxon_s
+                };
+                const DATETIME_HUGE = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n,
+                    weekday: luxon_l,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    timeZoneName: luxon_l
+                };
+                const DATETIME_HUGE_WITH_SECONDS = {
+                    year: luxon_n,
+                    month: luxon_l,
+                    day: luxon_n,
+                    weekday: luxon_l,
+                    hour: luxon_n,
+                    minute: luxon_n,
+                    second: luxon_n,
+                    timeZoneName: luxon_l
+                };
+                class Zone {
+                    get type() {
+                        throw new ZoneIsAbstractError();
+                    }
+                    get name() {
+                        throw new ZoneIsAbstractError();
+                    }
+                    get ianaName() {
+                        return this.name;
+                    }
+                    get isUniversal() {
+                        throw new ZoneIsAbstractError();
+                    }
+                    offsetName(ts, opts) {
+                        throw new ZoneIsAbstractError();
+                    }
+                    formatOffset(ts, format) {
+                        throw new ZoneIsAbstractError();
+                    }
+                    offset(ts) {
+                        throw new ZoneIsAbstractError();
+                    }
+                    equals(otherZone) {
+                        throw new ZoneIsAbstractError();
+                    }
+                    get isValid() {
+                        throw new ZoneIsAbstractError();
+                    }
+                }
+                let singleton$1 = null;
+                class SystemZone extends Zone {
+                    static get instance() {
+                        if (null === singleton$1) singleton$1 = new SystemZone();
+                        return singleton$1;
+                    }
+                    get type() {
+                        return "system";
+                    }
+                    get name() {
+                        return new Intl.DateTimeFormat().resolvedOptions().timeZone;
+                    }
+                    get isUniversal() {
+                        return false;
+                    }
+                    offsetName(ts, { format, locale }) {
+                        return parseZoneInfo(ts, format, locale);
+                    }
+                    formatOffset(ts, format) {
+                        return luxon_formatOffset(this.offset(ts), format);
+                    }
+                    offset(ts) {
+                        return -new Date(ts).getTimezoneOffset();
+                    }
+                    equals(otherZone) {
+                        return "system" === otherZone.type;
+                    }
+                    get isValid() {
+                        return true;
+                    }
+                }
+                const dtfCache = new Map();
+                function makeDTF(zoneName) {
+                    let dtf = dtfCache.get(zoneName);
+                    if (void 0 === dtf) {
+                        dtf = new Intl.DateTimeFormat("en-US", {
+                            hour12: false,
+                            timeZone: zoneName,
+                            year: "numeric",
+                            month: "2-digit",
+                            day: "2-digit",
+                            hour: "2-digit",
+                            minute: "2-digit",
+                            second: "2-digit",
+                            era: "short"
+                        });
+                        dtfCache.set(zoneName, dtf);
+                    }
+                    return dtf;
+                }
+                const typeToPos = {
+                    year: 0,
+                    month: 1,
+                    day: 2,
+                    era: 3,
+                    hour: 4,
+                    minute: 5,
+                    second: 6
+                };
+                function hackyOffset(dtf, date) {
+                    const formatted = dtf.format(date).replace(/\u200E/g, ""), parsed = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(formatted), [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed;
+                    return [
+                        fYear,
+                        fMonth,
+                        fDay,
+                        fadOrBc,
+                        fHour,
+                        fMinute,
+                        fSecond
+                    ];
+                }
+                function partsOffset(dtf, date) {
+                    const formatted = dtf.formatToParts(date);
+                    const filled = [];
+                    for(let i = 0; i < formatted.length; i++){
+                        const { type, value } = formatted[i];
+                        const pos = typeToPos[type];
+                        if ("era" === type) filled[pos] = value;
+                        else if (!isUndefined(pos)) filled[pos] = parseInt(value, 10);
+                    }
+                    return filled;
+                }
+                const ianaZoneCache = new Map();
+                class IANAZone extends Zone {
+                    static create(name) {
+                        let zone = ianaZoneCache.get(name);
+                        if (void 0 === zone) ianaZoneCache.set(name, zone = new IANAZone(name));
+                        return zone;
+                    }
+                    static resetCache() {
+                        ianaZoneCache.clear();
+                        dtfCache.clear();
+                    }
+                    static isValidSpecifier(s) {
+                        return this.isValidZone(s);
+                    }
+                    static isValidZone(zone) {
+                        if (!zone) return false;
+                        try {
+                            new Intl.DateTimeFormat("en-US", {
+                                timeZone: zone
+                            }).format();
+                            return true;
+                        } catch (e) {
+                            return false;
+                        }
+                    }
+                    constructor(name){
+                        super();
+                        this.zoneName = name;
+                        this.valid = IANAZone.isValidZone(name);
+                    }
+                    get type() {
+                        return "iana";
+                    }
+                    get name() {
+                        return this.zoneName;
+                    }
+                    get isUniversal() {
+                        return false;
+                    }
+                    offsetName(ts, { format, locale }) {
+                        return parseZoneInfo(ts, format, locale, this.name);
+                    }
+                    formatOffset(ts, format) {
+                        return luxon_formatOffset(this.offset(ts), format);
+                    }
+                    offset(ts) {
+                        if (!this.valid) return NaN;
+                        const date = new Date(ts);
+                        if (isNaN(date)) return NaN;
+                        const dtf = makeDTF(this.name);
+                        let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts ? partsOffset(dtf, date) : hackyOffset(dtf, date);
+                        if ("BC" === adOrBc) year = -Math.abs(year) + 1;
+                        const adjustedHour = 24 === hour ? 0 : hour;
+                        const asUTC = objToLocalTS({
+                            year,
+                            month,
+                            day,
+                            hour: adjustedHour,
+                            minute,
+                            second,
+                            millisecond: 0
+                        });
+                        let asTS = +date;
+                        const over = asTS % 1000;
+                        asTS -= over >= 0 ? over : 1000 + over;
+                        return (asUTC - asTS) / 60000;
+                    }
+                    equals(otherZone) {
+                        return "iana" === otherZone.type && otherZone.name === this.name;
+                    }
+                    get isValid() {
+                        return this.valid;
+                    }
+                }
+                let intlLFCache = {};
+                function getCachedLF(locString, opts = {}) {
+                    const key = JSON.stringify([
+                        locString,
+                        opts
+                    ]);
+                    let dtf = intlLFCache[key];
+                    if (!dtf) {
+                        dtf = new Intl.ListFormat(locString, opts);
+                        intlLFCache[key] = dtf;
+                    }
+                    return dtf;
+                }
+                const intlDTCache = new Map();
+                function getCachedDTF(locString, opts = {}) {
+                    const key = JSON.stringify([
+                        locString,
+                        opts
+                    ]);
+                    let dtf = intlDTCache.get(key);
+                    if (void 0 === dtf) {
+                        dtf = new Intl.DateTimeFormat(locString, opts);
+                        intlDTCache.set(key, dtf);
+                    }
+                    return dtf;
+                }
+                const intlNumCache = new Map();
+                function getCachedINF(locString, opts = {}) {
+                    const key = JSON.stringify([
+                        locString,
+                        opts
+                    ]);
+                    let inf = intlNumCache.get(key);
+                    if (void 0 === inf) {
+                        inf = new Intl.NumberFormat(locString, opts);
+                        intlNumCache.set(key, inf);
+                    }
+                    return inf;
+                }
+                const intlRelCache = new Map();
+                function getCachedRTF(locString, opts = {}) {
+                    const { base, ...cacheKeyOpts } = opts;
+                    const key = JSON.stringify([
+                        locString,
+                        cacheKeyOpts
+                    ]);
+                    let inf = intlRelCache.get(key);
+                    if (void 0 === inf) {
+                        inf = new Intl.RelativeTimeFormat(locString, opts);
+                        intlRelCache.set(key, inf);
+                    }
+                    return inf;
+                }
+                let sysLocaleCache = null;
+                function systemLocale() {
+                    if (sysLocaleCache) return sysLocaleCache;
+                    sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
+                    return sysLocaleCache;
+                }
+                const intlResolvedOptionsCache = new Map();
+                function getCachedIntResolvedOptions(locString) {
+                    let opts = intlResolvedOptionsCache.get(locString);
+                    if (void 0 === opts) {
+                        opts = new Intl.DateTimeFormat(locString).resolvedOptions();
+                        intlResolvedOptionsCache.set(locString, opts);
+                    }
+                    return opts;
+                }
+                const weekInfoCache = new Map();
+                function getCachedWeekInfo(locString) {
+                    let data = weekInfoCache.get(locString);
+                    if (!data) {
+                        const locale = new Intl.Locale(locString);
+                        data = "getWeekInfo" in locale ? locale.getWeekInfo() : locale.weekInfo;
+                        if (!("minimalDays" in data)) data = {
+                            ...fallbackWeekSettings,
+                            ...data
+                        };
+                        weekInfoCache.set(locString, data);
+                    }
+                    return data;
+                }
+                function parseLocaleString(localeStr) {
+                    const xIndex = localeStr.indexOf("-x-");
+                    if (-1 !== xIndex) localeStr = localeStr.substring(0, xIndex);
+                    const uIndex = localeStr.indexOf("-u-");
+                    if (-1 === uIndex) return [
+                        localeStr
+                    ];
+                    {
+                        let options;
+                        let selectedStr;
+                        try {
+                            options = getCachedDTF(localeStr).resolvedOptions();
+                            selectedStr = localeStr;
+                        } catch (e) {
+                            const smaller = localeStr.substring(0, uIndex);
+                            options = getCachedDTF(smaller).resolvedOptions();
+                            selectedStr = smaller;
+                        }
+                        const { numberingSystem, calendar } = options;
+                        return [
+                            selectedStr,
+                            numberingSystem,
+                            calendar
+                        ];
+                    }
+                }
+                function intlConfigString(localeStr, numberingSystem, outputCalendar) {
+                    if (!outputCalendar && !numberingSystem) return localeStr;
+                    if (!localeStr.includes("-u-")) localeStr += "-u";
+                    if (outputCalendar) localeStr += `-ca-${outputCalendar}`;
+                    if (numberingSystem) localeStr += `-nu-${numberingSystem}`;
+                    return localeStr;
+                }
+                function mapMonths(f) {
+                    const ms = [];
+                    for(let i = 1; i <= 12; i++){
+                        const dt = DateTime.utc(2009, i, 1);
+                        ms.push(f(dt));
+                    }
+                    return ms;
+                }
+                function mapWeekdays(f) {
+                    const ms = [];
+                    for(let i = 1; i <= 7; i++){
+                        const dt = DateTime.utc(2016, 11, 13 + i);
+                        ms.push(f(dt));
+                    }
+                    return ms;
+                }
+                function listStuff(loc, length, englishFn, intlFn) {
+                    const mode = loc.listingMode();
+                    if ("error" === mode) return null;
+                    if ("en" === mode) return englishFn(length);
+                    return intlFn(length);
+                }
+                function supportsFastNumbers(loc) {
+                    if (loc.numberingSystem && "latn" !== loc.numberingSystem) return false;
+                    return "latn" === loc.numberingSystem || !loc.locale || loc.locale.startsWith("en") || "latn" === getCachedIntResolvedOptions(loc.locale).numberingSystem;
+                }
+                class PolyNumberFormatter {
+                    constructor(intl, forceSimple, opts){
+                        this.padTo = opts.padTo || 0;
+                        this.floor = opts.floor || false;
+                        const { padTo, floor, ...otherOpts } = opts;
+                        if (!forceSimple || Object.keys(otherOpts).length > 0) {
+                            const intlOpts = {
+                                useGrouping: false,
+                                ...opts
+                            };
+                            if (opts.padTo > 0) intlOpts.minimumIntegerDigits = opts.padTo;
+                            this.inf = getCachedINF(intl, intlOpts);
+                        }
+                    }
+                    format(i) {
+                        if (this.inf) {
+                            const fixed = this.floor ? Math.floor(i) : i;
+                            return this.inf.format(fixed);
+                        }
+                        {
+                            const fixed = this.floor ? Math.floor(i) : roundTo(i, 3);
+                            return padStart(fixed, this.padTo);
+                        }
+                    }
+                }
+                class PolyDateFormatter {
+                    constructor(dt, intl, opts){
+                        this.opts = opts;
+                        this.originalZone = void 0;
+                        let z;
+                        if (this.opts.timeZone) this.dt = dt;
+                        else if ("fixed" === dt.zone.type) {
+                            const gmtOffset = -1 * (dt.offset / 60);
+                            const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`;
+                            if (0 !== dt.offset && IANAZone.create(offsetZ).valid) {
+                                z = offsetZ;
+                                this.dt = dt;
+                            } else {
+                                z = "UTC";
+                                this.dt = 0 === dt.offset ? dt : dt.setZone("UTC").plus({
+                                    minutes: dt.offset
+                                });
+                                this.originalZone = dt.zone;
+                            }
+                        } else if ("system" === dt.zone.type) this.dt = dt;
+                        else if ("iana" === dt.zone.type) {
+                            this.dt = dt;
+                            z = dt.zone.name;
+                        } else {
+                            z = "UTC";
+                            this.dt = dt.setZone("UTC").plus({
+                                minutes: dt.offset
+                            });
+                            this.originalZone = dt.zone;
+                        }
+                        const intlOpts = {
+                            ...this.opts
+                        };
+                        intlOpts.timeZone = intlOpts.timeZone || z;
+                        this.dtf = getCachedDTF(intl, intlOpts);
+                    }
+                    format() {
+                        if (this.originalZone) return this.formatToParts().map(({ value })=>value).join("");
+                        return this.dtf.format(this.dt.toJSDate());
+                    }
+                    formatToParts() {
+                        const parts = this.dtf.formatToParts(this.dt.toJSDate());
+                        if (this.originalZone) return parts.map((part)=>{
+                            if ("timeZoneName" !== part.type) return part;
+                            {
+                                const offsetName = this.originalZone.offsetName(this.dt.ts, {
+                                    locale: this.dt.locale,
+                                    format: this.opts.timeZoneName
+                                });
+                                return {
+                                    ...part,
+                                    value: offsetName
+                                };
+                            }
+                        });
+                        return parts;
+                    }
+                    resolvedOptions() {
+                        return this.dtf.resolvedOptions();
+                    }
+                }
+                class PolyRelFormatter {
+                    constructor(intl, isEnglish, opts){
+                        this.opts = {
+                            style: "long",
+                            ...opts
+                        };
+                        if (!isEnglish && hasRelative()) this.rtf = getCachedRTF(intl, opts);
+                    }
+                    format(count, unit) {
+                        if (this.rtf) return this.rtf.format(count, unit);
+                        return formatRelativeTime(unit, count, this.opts.numeric, "long" !== this.opts.style);
+                    }
+                    formatToParts(count, unit) {
+                        if (this.rtf) return this.rtf.formatToParts(count, unit);
+                        return [];
+                    }
+                }
+                const fallbackWeekSettings = {
+                    firstDay: 1,
+                    minimalDays: 4,
+                    weekend: [
+                        6,
+                        7
+                    ]
+                };
+                class Locale {
+                    static fromOpts(opts) {
+                        return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.weekSettings, opts.defaultToEN);
+                    }
+                    static create(locale, numberingSystem, outputCalendar, weekSettings, defaultToEN = false) {
+                        const specifiedLocale = locale || Settings.defaultLocale;
+                        const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
+                        const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
+                        const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
+                        const weekSettingsR = validateWeekSettings(weekSettings) || Settings.defaultWeekSettings;
+                        return new Locale(localeR, numberingSystemR, outputCalendarR, weekSettingsR, specifiedLocale);
+                    }
+                    static resetCache() {
+                        sysLocaleCache = null;
+                        intlDTCache.clear();
+                        intlNumCache.clear();
+                        intlRelCache.clear();
+                        intlResolvedOptionsCache.clear();
+                        weekInfoCache.clear();
+                    }
+                    static fromObject({ locale, numberingSystem, outputCalendar, weekSettings } = {}) {
+                        return Locale.create(locale, numberingSystem, outputCalendar, weekSettings);
+                    }
+                    constructor(locale, numbering, outputCalendar, weekSettings, specifiedLocale){
+                        const [parsedLocale, parsedNumberingSystem, parsedOutputCalendar] = parseLocaleString(locale);
+                        this.locale = parsedLocale;
+                        this.numberingSystem = numbering || parsedNumberingSystem || null;
+                        this.outputCalendar = outputCalendar || parsedOutputCalendar || null;
+                        this.weekSettings = weekSettings;
+                        this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar);
+                        this.weekdaysCache = {
+                            format: {},
+                            standalone: {}
+                        };
+                        this.monthsCache = {
+                            format: {},
+                            standalone: {}
+                        };
+                        this.meridiemCache = null;
+                        this.eraCache = {};
+                        this.specifiedLocale = specifiedLocale;
+                        this.fastNumbersCached = null;
+                    }
+                    get fastNumbers() {
+                        if (null == this.fastNumbersCached) this.fastNumbersCached = supportsFastNumbers(this);
+                        return this.fastNumbersCached;
+                    }
+                    listingMode() {
+                        const isActuallyEn = this.isEnglish();
+                        const hasNoWeirdness = (null === this.numberingSystem || "latn" === this.numberingSystem) && (null === this.outputCalendar || "gregory" === this.outputCalendar);
+                        return isActuallyEn && hasNoWeirdness ? "en" : "intl";
+                    }
+                    clone(alts) {
+                        if (!alts || 0 === Object.getOwnPropertyNames(alts).length) return this;
+                        return Locale.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, validateWeekSettings(alts.weekSettings) || this.weekSettings, alts.defaultToEN || false);
+                    }
+                    redefaultToEN(alts = {}) {
+                        return this.clone({
+                            ...alts,
+                            defaultToEN: true
+                        });
+                    }
+                    redefaultToSystem(alts = {}) {
+                        return this.clone({
+                            ...alts,
+                            defaultToEN: false
+                        });
+                    }
+                    months(length, format = false) {
+                        return listStuff(this, length, months, ()=>{
+                            const monthSpecialCase = "ja" === this.intl || this.intl.startsWith("ja-");
+                            format &= !monthSpecialCase;
+                            const intl = format ? {
+                                month: length,
+                                day: "numeric"
+                            } : {
+                                month: length
+                            }, formatStr = format ? "format" : "standalone";
+                            if (!this.monthsCache[formatStr][length]) {
+                                const mapper = monthSpecialCase ? (dt)=>this.dtFormatter(dt, intl).format() : (dt)=>this.extract(dt, intl, "month");
+                                this.monthsCache[formatStr][length] = mapMonths(mapper);
+                            }
+                            return this.monthsCache[formatStr][length];
+                        });
+                    }
+                    weekdays(length, format = false) {
+                        return listStuff(this, length, weekdays, ()=>{
+                            const intl = format ? {
+                                weekday: length,
+                                year: "numeric",
+                                month: "long",
+                                day: "numeric"
+                            } : {
+                                weekday: length
+                            }, formatStr = format ? "format" : "standalone";
+                            if (!this.weekdaysCache[formatStr][length]) this.weekdaysCache[formatStr][length] = mapWeekdays((dt)=>this.extract(dt, intl, "weekday"));
+                            return this.weekdaysCache[formatStr][length];
+                        });
+                    }
+                    meridiems() {
+                        return listStuff(this, void 0, ()=>meridiems, ()=>{
+                            if (!this.meridiemCache) {
+                                const intl = {
+                                    hour: "numeric",
+                                    hourCycle: "h12"
+                                };
+                                this.meridiemCache = [
+                                    DateTime.utc(2016, 11, 13, 9),
+                                    DateTime.utc(2016, 11, 13, 19)
+                                ].map((dt)=>this.extract(dt, intl, "dayperiod"));
+                            }
+                            return this.meridiemCache;
+                        });
+                    }
+                    eras(length) {
+                        return listStuff(this, length, eras, ()=>{
+                            const intl = {
+                                era: length
+                            };
+                            if (!this.eraCache[length]) this.eraCache[length] = [
+                                DateTime.utc(-40, 1, 1),
+                                DateTime.utc(2017, 1, 1)
+                            ].map((dt)=>this.extract(dt, intl, "era"));
+                            return this.eraCache[length];
+                        });
+                    }
+                    extract(dt, intlOpts, field) {
+                        const df = this.dtFormatter(dt, intlOpts), results = df.formatToParts(), matching = results.find((m)=>m.type.toLowerCase() === field);
+                        return matching ? matching.value : null;
+                    }
+                    numberFormatter(opts = {}) {
+                        return new PolyNumberFormatter(this.intl, opts.forceSimple || this.fastNumbers, opts);
+                    }
+                    dtFormatter(dt, intlOpts = {}) {
+                        return new PolyDateFormatter(dt, this.intl, intlOpts);
+                    }
+                    relFormatter(opts = {}) {
+                        return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
+                    }
+                    listFormatter(opts = {}) {
+                        return getCachedLF(this.intl, opts);
+                    }
+                    isEnglish() {
+                        return "en" === this.locale || "en-us" === this.locale.toLowerCase() || getCachedIntResolvedOptions(this.intl).locale.startsWith("en-us");
+                    }
+                    getWeekSettings() {
+                        if (this.weekSettings) return this.weekSettings;
+                        if (!hasLocaleWeekInfo()) return fallbackWeekSettings;
+                        return getCachedWeekInfo(this.locale);
+                    }
+                    getStartOfWeek() {
+                        return this.getWeekSettings().firstDay;
+                    }
+                    getMinDaysInFirstWeek() {
+                        return this.getWeekSettings().minimalDays;
+                    }
+                    getWeekendDays() {
+                        return this.getWeekSettings().weekend;
+                    }
+                    equals(other) {
+                        return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
+                    }
+                    toString() {
+                        return `Locale(${this.locale}, ${this.numberingSystem}, ${this.outputCalendar})`;
+                    }
+                }
+                let singleton = null;
+                class FixedOffsetZone extends Zone {
+                    static get utcInstance() {
+                        if (null === singleton) singleton = new FixedOffsetZone(0);
+                        return singleton;
+                    }
+                    static instance(offset) {
+                        return 0 === offset ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset);
+                    }
+                    static parseSpecifier(s) {
+                        if (s) {
+                            const r = s.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
+                            if (r) return new FixedOffsetZone(signedOffset(r[1], r[2]));
+                        }
+                        return null;
+                    }
+                    constructor(offset){
+                        super();
+                        this.fixed = offset;
+                    }
+                    get type() {
+                        return "fixed";
+                    }
+                    get name() {
+                        return 0 === this.fixed ? "UTC" : `UTC${luxon_formatOffset(this.fixed, "narrow")}`;
+                    }
+                    get ianaName() {
+                        if (0 === this.fixed) return "Etc/UTC";
+                        return `Etc/GMT${luxon_formatOffset(-this.fixed, "narrow")}`;
+                    }
+                    offsetName() {
+                        return this.name;
+                    }
+                    formatOffset(ts, format) {
+                        return luxon_formatOffset(this.fixed, format);
+                    }
+                    get isUniversal() {
+                        return true;
+                    }
+                    offset() {
+                        return this.fixed;
+                    }
+                    equals(otherZone) {
+                        return "fixed" === otherZone.type && otherZone.fixed === this.fixed;
+                    }
+                    get isValid() {
+                        return true;
+                    }
+                }
+                class InvalidZone extends Zone {
+                    constructor(zoneName){
+                        super();
+                        this.zoneName = zoneName;
+                    }
+                    get type() {
+                        return "invalid";
+                    }
+                    get name() {
+                        return this.zoneName;
+                    }
+                    get isUniversal() {
+                        return false;
+                    }
+                    offsetName() {
+                        return null;
+                    }
+                    formatOffset() {
+                        return "";
+                    }
+                    offset() {
+                        return NaN;
+                    }
+                    equals() {
+                        return false;
+                    }
+                    get isValid() {
+                        return false;
+                    }
+                }
+                function normalizeZone(input, defaultZone) {
+                    if (isUndefined(input) || null === input) return defaultZone;
+                    if (input instanceof Zone) return input;
+                    if (isString(input)) {
+                        const lowered = input.toLowerCase();
+                        if ("default" === lowered) return defaultZone;
+                        if ("local" === lowered || "system" === lowered) return SystemZone.instance;
+                        if ("utc" === lowered || "gmt" === lowered) return FixedOffsetZone.utcInstance;
+                        else return FixedOffsetZone.parseSpecifier(lowered) || IANAZone.create(input);
+                    }
+                    if (isNumber(input)) return FixedOffsetZone.instance(input);
+                    if ("object" == typeof input && "offset" in input && "function" == typeof input.offset) return input;
+                    else return new InvalidZone(input);
+                }
+                const numberingSystems = {
+                    arab: "[\u0660-\u0669]",
+                    arabext: "[\u06F0-\u06F9]",
+                    bali: "[\u1B50-\u1B59]",
+                    beng: "[\u09E6-\u09EF]",
+                    deva: "[\u0966-\u096F]",
+                    fullwide: "[\uFF10-\uFF19]",
+                    gujr: "[\u0AE6-\u0AEF]",
+                    hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
+                    khmr: "[\u17E0-\u17E9]",
+                    knda: "[\u0CE6-\u0CEF]",
+                    laoo: "[\u0ED0-\u0ED9]",
+                    limb: "[\u1946-\u194F]",
+                    mlym: "[\u0D66-\u0D6F]",
+                    mong: "[\u1810-\u1819]",
+                    mymr: "[\u1040-\u1049]",
+                    orya: "[\u0B66-\u0B6F]",
+                    tamldec: "[\u0BE6-\u0BEF]",
+                    telu: "[\u0C66-\u0C6F]",
+                    thai: "[\u0E50-\u0E59]",
+                    tibt: "[\u0F20-\u0F29]",
+                    latn: "\\d"
+                };
+                const numberingSystemsUTF16 = {
+                    arab: [
+                        1632,
+                        1641
+                    ],
+                    arabext: [
+                        1776,
+                        1785
+                    ],
+                    bali: [
+                        6992,
+                        7001
+                    ],
+                    beng: [
+                        2534,
+                        2543
+                    ],
+                    deva: [
+                        2406,
+                        2415
+                    ],
+                    fullwide: [
+                        65296,
+                        65303
+                    ],
+                    gujr: [
+                        2790,
+                        2799
+                    ],
+                    khmr: [
+                        6112,
+                        6121
+                    ],
+                    knda: [
+                        3302,
+                        3311
+                    ],
+                    laoo: [
+                        3792,
+                        3801
+                    ],
+                    limb: [
+                        6470,
+                        6479
+                    ],
+                    mlym: [
+                        3430,
+                        3439
+                    ],
+                    mong: [
+                        6160,
+                        6169
+                    ],
+                    mymr: [
+                        4160,
+                        4169
+                    ],
+                    orya: [
+                        2918,
+                        2927
+                    ],
+                    tamldec: [
+                        3046,
+                        3055
+                    ],
+                    telu: [
+                        3174,
+                        3183
+                    ],
+                    thai: [
+                        3664,
+                        3673
+                    ],
+                    tibt: [
+                        3872,
+                        3881
+                    ]
+                };
+                const hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split("");
+                function parseDigits(str) {
+                    let value = parseInt(str, 10);
+                    if (!isNaN(value)) return value;
+                    value = "";
+                    for(let i = 0; i < str.length; i++){
+                        const code = str.charCodeAt(i);
+                        if (-1 !== str[i].search(numberingSystems.hanidec)) value += hanidecChars.indexOf(str[i]);
+                        else for(const key in numberingSystemsUTF16){
+                            const [min, max] = numberingSystemsUTF16[key];
+                            if (code >= min && code <= max) value += code - min;
+                        }
+                    }
+                    return parseInt(value, 10);
+                }
+                const digitRegexCache = new Map();
+                function resetDigitRegexCache() {
+                    digitRegexCache.clear();
+                }
+                function digitRegex({ numberingSystem }, append = "") {
+                    const ns = numberingSystem || "latn";
+                    let appendCache = digitRegexCache.get(ns);
+                    if (void 0 === appendCache) {
+                        appendCache = new Map();
+                        digitRegexCache.set(ns, appendCache);
+                    }
+                    let regex = appendCache.get(append);
+                    if (void 0 === regex) {
+                        regex = new RegExp(`${numberingSystems[ns]}${append}`);
+                        appendCache.set(append, regex);
+                    }
+                    return regex;
+                }
+                let now = ()=>Date.now(), luxon_defaultZone = "system", defaultLocale = null, defaultNumberingSystem = null, defaultOutputCalendar = null, twoDigitCutoffYear = 60, throwOnInvalid, defaultWeekSettings = null;
+                class Settings {
+                    static get now() {
+                        return now;
+                    }
+                    static set now(n) {
+                        now = n;
+                    }
+                    static set defaultZone(zone) {
+                        luxon_defaultZone = zone;
+                    }
+                    static get defaultZone() {
+                        return normalizeZone(luxon_defaultZone, SystemZone.instance);
+                    }
+                    static get defaultLocale() {
+                        return defaultLocale;
+                    }
+                    static set defaultLocale(locale) {
+                        defaultLocale = locale;
+                    }
+                    static get defaultNumberingSystem() {
+                        return defaultNumberingSystem;
+                    }
+                    static set defaultNumberingSystem(numberingSystem) {
+                        defaultNumberingSystem = numberingSystem;
+                    }
+                    static get defaultOutputCalendar() {
+                        return defaultOutputCalendar;
+                    }
+                    static set defaultOutputCalendar(outputCalendar) {
+                        defaultOutputCalendar = outputCalendar;
+                    }
+                    static get defaultWeekSettings() {
+                        return defaultWeekSettings;
+                    }
+                    static set defaultWeekSettings(weekSettings) {
+                        defaultWeekSettings = validateWeekSettings(weekSettings);
+                    }
+                    static get twoDigitCutoffYear() {
+                        return twoDigitCutoffYear;
+                    }
+                    static set twoDigitCutoffYear(cutoffYear) {
+                        twoDigitCutoffYear = cutoffYear % 100;
+                    }
+                    static get throwOnInvalid() {
+                        return throwOnInvalid;
+                    }
+                    static set throwOnInvalid(t) {
+                        throwOnInvalid = t;
+                    }
+                    static resetCaches() {
+                        Locale.resetCache();
+                        IANAZone.resetCache();
+                        DateTime.resetCache();
+                        resetDigitRegexCache();
+                    }
+                }
+                class Invalid {
+                    constructor(reason, explanation){
+                        this.reason = reason;
+                        this.explanation = explanation;
+                    }
+                    toMessage() {
+                        if (this.explanation) return `${this.reason}: ${this.explanation}`;
+                        return this.reason;
+                    }
+                }
+                const nonLeapLadder = [
+                    0,
+                    31,
+                    59,
+                    90,
+                    120,
+                    151,
+                    181,
+                    212,
+                    243,
+                    273,
+                    304,
+                    334
+                ], leapLadder = [
+                    0,
+                    31,
+                    60,
+                    91,
+                    121,
+                    152,
+                    182,
+                    213,
+                    244,
+                    274,
+                    305,
+                    335
+                ];
+                function unitOutOfRange(unit, value) {
+                    return new Invalid("unit out of range", `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`);
+                }
+                function dayOfWeek(year, month, day) {
+                    const d = new Date(Date.UTC(year, month - 1, day));
+                    if (year < 100 && year >= 0) d.setUTCFullYear(d.getUTCFullYear() - 1900);
+                    const js = d.getUTCDay();
+                    return 0 === js ? 7 : js;
+                }
+                function computeOrdinal(year, month, day) {
+                    return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
+                }
+                function uncomputeOrdinal(year, ordinal) {
+                    const table = isLeapYear(year) ? leapLadder : nonLeapLadder, month0 = table.findIndex((i)=>i < ordinal), day = ordinal - table[month0];
+                    return {
+                        month: month0 + 1,
+                        day
+                    };
+                }
+                function isoWeekdayToLocal(isoWeekday, startOfWeek) {
+                    return (isoWeekday - startOfWeek + 7) % 7 + 1;
+                }
+                function gregorianToWeek(gregObj, minDaysInFirstWeek = 4, startOfWeek = 1) {
+                    const { year, month, day } = gregObj, ordinal = computeOrdinal(year, month, day), weekday = isoWeekdayToLocal(dayOfWeek(year, month, day), startOfWeek);
+                    let weekNumber = Math.floor((ordinal - weekday + 14 - minDaysInFirstWeek) / 7), weekYear;
+                    if (weekNumber < 1) {
+                        weekYear = year - 1;
+                        weekNumber = weeksInWeekYear(weekYear, minDaysInFirstWeek, startOfWeek);
+                    } else if (weekNumber > weeksInWeekYear(year, minDaysInFirstWeek, startOfWeek)) {
+                        weekYear = year + 1;
+                        weekNumber = 1;
+                    } else weekYear = year;
+                    return {
+                        weekYear,
+                        weekNumber,
+                        weekday,
+                        ...timeObject(gregObj)
+                    };
+                }
+                function weekToGregorian(weekData, minDaysInFirstWeek = 4, startOfWeek = 1) {
+                    const { weekYear, weekNumber, weekday } = weekData, weekdayOfJan4 = isoWeekdayToLocal(dayOfWeek(weekYear, 1, minDaysInFirstWeek), startOfWeek), yearInDays = daysInYear(weekYear);
+                    let ordinal = 7 * weekNumber + weekday - weekdayOfJan4 - 7 + minDaysInFirstWeek, year;
+                    if (ordinal < 1) {
+                        year = weekYear - 1;
+                        ordinal += daysInYear(year);
+                    } else if (ordinal > yearInDays) {
+                        year = weekYear + 1;
+                        ordinal -= daysInYear(weekYear);
+                    } else year = weekYear;
+                    const { month, day } = uncomputeOrdinal(year, ordinal);
+                    return {
+                        year,
+                        month,
+                        day,
+                        ...timeObject(weekData)
+                    };
+                }
+                function gregorianToOrdinal(gregData) {
+                    const { year, month, day } = gregData;
+                    const ordinal = computeOrdinal(year, month, day);
+                    return {
+                        year,
+                        ordinal,
+                        ...timeObject(gregData)
+                    };
+                }
+                function ordinalToGregorian(ordinalData) {
+                    const { year, ordinal } = ordinalData;
+                    const { month, day } = uncomputeOrdinal(year, ordinal);
+                    return {
+                        year,
+                        month,
+                        day,
+                        ...timeObject(ordinalData)
+                    };
+                }
+                function usesLocalWeekValues(obj, loc) {
+                    const hasLocaleWeekData = !isUndefined(obj.localWeekday) || !isUndefined(obj.localWeekNumber) || !isUndefined(obj.localWeekYear);
+                    if (!hasLocaleWeekData) return {
+                        minDaysInFirstWeek: 4,
+                        startOfWeek: 1
+                    };
+                    {
+                        const hasIsoWeekData = !isUndefined(obj.weekday) || !isUndefined(obj.weekNumber) || !isUndefined(obj.weekYear);
+                        if (hasIsoWeekData) throw new ConflictingSpecificationError("Cannot mix locale-based week fields with ISO-based week fields");
+                        if (!isUndefined(obj.localWeekday)) obj.weekday = obj.localWeekday;
+                        if (!isUndefined(obj.localWeekNumber)) obj.weekNumber = obj.localWeekNumber;
+                        if (!isUndefined(obj.localWeekYear)) obj.weekYear = obj.localWeekYear;
+                        delete obj.localWeekday;
+                        delete obj.localWeekNumber;
+                        delete obj.localWeekYear;
+                        return {
+                            minDaysInFirstWeek: loc.getMinDaysInFirstWeek(),
+                            startOfWeek: loc.getStartOfWeek()
+                        };
+                    }
+                }
+                function hasInvalidWeekData(obj, minDaysInFirstWeek = 4, startOfWeek = 1) {
+                    const validYear = isInteger(obj.weekYear), validWeek = integerBetween(obj.weekNumber, 1, weeksInWeekYear(obj.weekYear, minDaysInFirstWeek, startOfWeek)), validWeekday = integerBetween(obj.weekday, 1, 7);
+                    if (!validYear) return unitOutOfRange("weekYear", obj.weekYear);
+                    if (!validWeek) return unitOutOfRange("week", obj.weekNumber);
+                    if (!validWeekday) return unitOutOfRange("weekday", obj.weekday);
+                    return false;
+                }
+                function hasInvalidOrdinalData(obj) {
+                    const validYear = isInteger(obj.year), validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year));
+                    if (!validYear) return unitOutOfRange("year", obj.year);
+                    if (!validOrdinal) return unitOutOfRange("ordinal", obj.ordinal);
+                    return false;
+                }
+                function hasInvalidGregorianData(obj) {
+                    const validYear = isInteger(obj.year), validMonth = integerBetween(obj.month, 1, 12), validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month));
+                    if (!validYear) return unitOutOfRange("year", obj.year);
+                    if (!validMonth) return unitOutOfRange("month", obj.month);
+                    if (!validDay) return unitOutOfRange("day", obj.day);
+                    return false;
+                }
+                function hasInvalidTimeData(obj) {
+                    const { hour, minute, second, millisecond } = obj;
+                    const validHour = integerBetween(hour, 0, 23) || 24 === hour && 0 === minute && 0 === second && 0 === millisecond, validMinute = integerBetween(minute, 0, 59), validSecond = integerBetween(second, 0, 59), validMillisecond = integerBetween(millisecond, 0, 999);
+                    if (!validHour) return unitOutOfRange("hour", hour);
+                    if (!validMinute) return unitOutOfRange("minute", minute);
+                    if (!validSecond) return unitOutOfRange("second", second);
+                    if (!validMillisecond) return unitOutOfRange("millisecond", millisecond);
+                    return false;
+                }
+                function isUndefined(o) {
+                    return void 0 === o;
+                }
+                function isNumber(o) {
+                    return "number" == typeof o;
+                }
+                function isInteger(o) {
+                    return "number" == typeof o && o % 1 === 0;
+                }
+                function isString(o) {
+                    return "string" == typeof o;
+                }
+                function isDate(o) {
+                    return "[object Date]" === Object.prototype.toString.call(o);
+                }
+                function hasRelative() {
+                    try {
+                        return "u" > typeof Intl && !!Intl.RelativeTimeFormat;
+                    } catch (e) {
+                        return false;
+                    }
+                }
+                function hasLocaleWeekInfo() {
+                    try {
+                        return "u" > typeof Intl && !!Intl.Locale && ("weekInfo" in Intl.Locale.prototype || "getWeekInfo" in Intl.Locale.prototype);
+                    } catch (e) {
+                        return false;
+                    }
+                }
+                function maybeArray(thing) {
+                    return Array.isArray(thing) ? thing : [
+                        thing
+                    ];
+                }
+                function bestBy(arr, by, compare) {
+                    if (0 === arr.length) return;
+                    return arr.reduce((best, next)=>{
+                        const pair = [
+                            by(next),
+                            next
+                        ];
+                        if (!best) return pair;
+                        if (compare(best[0], pair[0]) === best[0]) return best;
+                        return pair;
+                    }, null)[1];
+                }
+                function pick(obj, keys) {
+                    return keys.reduce((a, k)=>{
+                        a[k] = obj[k];
+                        return a;
+                    }, {});
+                }
+                function luxon_hasOwnProperty(obj, prop) {
+                    return Object.prototype.hasOwnProperty.call(obj, prop);
+                }
+                function validateWeekSettings(settings) {
+                    if (null == settings) return null;
+                    if ("object" != typeof settings) throw new InvalidArgumentError("Week settings must be an object");
+                    if (!integerBetween(settings.firstDay, 1, 7) || !integerBetween(settings.minimalDays, 1, 7) || !Array.isArray(settings.weekend) || settings.weekend.some((v)=>!integerBetween(v, 1, 7))) throw new InvalidArgumentError("Invalid week settings");
+                    return {
+                        firstDay: settings.firstDay,
+                        minimalDays: settings.minimalDays,
+                        weekend: Array.from(settings.weekend)
+                    };
+                }
+                function integerBetween(thing, bottom, top) {
+                    return isInteger(thing) && thing >= bottom && thing <= top;
+                }
+                function floorMod(x, n) {
+                    return x - n * Math.floor(x / n);
+                }
+                function padStart(input, n = 2) {
+                    const isNeg = input < 0;
+                    let padded;
+                    padded = isNeg ? "-" + ("" + -input).padStart(n, "0") : ("" + input).padStart(n, "0");
+                    return padded;
+                }
+                function parseInteger(string) {
+                    if (isUndefined(string) || null === string || "" === string) return;
+                    return parseInt(string, 10);
+                }
+                function parseFloating(string) {
+                    if (isUndefined(string) || null === string || "" === string) return;
+                    return parseFloat(string);
+                }
+                function parseMillis(fraction) {
+                    if (isUndefined(fraction) || null === fraction || "" === fraction) return;
+                    {
+                        const f = 1000 * parseFloat("0." + fraction);
+                        return Math.floor(f);
+                    }
+                }
+                function roundTo(number, digits, rounding = "round") {
+                    const factor = 10 ** digits;
+                    switch(rounding){
+                        case "expand":
+                            return number > 0 ? Math.ceil(number * factor) / factor : Math.floor(number * factor) / factor;
+                        case "trunc":
+                            return Math.trunc(number * factor) / factor;
+                        case "round":
+                            return Math.round(number * factor) / factor;
+                        case "floor":
+                            return Math.floor(number * factor) / factor;
+                        case "ceil":
+                            return Math.ceil(number * factor) / factor;
+                        default:
+                            throw new RangeError(`Value rounding ${rounding} is out of range`);
+                    }
+                }
+                function isLeapYear(year) {
+                    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+                }
+                function daysInYear(year) {
+                    return isLeapYear(year) ? 366 : 365;
+                }
+                function daysInMonth(year, month) {
+                    const modMonth = floorMod(month - 1, 12) + 1, modYear = year + (month - modMonth) / 12;
+                    if (2 === modMonth) return isLeapYear(modYear) ? 29 : 28;
+                    return [
+                        31,
+                        null,
+                        31,
+                        30,
+                        31,
+                        30,
+                        31,
+                        31,
+                        30,
+                        31,
+                        30,
+                        31
+                    ][modMonth - 1];
+                }
+                function objToLocalTS(obj) {
+                    let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
+                    if (obj.year < 100 && obj.year >= 0) {
+                        d = new Date(d);
+                        d.setUTCFullYear(obj.year, obj.month - 1, obj.day);
+                    }
+                    return +d;
+                }
+                function firstWeekOffset(year, minDaysInFirstWeek, startOfWeek) {
+                    const fwdlw = isoWeekdayToLocal(dayOfWeek(year, 1, minDaysInFirstWeek), startOfWeek);
+                    return -fwdlw + minDaysInFirstWeek - 1;
+                }
+                function weeksInWeekYear(weekYear, minDaysInFirstWeek = 4, startOfWeek = 1) {
+                    const weekOffset = firstWeekOffset(weekYear, minDaysInFirstWeek, startOfWeek);
+                    const weekOffsetNext = firstWeekOffset(weekYear + 1, minDaysInFirstWeek, startOfWeek);
+                    return (daysInYear(weekYear) - weekOffset + weekOffsetNext) / 7;
+                }
+                function untruncateYear(year) {
+                    if (year > 99) return year;
+                    return year > Settings.twoDigitCutoffYear ? 1900 + year : 2000 + year;
+                }
+                function parseZoneInfo(ts, offsetFormat, locale, timeZone = null) {
+                    const date = new Date(ts), intlOpts = {
+                        hourCycle: "h23",
+                        year: "numeric",
+                        month: "2-digit",
+                        day: "2-digit",
+                        hour: "2-digit",
+                        minute: "2-digit"
+                    };
+                    if (timeZone) intlOpts.timeZone = timeZone;
+                    const modified = {
+                        timeZoneName: offsetFormat,
+                        ...intlOpts
+                    };
+                    const parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find((m)=>"timezonename" === m.type.toLowerCase());
+                    return parsed ? parsed.value : null;
+                }
+                function signedOffset(offHourStr, offMinuteStr) {
+                    let offHour = parseInt(offHourStr, 10);
+                    if (Number.isNaN(offHour)) offHour = 0;
+                    const offMin = parseInt(offMinuteStr, 10) || 0, offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin;
+                    return 60 * offHour + offMinSigned;
+                }
+                function asNumber(value) {
+                    const numericValue = Number(value);
+                    if ("boolean" == typeof value || "" === value || !Number.isFinite(numericValue)) throw new InvalidArgumentError(`Invalid unit value ${value}`);
+                    return numericValue;
+                }
+                function normalizeObject(obj, normalizer) {
+                    const normalized = {};
+                    for(const u in obj)if (luxon_hasOwnProperty(obj, u)) {
+                        const v = obj[u];
+                        if (null == v) continue;
+                        normalized[normalizer(u)] = asNumber(v);
+                    }
+                    return normalized;
+                }
+                function luxon_formatOffset(offset, format) {
+                    const hours = Math.trunc(Math.abs(offset / 60)), minutes = Math.trunc(Math.abs(offset % 60)), sign = offset >= 0 ? "+" : "-";
+                    switch(format){
+                        case "short":
+                            return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`;
+                        case "narrow":
+                            return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`;
+                        case "techie":
+                            return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`;
+                        default:
+                            throw new RangeError(`Value format ${format} is out of range for property format`);
+                    }
+                }
+                function timeObject(obj) {
+                    return pick(obj, [
+                        "hour",
+                        "minute",
+                        "second",
+                        "millisecond"
+                    ]);
+                }
+                const monthsLong = [
+                    "January",
+                    "February",
+                    "March",
+                    "April",
+                    "May",
+                    "June",
+                    "July",
+                    "August",
+                    "September",
+                    "October",
+                    "November",
+                    "December"
+                ];
+                const monthsShort = [
+                    "Jan",
+                    "Feb",
+                    "Mar",
+                    "Apr",
+                    "May",
+                    "Jun",
+                    "Jul",
+                    "Aug",
+                    "Sep",
+                    "Oct",
+                    "Nov",
+                    "Dec"
+                ];
+                const monthsNarrow = [
+                    "J",
+                    "F",
+                    "M",
+                    "A",
+                    "M",
+                    "J",
+                    "J",
+                    "A",
+                    "S",
+                    "O",
+                    "N",
+                    "D"
+                ];
+                function months(length) {
+                    switch(length){
+                        case "narrow":
+                            return [
+                                ...monthsNarrow
+                            ];
+                        case "short":
+                            return [
+                                ...monthsShort
+                            ];
+                        case "long":
+                            return [
+                                ...monthsLong
+                            ];
+                        case "numeric":
+                            return [
+                                "1",
+                                "2",
+                                "3",
+                                "4",
+                                "5",
+                                "6",
+                                "7",
+                                "8",
+                                "9",
+                                "10",
+                                "11",
+                                "12"
+                            ];
+                        case "2-digit":
+                            return [
+                                "01",
+                                "02",
+                                "03",
+                                "04",
+                                "05",
+                                "06",
+                                "07",
+                                "08",
+                                "09",
+                                "10",
+                                "11",
+                                "12"
+                            ];
+                        default:
+                            return null;
+                    }
+                }
+                const weekdaysLong = [
+                    "Monday",
+                    "Tuesday",
+                    "Wednesday",
+                    "Thursday",
+                    "Friday",
+                    "Saturday",
+                    "Sunday"
+                ];
+                const weekdaysShort = [
+                    "Mon",
+                    "Tue",
+                    "Wed",
+                    "Thu",
+                    "Fri",
+                    "Sat",
+                    "Sun"
+                ];
+                const weekdaysNarrow = [
+                    "M",
+                    "T",
+                    "W",
+                    "T",
+                    "F",
+                    "S",
+                    "S"
+                ];
+                function weekdays(length) {
+                    switch(length){
+                        case "narrow":
+                            return [
+                                ...weekdaysNarrow
+                            ];
+                        case "short":
+                            return [
+                                ...weekdaysShort
+                            ];
+                        case "long":
+                            return [
+                                ...weekdaysLong
+                            ];
+                        case "numeric":
+                            return [
+                                "1",
+                                "2",
+                                "3",
+                                "4",
+                                "5",
+                                "6",
+                                "7"
+                            ];
+                        default:
+                            return null;
+                    }
+                }
+                const meridiems = [
+                    "AM",
+                    "PM"
+                ];
+                const erasLong = [
+                    "Before Christ",
+                    "Anno Domini"
+                ];
+                const erasShort = [
+                    "BC",
+                    "AD"
+                ];
+                const erasNarrow = [
+                    "B",
+                    "A"
+                ];
+                function eras(length) {
+                    switch(length){
+                        case "narrow":
+                            return [
+                                ...erasNarrow
+                            ];
+                        case "short":
+                            return [
+                                ...erasShort
+                            ];
+                        case "long":
+                            return [
+                                ...erasLong
+                            ];
+                        default:
+                            return null;
+                    }
+                }
+                function meridiemForDateTime(dt) {
+                    return meridiems[dt.hour < 12 ? 0 : 1];
+                }
+                function weekdayForDateTime(dt, length) {
+                    return weekdays(length)[dt.weekday - 1];
+                }
+                function monthForDateTime(dt, length) {
+                    return months(length)[dt.month - 1];
+                }
+                function eraForDateTime(dt, length) {
+                    return eras(length)[dt.year < 0 ? 0 : 1];
+                }
+                function formatRelativeTime(unit, count, numeric = "always", narrow = false) {
+                    const units = {
+                        years: [
+                            "year",
+                            "yr."
+                        ],
+                        quarters: [
+                            "quarter",
+                            "qtr."
+                        ],
+                        months: [
+                            "month",
+                            "mo."
+                        ],
+                        weeks: [
+                            "week",
+                            "wk."
+                        ],
+                        days: [
+                            "day",
+                            "day",
+                            "days"
+                        ],
+                        hours: [
+                            "hour",
+                            "hr."
+                        ],
+                        minutes: [
+                            "minute",
+                            "min."
+                        ],
+                        seconds: [
+                            "second",
+                            "sec."
+                        ]
+                    };
+                    const lastable = -1 === [
+                        "hours",
+                        "minutes",
+                        "seconds"
+                    ].indexOf(unit);
+                    if ("auto" === numeric && lastable) {
+                        const isDay = "days" === unit;
+                        switch(count){
+                            case 1:
+                                return isDay ? "tomorrow" : `next ${units[unit][0]}`;
+                            case -1:
+                                return isDay ? "yesterday" : `last ${units[unit][0]}`;
+                            case 0:
+                                return isDay ? "today" : `this ${units[unit][0]}`;
+                        }
+                    }
+                    const isInPast = Object.is(count, -0) || count < 0, fmtValue = Math.abs(count), singular = 1 === fmtValue, lilUnits = units[unit], fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit;
+                    return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`;
+                }
+                function stringifyTokens(splits, tokenToString) {
+                    let s = "";
+                    for (const token of splits)if (token.literal) s += token.val;
+                    else s += tokenToString(token.val);
+                    return s;
+                }
+                const macroTokenToFormatOpts = {
+                    D: DATE_SHORT,
+                    DD: DATE_MED,
+                    DDD: DATE_FULL,
+                    DDDD: DATE_HUGE,
+                    t: TIME_SIMPLE,
+                    tt: TIME_WITH_SECONDS,
+                    ttt: TIME_WITH_SHORT_OFFSET,
+                    tttt: TIME_WITH_LONG_OFFSET,
+                    T: TIME_24_SIMPLE,
+                    TT: TIME_24_WITH_SECONDS,
+                    TTT: TIME_24_WITH_SHORT_OFFSET,
+                    TTTT: TIME_24_WITH_LONG_OFFSET,
+                    f: DATETIME_SHORT,
+                    ff: DATETIME_MED,
+                    fff: DATETIME_FULL,
+                    ffff: DATETIME_HUGE,
+                    F: DATETIME_SHORT_WITH_SECONDS,
+                    FF: DATETIME_MED_WITH_SECONDS,
+                    FFF: DATETIME_FULL_WITH_SECONDS,
+                    FFFF: DATETIME_HUGE_WITH_SECONDS
+                };
+                class Formatter {
+                    static create(locale, opts = {}) {
+                        return new Formatter(locale, opts);
+                    }
+                    static parseFormat(fmt) {
+                        let current = null, currentFull = "", bracketed = false;
+                        const splits = [];
+                        for(let i = 0; i < fmt.length; i++){
+                            const c = fmt.charAt(i);
+                            if ("'" === c) {
+                                if (currentFull.length > 0 || bracketed) splits.push({
+                                    literal: bracketed || /^\s+$/.test(currentFull),
+                                    val: "" === currentFull ? "'" : currentFull
+                                });
+                                current = null;
+                                currentFull = "";
+                                bracketed = !bracketed;
+                            } else if (bracketed) currentFull += c;
+                            else if (c === current) currentFull += c;
+                            else {
+                                if (currentFull.length > 0) splits.push({
+                                    literal: /^\s+$/.test(currentFull),
+                                    val: currentFull
+                                });
+                                currentFull = c;
+                                current = c;
+                            }
+                        }
+                        if (currentFull.length > 0) splits.push({
+                            literal: bracketed || /^\s+$/.test(currentFull),
+                            val: currentFull
+                        });
+                        return splits;
+                    }
+                    static macroTokenToFormatOpts(token) {
+                        return macroTokenToFormatOpts[token];
+                    }
+                    constructor(locale, formatOpts){
+                        this.opts = formatOpts;
+                        this.loc = locale;
+                        this.systemLoc = null;
+                    }
+                    formatWithSystemDefault(dt, opts) {
+                        if (null === this.systemLoc) this.systemLoc = this.loc.redefaultToSystem();
+                        const df = this.systemLoc.dtFormatter(dt, {
+                            ...this.opts,
+                            ...opts
+                        });
+                        return df.format();
+                    }
+                    dtFormatter(dt, opts = {}) {
+                        return this.loc.dtFormatter(dt, {
+                            ...this.opts,
+                            ...opts
+                        });
+                    }
+                    formatDateTime(dt, opts) {
+                        return this.dtFormatter(dt, opts).format();
+                    }
+                    formatDateTimeParts(dt, opts) {
+                        return this.dtFormatter(dt, opts).formatToParts();
+                    }
+                    formatInterval(interval, opts) {
+                        const df = this.dtFormatter(interval.start, opts);
+                        return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate());
+                    }
+                    resolvedOptions(dt, opts) {
+                        return this.dtFormatter(dt, opts).resolvedOptions();
+                    }
+                    num(n, p = 0, signDisplay) {
+                        if (this.opts.forceSimple) return padStart(n, p);
+                        const opts = {
+                            ...this.opts
+                        };
+                        if (p > 0) opts.padTo = p;
+                        if (signDisplay) opts.signDisplay = signDisplay;
+                        return this.loc.numberFormatter(opts).format(n);
+                    }
+                    formatDateTimeFromString(dt, fmt) {
+                        const knownEnglish = "en" === this.loc.listingMode(), useDateTimeFormatter = this.loc.outputCalendar && "gregory" !== this.loc.outputCalendar, string = (opts, extract)=>this.loc.extract(dt, opts, extract), formatOffset = (opts)=>{
+                            if (dt.isOffsetFixed && 0 === dt.offset && opts.allowZ) return "Z";
+                            return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : "";
+                        }, meridiem = ()=>knownEnglish ? meridiemForDateTime(dt) : string({
+                                hour: "numeric",
+                                hourCycle: "h12"
+                            }, "dayperiod"), month = (length, standalone)=>knownEnglish ? monthForDateTime(dt, length) : string(standalone ? {
+                                month: length
+                            } : {
+                                month: length,
+                                day: "numeric"
+                            }, "month"), weekday = (length, standalone)=>knownEnglish ? weekdayForDateTime(dt, length) : string(standalone ? {
+                                weekday: length
+                            } : {
+                                weekday: length,
+                                month: "long",
+                                day: "numeric"
+                            }, "weekday"), maybeMacro = (token)=>{
+                            const formatOpts = Formatter.macroTokenToFormatOpts(token);
+                            if (formatOpts) return this.formatWithSystemDefault(dt, formatOpts);
+                            return token;
+                        }, era = (length)=>knownEnglish ? eraForDateTime(dt, length) : string({
+                                era: length
+                            }, "era"), tokenToString = (token)=>{
+                            switch(token){
+                                case "S":
+                                    return this.num(dt.millisecond);
+                                case "u":
+                                case "SSS":
+                                    return this.num(dt.millisecond, 3);
+                                case "s":
+                                    return this.num(dt.second);
+                                case "ss":
+                                    return this.num(dt.second, 2);
+                                case "uu":
+                                    return this.num(Math.floor(dt.millisecond / 10), 2);
+                                case "uuu":
+                                    return this.num(Math.floor(dt.millisecond / 100));
+                                case "m":
+                                    return this.num(dt.minute);
+                                case "mm":
+                                    return this.num(dt.minute, 2);
+                                case "h":
+                                    return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12);
+                                case "hh":
+                                    return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2);
+                                case "H":
+                                    return this.num(dt.hour);
+                                case "HH":
+                                    return this.num(dt.hour, 2);
+                                case "Z":
+                                    return formatOffset({
+                                        format: "narrow",
+                                        allowZ: this.opts.allowZ
+                                    });
+                                case "ZZ":
+                                    return formatOffset({
+                                        format: "short",
+                                        allowZ: this.opts.allowZ
+                                    });
+                                case "ZZZ":
+                                    return formatOffset({
+                                        format: "techie",
+                                        allowZ: this.opts.allowZ
+                                    });
+                                case "ZZZZ":
+                                    return dt.zone.offsetName(dt.ts, {
+                                        format: "short",
+                                        locale: this.loc.locale
+                                    });
+                                case "ZZZZZ":
+                                    return dt.zone.offsetName(dt.ts, {
+                                        format: "long",
+                                        locale: this.loc.locale
+                                    });
+                                case "z":
+                                    return dt.zoneName;
+                                case "a":
+                                    return meridiem();
+                                case "d":
+                                    return useDateTimeFormatter ? string({
+                                        day: "numeric"
+                                    }, "day") : this.num(dt.day);
+                                case "dd":
+                                    return useDateTimeFormatter ? string({
+                                        day: "2-digit"
+                                    }, "day") : this.num(dt.day, 2);
+                                case "c":
+                                    return this.num(dt.weekday);
+                                case "ccc":
+                                    return weekday("short", true);
+                                case "cccc":
+                                    return weekday("long", true);
+                                case "ccccc":
+                                    return weekday("narrow", true);
+                                case "E":
+                                    return this.num(dt.weekday);
+                                case "EEE":
+                                    return weekday("short", false);
+                                case "EEEE":
+                                    return weekday("long", false);
+                                case "EEEEE":
+                                    return weekday("narrow", false);
+                                case "L":
+                                    return useDateTimeFormatter ? string({
+                                        month: "numeric",
+                                        day: "numeric"
+                                    }, "month") : this.num(dt.month);
+                                case "LL":
+                                    return useDateTimeFormatter ? string({
+                                        month: "2-digit",
+                                        day: "numeric"
+                                    }, "month") : this.num(dt.month, 2);
+                                case "LLL":
+                                    return month("short", true);
+                                case "LLLL":
+                                    return month("long", true);
+                                case "LLLLL":
+                                    return month("narrow", true);
+                                case "M":
+                                    return useDateTimeFormatter ? string({
+                                        month: "numeric"
+                                    }, "month") : this.num(dt.month);
+                                case "MM":
+                                    return useDateTimeFormatter ? string({
+                                        month: "2-digit"
+                                    }, "month") : this.num(dt.month, 2);
+                                case "MMM":
+                                    return month("short", false);
+                                case "MMMM":
+                                    return month("long", false);
+                                case "MMMMM":
+                                    return month("narrow", false);
+                                case "y":
+                                    return useDateTimeFormatter ? string({
+                                        year: "numeric"
+                                    }, "year") : this.num(dt.year);
+                                case "yy":
+                                    return useDateTimeFormatter ? string({
+                                        year: "2-digit"
+                                    }, "year") : this.num(dt.year.toString().slice(-2), 2);
+                                case "yyyy":
+                                    return useDateTimeFormatter ? string({
+                                        year: "numeric"
+                                    }, "year") : this.num(dt.year, 4);
+                                case "yyyyyy":
+                                    return useDateTimeFormatter ? string({
+                                        year: "numeric"
+                                    }, "year") : this.num(dt.year, 6);
+                                case "G":
+                                    return era("short");
+                                case "GG":
+                                    return era("long");
+                                case "GGGGG":
+                                    return era("narrow");
+                                case "kk":
+                                    return this.num(dt.weekYear.toString().slice(-2), 2);
+                                case "kkkk":
+                                    return this.num(dt.weekYear, 4);
+                                case "W":
+                                    return this.num(dt.weekNumber);
+                                case "WW":
+                                    return this.num(dt.weekNumber, 2);
+                                case "n":
+                                    return this.num(dt.localWeekNumber);
+                                case "nn":
+                                    return this.num(dt.localWeekNumber, 2);
+                                case "ii":
+                                    return this.num(dt.localWeekYear.toString().slice(-2), 2);
+                                case "iiii":
+                                    return this.num(dt.localWeekYear, 4);
+                                case "o":
+                                    return this.num(dt.ordinal);
+                                case "ooo":
+                                    return this.num(dt.ordinal, 3);
+                                case "q":
+                                    return this.num(dt.quarter);
+                                case "qq":
+                                    return this.num(dt.quarter, 2);
+                                case "X":
+                                    return this.num(Math.floor(dt.ts / 1000));
+                                case "x":
+                                    return this.num(dt.ts);
+                                default:
+                                    return maybeMacro(token);
+                            }
+                        };
+                        return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
+                    }
+                    formatDurationFromString(dur, fmt) {
+                        const invertLargest = "negativeLargestOnly" === this.opts.signMode ? -1 : 1;
+                        const tokenToField = (token)=>{
+                            switch(token[0]){
+                                case "S":
+                                    return "milliseconds";
+                                case "s":
+                                    return "seconds";
+                                case "m":
+                                    return "minutes";
+                                case "h":
+                                    return "hours";
+                                case "d":
+                                    return "days";
+                                case "w":
+                                    return "weeks";
+                                case "M":
+                                    return "months";
+                                case "y":
+                                    return "years";
+                                default:
+                                    return null;
+                            }
+                        }, tokenToString = (lildur, info)=>(token)=>{
+                                const mapped = tokenToField(token);
+                                if (!mapped) return token;
+                                {
+                                    const inversionFactor = info.isNegativeDuration && mapped !== info.largestUnit ? invertLargest : 1;
+                                    let signDisplay;
+                                    signDisplay = "negativeLargestOnly" === this.opts.signMode && mapped !== info.largestUnit ? "never" : "all" === this.opts.signMode ? "always" : "auto";
+                                    return this.num(lildur.get(mapped) * inversionFactor, token.length, signDisplay);
+                                }
+                            }, tokens = Formatter.parseFormat(fmt), realTokens = tokens.reduce((found, { literal, val })=>literal ? found : found.concat(val), []), collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter((t)=>t)), durationInfo = {
+                            isNegativeDuration: collapsed < 0,
+                            largestUnit: Object.keys(collapsed.values)[0]
+                        };
+                        return stringifyTokens(tokens, tokenToString(collapsed, durationInfo));
+                    }
+                }
+                const ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
+                function combineRegexes(...regexes) {
+                    const full = regexes.reduce((f, r)=>f + r.source, "");
+                    return RegExp(`^${full}$`);
+                }
+                function combineExtractors(...extractors) {
+                    return (m)=>extractors.reduce(([mergedVals, mergedZone, cursor], ex)=>{
+                            const [val, zone, next] = ex(m, cursor);
+                            return [
+                                {
+                                    ...mergedVals,
+                                    ...val
+                                },
+                                zone || mergedZone,
+                                next
+                            ];
+                        }, [
+                            {},
+                            null,
+                            1
+                        ]).slice(0, 2);
+                }
+                function parse(s, ...patterns) {
+                    if (null == s) return [
+                        null,
+                        null
+                    ];
+                    for (const [regex, extractor] of patterns){
+                        const m = regex.exec(s);
+                        if (m) return extractor(m);
+                    }
+                    return [
+                        null,
+                        null
+                    ];
+                }
+                function simpleParse(...keys) {
+                    return (match, cursor)=>{
+                        const ret = {};
+                        let i;
+                        for(i = 0; i < keys.length; i++)ret[keys[i]] = parseInteger(match[cursor + i]);
+                        return [
+                            ret,
+                            null,
+                            cursor + i
+                        ];
+                    };
+                }
+                const offsetRegex = /(?:([Zz])|([+-]\d\d)(?::?(\d\d))?)/;
+                const isoExtendedZone = `(?:${offsetRegex.source}?(?:\\[(${ianaRegex.source})\\])?)?`;
+                const isoTimeBaseRegex = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/;
+                const isoTimeRegex = RegExp(`${isoTimeBaseRegex.source}${isoExtendedZone}`);
+                const isoTimeExtensionRegex = RegExp(`(?:[Tt]${isoTimeRegex.source})?`);
+                const isoYmdRegex = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/;
+                const isoWeekRegex = /(\d{4})-?W(\d\d)(?:-?(\d))?/;
+                const isoOrdinalRegex = /(\d{4})-?(\d{3})/;
+                const extractISOWeekData = simpleParse("weekYear", "weekNumber", "weekDay");
+                const extractISOOrdinalData = simpleParse("year", "ordinal");
+                const sqlYmdRegex = /(\d{4})-(\d\d)-(\d\d)/;
+                const sqlTimeRegex = RegExp(`${isoTimeBaseRegex.source} ?(?:${offsetRegex.source}|(${ianaRegex.source}))?`);
+                const sqlTimeExtensionRegex = RegExp(`(?: ${sqlTimeRegex.source})?`);
+                function luxon_int(match, pos, fallback) {
+                    const m = match[pos];
+                    return isUndefined(m) ? fallback : parseInteger(m);
+                }
+                function extractISOYmd(match, cursor) {
+                    const item = {
+                        year: luxon_int(match, cursor),
+                        month: luxon_int(match, cursor + 1, 1),
+                        day: luxon_int(match, cursor + 2, 1)
+                    };
+                    return [
+                        item,
+                        null,
+                        cursor + 3
+                    ];
+                }
+                function extractISOTime(match, cursor) {
+                    const item = {
+                        hours: luxon_int(match, cursor, 0),
+                        minutes: luxon_int(match, cursor + 1, 0),
+                        seconds: luxon_int(match, cursor + 2, 0),
+                        milliseconds: parseMillis(match[cursor + 3])
+                    };
+                    return [
+                        item,
+                        null,
+                        cursor + 4
+                    ];
+                }
+                function extractISOOffset(match, cursor) {
+                    const local = !match[cursor] && !match[cursor + 1], fullOffset = signedOffset(match[cursor + 1], match[cursor + 2]), zone = local ? null : FixedOffsetZone.instance(fullOffset);
+                    return [
+                        {},
+                        zone,
+                        cursor + 3
+                    ];
+                }
+                function extractIANAZone(match, cursor) {
+                    const zone = match[cursor] ? IANAZone.create(match[cursor]) : null;
+                    return [
+                        {},
+                        zone,
+                        cursor + 1
+                    ];
+                }
+                const isoTimeOnly = RegExp(`^T?${isoTimeBaseRegex.source}$`);
+                const isoDuration = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;
+                function extractISODuration(match) {
+                    const [s, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match;
+                    const hasNegativePrefix = "-" === s[0];
+                    const negativeSeconds = secondStr && "-" === secondStr[0];
+                    const maybeNegate = (num, force = false)=>void 0 !== num && (force || num && hasNegativePrefix) ? -num : num;
+                    return [
+                        {
+                            years: maybeNegate(parseFloating(yearStr)),
+                            months: maybeNegate(parseFloating(monthStr)),
+                            weeks: maybeNegate(parseFloating(weekStr)),
+                            days: maybeNegate(parseFloating(dayStr)),
+                            hours: maybeNegate(parseFloating(hourStr)),
+                            minutes: maybeNegate(parseFloating(minuteStr)),
+                            seconds: maybeNegate(parseFloating(secondStr), "-0" === secondStr),
+                            milliseconds: maybeNegate(parseMillis(millisecondsStr), negativeSeconds)
+                        }
+                    ];
+                }
+                const obsOffsets = {
+                    GMT: 0,
+                    EDT: -240,
+                    EST: -300,
+                    CDT: -300,
+                    CST: -360,
+                    MDT: -360,
+                    MST: -420,
+                    PDT: -420,
+                    PST: -480
+                };
+                function fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+                    const result = {
+                        year: 2 === yearStr.length ? untruncateYear(parseInteger(yearStr)) : parseInteger(yearStr),
+                        month: monthsShort.indexOf(monthStr) + 1,
+                        day: parseInteger(dayStr),
+                        hour: parseInteger(hourStr),
+                        minute: parseInteger(minuteStr)
+                    };
+                    if (secondStr) result.second = parseInteger(secondStr);
+                    if (weekdayStr) result.weekday = weekdayStr.length > 3 ? weekdaysLong.indexOf(weekdayStr) + 1 : weekdaysShort.indexOf(weekdayStr) + 1;
+                    return result;
+                }
+                const rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/;
+                function extractRFC2822(match) {
+                    const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr, obsOffset, milOffset, offHourStr, offMinuteStr] = match, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
+                    let offset;
+                    offset = obsOffset ? obsOffsets[obsOffset] : milOffset ? 0 : signedOffset(offHourStr, offMinuteStr);
+                    return [
+                        result,
+                        new FixedOffsetZone(offset)
+                    ];
+                }
+                function preprocessRFC2822(s) {
+                    return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
+                }
+                const rfc1123 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/, rfc850 = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/, ascii = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/;
+                function extractRFC1123Or850(match) {
+                    const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr] = match, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
+                    return [
+                        result,
+                        FixedOffsetZone.utcInstance
+                    ];
+                }
+                function extractASCII(match) {
+                    const [, weekdayStr, monthStr, dayStr, hourStr, minuteStr, secondStr, yearStr] = match, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
+                    return [
+                        result,
+                        FixedOffsetZone.utcInstance
+                    ];
+                }
+                const isoYmdWithTimeExtensionRegex = combineRegexes(isoYmdRegex, isoTimeExtensionRegex);
+                const isoWeekWithTimeExtensionRegex = combineRegexes(isoWeekRegex, isoTimeExtensionRegex);
+                const isoOrdinalWithTimeExtensionRegex = combineRegexes(isoOrdinalRegex, isoTimeExtensionRegex);
+                const isoTimeCombinedRegex = combineRegexes(isoTimeRegex);
+                const extractISOYmdTimeAndOffset = combineExtractors(extractISOYmd, extractISOTime, extractISOOffset, extractIANAZone);
+                const extractISOWeekTimeAndOffset = combineExtractors(extractISOWeekData, extractISOTime, extractISOOffset, extractIANAZone);
+                const extractISOOrdinalDateAndTime = combineExtractors(extractISOOrdinalData, extractISOTime, extractISOOffset, extractIANAZone);
+                const extractISOTimeAndOffset = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
+                function parseISODate(s) {
+                    return parse(s, [
+                        isoYmdWithTimeExtensionRegex,
+                        extractISOYmdTimeAndOffset
+                    ], [
+                        isoWeekWithTimeExtensionRegex,
+                        extractISOWeekTimeAndOffset
+                    ], [
+                        isoOrdinalWithTimeExtensionRegex,
+                        extractISOOrdinalDateAndTime
+                    ], [
+                        isoTimeCombinedRegex,
+                        extractISOTimeAndOffset
+                    ]);
+                }
+                function parseRFC2822Date(s) {
+                    return parse(preprocessRFC2822(s), [
+                        rfc2822,
+                        extractRFC2822
+                    ]);
+                }
+                function parseHTTPDate(s) {
+                    return parse(s, [
+                        rfc1123,
+                        extractRFC1123Or850
+                    ], [
+                        rfc850,
+                        extractRFC1123Or850
+                    ], [
+                        ascii,
+                        extractASCII
+                    ]);
+                }
+                function parseISODuration(s) {
+                    return parse(s, [
+                        isoDuration,
+                        extractISODuration
+                    ]);
+                }
+                const extractISOTimeOnly = combineExtractors(extractISOTime);
+                function parseISOTimeOnly(s) {
+                    return parse(s, [
+                        isoTimeOnly,
+                        extractISOTimeOnly
+                    ]);
+                }
+                const sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex);
+                const sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex);
+                const extractISOTimeOffsetAndIANAZone = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
+                function parseSQL(s) {
+                    return parse(s, [
+                        sqlYmdWithTimeExtensionRegex,
+                        extractISOYmdTimeAndOffset
+                    ], [
+                        sqlTimeCombinedRegex,
+                        extractISOTimeOffsetAndIANAZone
+                    ]);
+                }
+                const INVALID$2 = "Invalid Duration";
+                const lowOrderMatrix = {
+                    weeks: {
+                        days: 7,
+                        hours: 168,
+                        minutes: 10080,
+                        seconds: 604800,
+                        milliseconds: 604800000
+                    },
+                    days: {
+                        hours: 24,
+                        minutes: 1440,
+                        seconds: 86400,
+                        milliseconds: 86400000
+                    },
+                    hours: {
+                        minutes: 60,
+                        seconds: 3600,
+                        milliseconds: 3600000
+                    },
+                    minutes: {
+                        seconds: 60,
+                        milliseconds: 60000
+                    },
+                    seconds: {
+                        milliseconds: 1000
+                    }
+                }, casualMatrix = {
+                    years: {
+                        quarters: 4,
+                        months: 12,
+                        weeks: 52,
+                        days: 365,
+                        hours: 8760,
+                        minutes: 525600,
+                        seconds: 31536000,
+                        milliseconds: 31536000000
+                    },
+                    quarters: {
+                        months: 3,
+                        weeks: 13,
+                        days: 91,
+                        hours: 2184,
+                        minutes: 131040,
+                        seconds: 7862400,
+                        milliseconds: 7862400000
+                    },
+                    months: {
+                        weeks: 4,
+                        days: 30,
+                        hours: 720,
+                        minutes: 43200,
+                        seconds: 2592000,
+                        milliseconds: 2592000000
+                    },
+                    ...lowOrderMatrix
+                }, daysInYearAccurate = 365.2425, daysInMonthAccurate = 30.436875, accurateMatrix = {
+                    years: {
+                        quarters: 4,
+                        months: 12,
+                        weeks: daysInYearAccurate / 7,
+                        days: daysInYearAccurate,
+                        hours: 24 * daysInYearAccurate,
+                        minutes: 24 * daysInYearAccurate * 60,
+                        seconds: 24 * daysInYearAccurate * 3600,
+                        milliseconds: 24 * daysInYearAccurate * 3600000
+                    },
+                    quarters: {
+                        months: 3,
+                        weeks: daysInYearAccurate / 28,
+                        days: daysInYearAccurate / 4,
+                        hours: 24 * daysInYearAccurate / 4,
+                        minutes: 24 * daysInYearAccurate * 60 / 4,
+                        seconds: 24 * daysInYearAccurate * 3600 / 4,
+                        milliseconds: 24 * daysInYearAccurate * 3600000 / 4
+                    },
+                    months: {
+                        weeks: daysInMonthAccurate / 7,
+                        days: daysInMonthAccurate,
+                        hours: 24 * daysInMonthAccurate,
+                        minutes: 24 * daysInMonthAccurate * 60,
+                        seconds: 24 * daysInMonthAccurate * 3600,
+                        milliseconds: 24 * daysInMonthAccurate * 3600000
+                    },
+                    ...lowOrderMatrix
+                };
+                const orderedUnits$1 = [
+                    "years",
+                    "quarters",
+                    "months",
+                    "weeks",
+                    "days",
+                    "hours",
+                    "minutes",
+                    "seconds",
+                    "milliseconds"
+                ];
+                const reverseUnits = orderedUnits$1.slice(0).reverse();
+                function clone$1(dur, alts, clear = false) {
+                    const conf = {
+                        values: clear ? alts.values : {
+                            ...dur.values,
+                            ...alts.values || {}
+                        },
+                        loc: dur.loc.clone(alts.loc),
+                        conversionAccuracy: alts.conversionAccuracy || dur.conversionAccuracy,
+                        matrix: alts.matrix || dur.matrix
+                    };
+                    return new Duration(conf);
+                }
+                function durationToMillis(matrix, vals) {
+                    let sum = vals.milliseconds ?? 0;
+                    for (const unit of reverseUnits.slice(1))if (vals[unit]) sum += vals[unit] * matrix[unit]["milliseconds"];
+                    return sum;
+                }
+                function normalizeValues(matrix, vals) {
+                    const factor = durationToMillis(matrix, vals) < 0 ? -1 : 1;
+                    orderedUnits$1.reduceRight((previous, current)=>{
+                        if (isUndefined(vals[current])) return previous;
+                        if (previous) {
+                            const previousVal = vals[previous] * factor;
+                            const conv = matrix[current][previous];
+                            const rollUp = Math.floor(previousVal / conv);
+                            vals[current] += rollUp * factor;
+                            vals[previous] -= rollUp * conv * factor;
+                        }
+                        return current;
+                    }, null);
+                    orderedUnits$1.reduce((previous, current)=>{
+                        if (isUndefined(vals[current])) return previous;
+                        if (previous) {
+                            const fraction = vals[previous] % 1;
+                            vals[previous] -= fraction;
+                            vals[current] += fraction * matrix[previous][current];
+                        }
+                        return current;
+                    }, null);
+                }
+                function removeZeroes(vals) {
+                    const newVals = {};
+                    for (const [key, value] of Object.entries(vals))if (0 !== value) newVals[key] = value;
+                    return newVals;
+                }
+                class Duration {
+                    constructor(config){
+                        const accurate = "longterm" === config.conversionAccuracy || false;
+                        let matrix = accurate ? accurateMatrix : casualMatrix;
+                        if (config.matrix) matrix = config.matrix;
+                        this.values = config.values;
+                        this.loc = config.loc || Locale.create();
+                        this.conversionAccuracy = accurate ? "longterm" : "casual";
+                        this.invalid = config.invalid || null;
+                        this.matrix = matrix;
+                        this.isLuxonDuration = true;
+                    }
+                    static fromMillis(count, opts) {
+                        return Duration.fromObject({
+                            milliseconds: count
+                        }, opts);
+                    }
+                    static fromObject(obj, opts = {}) {
+                        if (null == obj || "object" != typeof obj) throw new InvalidArgumentError(`Duration.fromObject: argument expected to be an object, got ${null === obj ? "null" : typeof obj}`);
+                        return new Duration({
+                            values: normalizeObject(obj, Duration.normalizeUnit),
+                            loc: Locale.fromObject(opts),
+                            conversionAccuracy: opts.conversionAccuracy,
+                            matrix: opts.matrix
+                        });
+                    }
+                    static fromDurationLike(durationLike) {
+                        if (isNumber(durationLike)) return Duration.fromMillis(durationLike);
+                        if (Duration.isDuration(durationLike)) return durationLike;
+                        if ("object" == typeof durationLike) return Duration.fromObject(durationLike);
+                        throw new InvalidArgumentError(`Unknown duration argument ${durationLike} of type ${typeof durationLike}`);
+                    }
+                    static fromISO(text, opts) {
+                        const [parsed] = parseISODuration(text);
+                        if (parsed) return Duration.fromObject(parsed, opts);
+                        return Duration.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`);
+                    }
+                    static fromISOTime(text, opts) {
+                        const [parsed] = parseISOTimeOnly(text);
+                        if (parsed) return Duration.fromObject(parsed, opts);
+                        return Duration.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`);
+                    }
+                    static invalid(reason, explanation = null) {
+                        if (!reason) throw new InvalidArgumentError("need to specify a reason the Duration is invalid");
+                        const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);
+                        if (!Settings.throwOnInvalid) return new Duration({
+                            invalid
+                        });
+                        throw new InvalidDurationError(invalid);
+                    }
+                    static normalizeUnit(unit) {
+                        const normalized = {
+                            year: "years",
+                            years: "years",
+                            quarter: "quarters",
+                            quarters: "quarters",
+                            month: "months",
+                            months: "months",
+                            week: "weeks",
+                            weeks: "weeks",
+                            day: "days",
+                            days: "days",
+                            hour: "hours",
+                            hours: "hours",
+                            minute: "minutes",
+                            minutes: "minutes",
+                            second: "seconds",
+                            seconds: "seconds",
+                            millisecond: "milliseconds",
+                            milliseconds: "milliseconds"
+                        }[unit ? unit.toLowerCase() : unit];
+                        if (!normalized) throw new InvalidUnitError(unit);
+                        return normalized;
+                    }
+                    static isDuration(o) {
+                        return o && o.isLuxonDuration || false;
+                    }
+                    get locale() {
+                        return this.isValid ? this.loc.locale : null;
+                    }
+                    get numberingSystem() {
+                        return this.isValid ? this.loc.numberingSystem : null;
+                    }
+                    toFormat(fmt, opts = {}) {
+                        const fmtOpts = {
+                            ...opts,
+                            floor: false !== opts.round && false !== opts.floor
+                        };
+                        return this.isValid ? Formatter.create(this.loc, fmtOpts).formatDurationFromString(this, fmt) : INVALID$2;
+                    }
+                    toHuman(opts = {}) {
+                        if (!this.isValid) return INVALID$2;
+                        const showZeros = false !== opts.showZeros;
+                        const l = orderedUnits$1.map((unit)=>{
+                            const val = this.values[unit];
+                            if (isUndefined(val) || 0 === val && !showZeros) return null;
+                            return this.loc.numberFormatter({
+                                style: "unit",
+                                unitDisplay: "long",
+                                ...opts,
+                                unit: unit.slice(0, -1)
+                            }).format(val);
+                        }).filter((n)=>n);
+                        return this.loc.listFormatter({
+                            type: "conjunction",
+                            style: opts.listStyle || "narrow",
+                            ...opts
+                        }).format(l);
+                    }
+                    toObject() {
+                        if (!this.isValid) return {};
+                        return {
+                            ...this.values
+                        };
+                    }
+                    toISO() {
+                        if (!this.isValid) return null;
+                        let s = "P";
+                        if (0 !== this.years) s += this.years + "Y";
+                        if (0 !== this.months || 0 !== this.quarters) s += this.months + 3 * this.quarters + "M";
+                        if (0 !== this.weeks) s += this.weeks + "W";
+                        if (0 !== this.days) s += this.days + "D";
+                        if (0 !== this.hours || 0 !== this.minutes || 0 !== this.seconds || 0 !== this.milliseconds) s += "T";
+                        if (0 !== this.hours) s += this.hours + "H";
+                        if (0 !== this.minutes) s += this.minutes + "M";
+                        if (0 !== this.seconds || 0 !== this.milliseconds) s += roundTo(this.seconds + this.milliseconds / 1000, 3) + "S";
+                        if ("P" === s) s += "T0S";
+                        return s;
+                    }
+                    toISOTime(opts = {}) {
+                        if (!this.isValid) return null;
+                        const millis = this.toMillis();
+                        if (millis < 0 || millis >= 86400000) return null;
+                        opts = {
+                            suppressMilliseconds: false,
+                            suppressSeconds: false,
+                            includePrefix: false,
+                            format: "extended",
+                            ...opts,
+                            includeOffset: false
+                        };
+                        const dateTime = DateTime.fromMillis(millis, {
+                            zone: "UTC"
+                        });
+                        return dateTime.toISOTime(opts);
+                    }
+                    toJSON() {
+                        return this.toISO();
+                    }
+                    toString() {
+                        return this.toISO();
+                    }
+                    [Symbol.for("nodejs.util.inspect.custom")]() {
+                        if (this.isValid) return `Duration { values: ${JSON.stringify(this.values)} }`;
+                        return `Duration { Invalid, reason: ${this.invalidReason} }`;
+                    }
+                    toMillis() {
+                        if (!this.isValid) return NaN;
+                        return durationToMillis(this.matrix, this.values);
+                    }
+                    valueOf() {
+                        return this.toMillis();
+                    }
+                    plus(duration) {
+                        if (!this.isValid) return this;
+                        const dur = Duration.fromDurationLike(duration), result = {};
+                        for (const k of orderedUnits$1)if (luxon_hasOwnProperty(dur.values, k) || luxon_hasOwnProperty(this.values, k)) result[k] = dur.get(k) + this.get(k);
+                        return clone$1(this, {
+                            values: result
+                        }, true);
+                    }
+                    minus(duration) {
+                        if (!this.isValid) return this;
+                        const dur = Duration.fromDurationLike(duration);
+                        return this.plus(dur.negate());
+                    }
+                    mapUnits(fn) {
+                        if (!this.isValid) return this;
+                        const result = {};
+                        for (const k of Object.keys(this.values))result[k] = asNumber(fn(this.values[k], k));
+                        return clone$1(this, {
+                            values: result
+                        }, true);
+                    }
+                    get(unit) {
+                        return this[Duration.normalizeUnit(unit)];
+                    }
+                    set(values) {
+                        if (!this.isValid) return this;
+                        const mixed = {
+                            ...this.values,
+                            ...normalizeObject(values, Duration.normalizeUnit)
+                        };
+                        return clone$1(this, {
+                            values: mixed
+                        });
+                    }
+                    reconfigure({ locale, numberingSystem, conversionAccuracy, matrix } = {}) {
+                        const loc = this.loc.clone({
+                            locale,
+                            numberingSystem
+                        });
+                        const opts = {
+                            loc,
+                            matrix,
+                            conversionAccuracy
+                        };
+                        return clone$1(this, opts);
+                    }
+                    as(unit) {
+                        return this.isValid ? this.shiftTo(unit).get(unit) : NaN;
+                    }
+                    normalize() {
+                        if (!this.isValid) return this;
+                        const vals = this.toObject();
+                        normalizeValues(this.matrix, vals);
+                        return clone$1(this, {
+                            values: vals
+                        }, true);
+                    }
+                    rescale() {
+                        if (!this.isValid) return this;
+                        const vals = removeZeroes(this.normalize().shiftToAll().toObject());
+                        return clone$1(this, {
+                            values: vals
+                        }, true);
+                    }
+                    shiftTo(...units) {
+                        if (!this.isValid) return this;
+                        if (0 === units.length) return this;
+                        units = units.map((u)=>Duration.normalizeUnit(u));
+                        const built = {}, accumulated = {}, vals = this.toObject();
+                        let lastUnit;
+                        for (const k of orderedUnits$1)if (units.indexOf(k) >= 0) {
+                            lastUnit = k;
+                            let own = 0;
+                            for(const ak in accumulated){
+                                own += this.matrix[ak][k] * accumulated[ak];
+                                accumulated[ak] = 0;
+                            }
+                            if (isNumber(vals[k])) own += vals[k];
+                            const i = Math.trunc(own);
+                            built[k] = i;
+                            accumulated[k] = (1000 * own - 1000 * i) / 1000;
+                        } else if (isNumber(vals[k])) accumulated[k] = vals[k];
+                        for(const key in accumulated)if (0 !== accumulated[key]) built[lastUnit] += key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key];
+                        normalizeValues(this.matrix, built);
+                        return clone$1(this, {
+                            values: built
+                        }, true);
+                    }
+                    shiftToAll() {
+                        if (!this.isValid) return this;
+                        return this.shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds");
+                    }
+                    negate() {
+                        if (!this.isValid) return this;
+                        const negated = {};
+                        for (const k of Object.keys(this.values))negated[k] = 0 === this.values[k] ? 0 : -this.values[k];
+                        return clone$1(this, {
+                            values: negated
+                        }, true);
+                    }
+                    removeZeros() {
+                        if (!this.isValid) return this;
+                        const vals = removeZeroes(this.values);
+                        return clone$1(this, {
+                            values: vals
+                        }, true);
+                    }
+                    get years() {
+                        return this.isValid ? this.values.years || 0 : NaN;
+                    }
+                    get quarters() {
+                        return this.isValid ? this.values.quarters || 0 : NaN;
+                    }
+                    get months() {
+                        return this.isValid ? this.values.months || 0 : NaN;
+                    }
+                    get weeks() {
+                        return this.isValid ? this.values.weeks || 0 : NaN;
+                    }
+                    get days() {
+                        return this.isValid ? this.values.days || 0 : NaN;
+                    }
+                    get hours() {
+                        return this.isValid ? this.values.hours || 0 : NaN;
+                    }
+                    get minutes() {
+                        return this.isValid ? this.values.minutes || 0 : NaN;
+                    }
+                    get seconds() {
+                        return this.isValid ? this.values.seconds || 0 : NaN;
+                    }
+                    get milliseconds() {
+                        return this.isValid ? this.values.milliseconds || 0 : NaN;
+                    }
+                    get isValid() {
+                        return null === this.invalid;
+                    }
+                    get invalidReason() {
+                        return this.invalid ? this.invalid.reason : null;
+                    }
+                    get invalidExplanation() {
+                        return this.invalid ? this.invalid.explanation : null;
+                    }
+                    equals(other) {
+                        if (!this.isValid || !other.isValid) return false;
+                        if (!this.loc.equals(other.loc)) return false;
+                        function eq(v1, v2) {
+                            if (void 0 === v1 || 0 === v1) return void 0 === v2 || 0 === v2;
+                            return v1 === v2;
+                        }
+                        for (const u of orderedUnits$1)if (!eq(this.values[u], other.values[u])) return false;
+                        return true;
+                    }
+                }
+                const INVALID$1 = "Invalid Interval";
+                function validateStartEnd(start, end) {
+                    if (!start || !start.isValid) return Interval.invalid("missing or invalid start");
+                    if (!end || !end.isValid) return Interval.invalid("missing or invalid end");
+                    if (end < start) return Interval.invalid("end before start", `The end of an interval must be after its start, but you had start=${start.toISO()} and end=${end.toISO()}`);
+                    return null;
+                }
+                class Interval {
+                    constructor(config){
+                        this.s = config.start;
+                        this.e = config.end;
+                        this.invalid = config.invalid || null;
+                        this.isLuxonInterval = true;
+                    }
+                    static invalid(reason, explanation = null) {
+                        if (!reason) throw new InvalidArgumentError("need to specify a reason the Interval is invalid");
+                        const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);
+                        if (!Settings.throwOnInvalid) return new Interval({
+                            invalid
+                        });
+                        throw new InvalidIntervalError(invalid);
+                    }
+                    static fromDateTimes(start, end) {
+                        const builtStart = friendlyDateTime(start), builtEnd = friendlyDateTime(end);
+                        const validateError = validateStartEnd(builtStart, builtEnd);
+                        if (null == validateError) return new Interval({
+                            start: builtStart,
+                            end: builtEnd
+                        });
+                        return validateError;
+                    }
+                    static after(start, duration) {
+                        const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(start);
+                        return Interval.fromDateTimes(dt, dt.plus(dur));
+                    }
+                    static before(end, duration) {
+                        const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(end);
+                        return Interval.fromDateTimes(dt.minus(dur), dt);
+                    }
+                    static fromISO(text, opts) {
+                        const [s, e] = (text || "").split("/", 2);
+                        if (s && e) {
+                            let start, startIsValid;
+                            try {
+                                start = DateTime.fromISO(s, opts);
+                                startIsValid = start.isValid;
+                            } catch (e) {
+                                startIsValid = false;
+                            }
+                            let end, endIsValid;
+                            try {
+                                end = DateTime.fromISO(e, opts);
+                                endIsValid = end.isValid;
+                            } catch (e) {
+                                endIsValid = false;
+                            }
+                            if (startIsValid && endIsValid) return Interval.fromDateTimes(start, end);
+                            if (startIsValid) {
+                                const dur = Duration.fromISO(e, opts);
+                                if (dur.isValid) return Interval.after(start, dur);
+                            } else if (endIsValid) {
+                                const dur = Duration.fromISO(s, opts);
+                                if (dur.isValid) return Interval.before(end, dur);
+                            }
+                        }
+                        return Interval.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`);
+                    }
+                    static isInterval(o) {
+                        return o && o.isLuxonInterval || false;
+                    }
+                    get start() {
+                        return this.isValid ? this.s : null;
+                    }
+                    get end() {
+                        return this.isValid ? this.e : null;
+                    }
+                    get lastDateTime() {
+                        return this.isValid ? this.e ? this.e.minus(1) : null : null;
+                    }
+                    get isValid() {
+                        return null === this.invalidReason;
+                    }
+                    get invalidReason() {
+                        return this.invalid ? this.invalid.reason : null;
+                    }
+                    get invalidExplanation() {
+                        return this.invalid ? this.invalid.explanation : null;
+                    }
+                    length(unit = "milliseconds") {
+                        return this.isValid ? this.toDuration(unit).get(unit) : NaN;
+                    }
+                    count(unit = "milliseconds", opts) {
+                        if (!this.isValid) return NaN;
+                        const start = this.start.startOf(unit, opts);
+                        let end;
+                        end = opts?.useLocaleWeeks ? this.end.reconfigure({
+                            locale: start.locale
+                        }) : this.end;
+                        end = end.startOf(unit, opts);
+                        return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());
+                    }
+                    hasSame(unit) {
+                        return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;
+                    }
+                    isEmpty() {
+                        return this.s.valueOf() === this.e.valueOf();
+                    }
+                    isAfter(dateTime) {
+                        if (!this.isValid) return false;
+                        return this.s > dateTime;
+                    }
+                    isBefore(dateTime) {
+                        if (!this.isValid) return false;
+                        return this.e <= dateTime;
+                    }
+                    contains(dateTime) {
+                        if (!this.isValid) return false;
+                        return this.s <= dateTime && this.e > dateTime;
+                    }
+                    set({ start, end } = {}) {
+                        if (!this.isValid) return this;
+                        return Interval.fromDateTimes(start || this.s, end || this.e);
+                    }
+                    splitAt(...dateTimes) {
+                        if (!this.isValid) return [];
+                        const sorted = dateTimes.map(friendlyDateTime).filter((d)=>this.contains(d)).sort((a, b)=>a.toMillis() - b.toMillis()), results = [];
+                        let { s } = this, i = 0;
+                        while(s < this.e){
+                            const added = sorted[i] || this.e, next = +added > +this.e ? this.e : added;
+                            results.push(Interval.fromDateTimes(s, next));
+                            s = next;
+                            i += 1;
+                        }
+                        return results;
+                    }
+                    splitBy(duration) {
+                        const dur = Duration.fromDurationLike(duration);
+                        if (!this.isValid || !dur.isValid || 0 === dur.as("milliseconds")) return [];
+                        let { s } = this, idx = 1, next;
+                        const results = [];
+                        while(s < this.e){
+                            const added = this.start.plus(dur.mapUnits((x)=>x * idx));
+                            next = +added > +this.e ? this.e : added;
+                            results.push(Interval.fromDateTimes(s, next));
+                            s = next;
+                            idx += 1;
+                        }
+                        return results;
+                    }
+                    divideEqually(numberOfParts) {
+                        if (!this.isValid) return [];
+                        return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts);
+                    }
+                    overlaps(other) {
+                        return this.e > other.s && this.s < other.e;
+                    }
+                    abutsStart(other) {
+                        if (!this.isValid) return false;
+                        return +this.e === +other.s;
+                    }
+                    abutsEnd(other) {
+                        if (!this.isValid) return false;
+                        return +other.e === +this.s;
+                    }
+                    engulfs(other) {
+                        if (!this.isValid) return false;
+                        return this.s <= other.s && this.e >= other.e;
+                    }
+                    equals(other) {
+                        if (!this.isValid || !other.isValid) return false;
+                        return this.s.equals(other.s) && this.e.equals(other.e);
+                    }
+                    intersection(other) {
+                        if (!this.isValid) return this;
+                        const s = this.s > other.s ? this.s : other.s, e = this.e < other.e ? this.e : other.e;
+                        if (s >= e) return null;
+                        return Interval.fromDateTimes(s, e);
+                    }
+                    union(other) {
+                        if (!this.isValid) return this;
+                        const s = this.s < other.s ? this.s : other.s, e = this.e > other.e ? this.e : other.e;
+                        return Interval.fromDateTimes(s, e);
+                    }
+                    static merge(intervals) {
+                        const [found, final] = intervals.sort((a, b)=>a.s - b.s).reduce(([sofar, current], item)=>{
+                            if (!current) return [
+                                sofar,
+                                item
+                            ];
+                            if (current.overlaps(item) || current.abutsStart(item)) return [
+                                sofar,
+                                current.union(item)
+                            ];
+                            return [
+                                sofar.concat([
+                                    current
+                                ]),
+                                item
+                            ];
+                        }, [
+                            [],
+                            null
+                        ]);
+                        if (final) found.push(final);
+                        return found;
+                    }
+                    static xor(intervals) {
+                        let start = null, currentCount = 0;
+                        const results = [], ends = intervals.map((i)=>[
+                                {
+                                    time: i.s,
+                                    type: "s"
+                                },
+                                {
+                                    time: i.e,
+                                    type: "e"
+                                }
+                            ]), flattened = Array.prototype.concat(...ends), arr = flattened.sort((a, b)=>a.time - b.time);
+                        for (const i of arr){
+                            currentCount += "s" === i.type ? 1 : -1;
+                            if (1 === currentCount) start = i.time;
+                            else {
+                                if (start && +start !== +i.time) results.push(Interval.fromDateTimes(start, i.time));
+                                start = null;
+                            }
+                        }
+                        return Interval.merge(results);
+                    }
+                    difference(...intervals) {
+                        return Interval.xor([
+                            this
+                        ].concat(intervals)).map((i)=>this.intersection(i)).filter((i)=>i && !i.isEmpty());
+                    }
+                    toString() {
+                        if (!this.isValid) return INVALID$1;
+                        return `[${this.s.toISO()} – ${this.e.toISO()})`;
+                    }
+                    [Symbol.for("nodejs.util.inspect.custom")]() {
+                        if (this.isValid) return `Interval { start: ${this.s.toISO()}, end: ${this.e.toISO()} }`;
+                        return `Interval { Invalid, reason: ${this.invalidReason} }`;
+                    }
+                    toLocaleString(formatOpts = DATE_SHORT, opts = {}) {
+                        return this.isValid ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this) : INVALID$1;
+                    }
+                    toISO(opts) {
+                        if (!this.isValid) return INVALID$1;
+                        return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`;
+                    }
+                    toISODate() {
+                        if (!this.isValid) return INVALID$1;
+                        return `${this.s.toISODate()}/${this.e.toISODate()}`;
+                    }
+                    toISOTime(opts) {
+                        if (!this.isValid) return INVALID$1;
+                        return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`;
+                    }
+                    toFormat(dateFormat, { separator = " – " } = {}) {
+                        if (!this.isValid) return INVALID$1;
+                        return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`;
+                    }
+                    toDuration(unit, opts) {
+                        if (!this.isValid) return Duration.invalid(this.invalidReason);
+                        return this.e.diff(this.s, unit, opts);
+                    }
+                    mapEndpoints(mapFn) {
+                        return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));
+                    }
+                }
+                class Info {
+                    static hasDST(zone = Settings.defaultZone) {
+                        const proto = DateTime.now().setZone(zone).set({
+                            month: 12
+                        });
+                        return !zone.isUniversal && proto.offset !== proto.set({
+                            month: 6
+                        }).offset;
+                    }
+                    static isValidIANAZone(zone) {
+                        return IANAZone.isValidZone(zone);
+                    }
+                    static normalizeZone(input) {
+                        return normalizeZone(input, Settings.defaultZone);
+                    }
+                    static getStartOfWeek({ locale = null, locObj = null } = {}) {
+                        return (locObj || Locale.create(locale)).getStartOfWeek();
+                    }
+                    static getMinimumDaysInFirstWeek({ locale = null, locObj = null } = {}) {
+                        return (locObj || Locale.create(locale)).getMinDaysInFirstWeek();
+                    }
+                    static getWeekendWeekdays({ locale = null, locObj = null } = {}) {
+                        return (locObj || Locale.create(locale)).getWeekendDays().slice();
+                    }
+                    static months(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) {
+                        return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length);
+                    }
+                    static monthsFormat(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) {
+                        return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length, true);
+                    }
+                    static weekdays(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) {
+                        return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length);
+                    }
+                    static weekdaysFormat(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) {
+                        return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length, true);
+                    }
+                    static meridiems({ locale = null } = {}) {
+                        return Locale.create(locale).meridiems();
+                    }
+                    static eras(length = "short", { locale = null } = {}) {
+                        return Locale.create(locale, null, "gregory").eras(length);
+                    }
+                    static features() {
+                        return {
+                            relative: hasRelative(),
+                            localeWeek: hasLocaleWeekInfo()
+                        };
+                    }
+                }
+                function dayDiff(earlier, later) {
+                    const utcDayStart = (dt)=>dt.toUTC(0, {
+                            keepLocalTime: true
+                        }).startOf("day").valueOf(), ms = utcDayStart(later) - utcDayStart(earlier);
+                    return Math.floor(Duration.fromMillis(ms).as("days"));
+                }
+                function highOrderDiffs(cursor, later, units) {
+                    const differs = [
+                        [
+                            "years",
+                            (a, b)=>b.year - a.year
+                        ],
+                        [
+                            "quarters",
+                            (a, b)=>b.quarter - a.quarter + (b.year - a.year) * 4
+                        ],
+                        [
+                            "months",
+                            (a, b)=>b.month - a.month + (b.year - a.year) * 12
+                        ],
+                        [
+                            "weeks",
+                            (a, b)=>{
+                                const days = dayDiff(a, b);
+                                return (days - days % 7) / 7;
+                            }
+                        ],
+                        [
+                            "days",
+                            dayDiff
+                        ]
+                    ];
+                    const results = {};
+                    const earlier = cursor;
+                    let lowestOrder, highWater;
+                    for (const [unit, differ] of differs)if (units.indexOf(unit) >= 0) {
+                        lowestOrder = unit;
+                        results[unit] = differ(cursor, later);
+                        highWater = earlier.plus(results);
+                        if (highWater > later) {
+                            results[unit]--;
+                            cursor = earlier.plus(results);
+                            if (cursor > later) {
+                                highWater = cursor;
+                                results[unit]--;
+                                cursor = earlier.plus(results);
+                            }
+                        } else cursor = highWater;
+                    }
+                    return [
+                        cursor,
+                        results,
+                        highWater,
+                        lowestOrder
+                    ];
+                }
+                function diff(earlier, later, units, opts) {
+                    let [cursor, results, highWater, lowestOrder] = highOrderDiffs(earlier, later, units);
+                    const remainingMillis = later - cursor;
+                    const lowerOrderUnits = units.filter((u)=>[
+                            "hours",
+                            "minutes",
+                            "seconds",
+                            "milliseconds"
+                        ].indexOf(u) >= 0);
+                    if (0 === lowerOrderUnits.length) {
+                        if (highWater < later) highWater = cursor.plus({
+                            [lowestOrder]: 1
+                        });
+                        if (highWater !== cursor) results[lowestOrder] = (results[lowestOrder] || 0) + remainingMillis / (highWater - cursor);
+                    }
+                    const duration = Duration.fromObject(results, opts);
+                    if (lowerOrderUnits.length > 0) return Duration.fromMillis(remainingMillis, opts).shiftTo(...lowerOrderUnits).plus(duration);
+                    return duration;
+                }
+                const MISSING_FTP = "missing Intl.DateTimeFormat.formatToParts support";
+                function intUnit(regex, post = (i)=>i) {
+                    return {
+                        regex,
+                        deser: ([s])=>post(parseDigits(s))
+                    };
+                }
+                const NBSP = String.fromCharCode(160);
+                const spaceOrNBSP = `[ ${NBSP}]`;
+                const spaceOrNBSPRegExp = new RegExp(spaceOrNBSP, "g");
+                function fixListRegex(s) {
+                    return s.replace(/\./g, "\\.?").replace(spaceOrNBSPRegExp, spaceOrNBSP);
+                }
+                function stripInsensitivities(s) {
+                    return s.replace(/\./g, "").replace(spaceOrNBSPRegExp, " ").toLowerCase();
+                }
+                function oneOf(strings, startIndex) {
+                    if (null === strings) return null;
+                    return {
+                        regex: RegExp(strings.map(fixListRegex).join("|")),
+                        deser: ([s])=>strings.findIndex((i)=>stripInsensitivities(s) === stripInsensitivities(i)) + startIndex
+                    };
+                }
+                function luxon_offset(regex, groups) {
+                    return {
+                        regex,
+                        deser: ([, h, m])=>signedOffset(h, m),
+                        groups
+                    };
+                }
+                function simple(regex) {
+                    return {
+                        regex,
+                        deser: ([s])=>s
+                    };
+                }
+                function escapeToken(value) {
+                    return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+                }
+                function unitForToken(token, loc) {
+                    const one = digitRegex(loc), two = digitRegex(loc, "{2}"), three = digitRegex(loc, "{3}"), four = digitRegex(loc, "{4}"), six = digitRegex(loc, "{6}"), oneOrTwo = digitRegex(loc, "{1,2}"), oneToThree = digitRegex(loc, "{1,3}"), oneToSix = digitRegex(loc, "{1,6}"), oneToNine = digitRegex(loc, "{1,9}"), twoToFour = digitRegex(loc, "{2,4}"), fourToSix = digitRegex(loc, "{4,6}"), literal = (t)=>({
+                            regex: RegExp(escapeToken(t.val)),
+                            deser: ([s])=>s,
+                            literal: true
+                        }), unitate = (t)=>{
+                        if (token.literal) return literal(t);
+                        switch(t.val){
+                            case "G":
+                                return oneOf(loc.eras("short"), 0);
+                            case "GG":
+                                return oneOf(loc.eras("long"), 0);
+                            case "y":
+                                return intUnit(oneToSix);
+                            case "yy":
+                                return intUnit(twoToFour, untruncateYear);
+                            case "yyyy":
+                                return intUnit(four);
+                            case "yyyyy":
+                                return intUnit(fourToSix);
+                            case "yyyyyy":
+                                return intUnit(six);
+                            case "M":
+                                return intUnit(oneOrTwo);
+                            case "MM":
+                                return intUnit(two);
+                            case "MMM":
+                                return oneOf(loc.months("short", true), 1);
+                            case "MMMM":
+                                return oneOf(loc.months("long", true), 1);
+                            case "L":
+                                return intUnit(oneOrTwo);
+                            case "LL":
+                                return intUnit(two);
+                            case "LLL":
+                                return oneOf(loc.months("short", false), 1);
+                            case "LLLL":
+                                return oneOf(loc.months("long", false), 1);
+                            case "d":
+                                return intUnit(oneOrTwo);
+                            case "dd":
+                                return intUnit(two);
+                            case "o":
+                                return intUnit(oneToThree);
+                            case "ooo":
+                                return intUnit(three);
+                            case "HH":
+                                return intUnit(two);
+                            case "H":
+                                return intUnit(oneOrTwo);
+                            case "hh":
+                                return intUnit(two);
+                            case "h":
+                                return intUnit(oneOrTwo);
+                            case "mm":
+                                return intUnit(two);
+                            case "m":
+                                return intUnit(oneOrTwo);
+                            case "q":
+                                return intUnit(oneOrTwo);
+                            case "qq":
+                                return intUnit(two);
+                            case "s":
+                                return intUnit(oneOrTwo);
+                            case "ss":
+                                return intUnit(two);
+                            case "S":
+                                return intUnit(oneToThree);
+                            case "SSS":
+                                return intUnit(three);
+                            case "u":
+                                return simple(oneToNine);
+                            case "uu":
+                                return simple(oneOrTwo);
+                            case "uuu":
+                                return intUnit(one);
+                            case "a":
+                                return oneOf(loc.meridiems(), 0);
+                            case "kkkk":
+                                return intUnit(four);
+                            case "kk":
+                                return intUnit(twoToFour, untruncateYear);
+                            case "W":
+                                return intUnit(oneOrTwo);
+                            case "WW":
+                                return intUnit(two);
+                            case "E":
+                            case "c":
+                                return intUnit(one);
+                            case "EEE":
+                                return oneOf(loc.weekdays("short", false), 1);
+                            case "EEEE":
+                                return oneOf(loc.weekdays("long", false), 1);
+                            case "ccc":
+                                return oneOf(loc.weekdays("short", true), 1);
+                            case "cccc":
+                                return oneOf(loc.weekdays("long", true), 1);
+                            case "Z":
+                            case "ZZ":
+                                return luxon_offset(new RegExp(`([+-]${oneOrTwo.source})(?::(${two.source}))?`), 2);
+                            case "ZZZ":
+                                return luxon_offset(new RegExp(`([+-]${oneOrTwo.source})(${two.source})?`), 2);
+                            case "z":
+                                return simple(/[a-z_+-/]{1,256}?/i);
+                            case " ":
+                                return simple(/[^\S\n\r]/);
+                            default:
+                                return literal(t);
+                        }
+                    };
+                    const unit = unitate(token) || {
+                        invalidReason: MISSING_FTP
+                    };
+                    unit.token = token;
+                    return unit;
+                }
+                const partTypeStyleToTokenVal = {
+                    year: {
+                        "2-digit": "yy",
+                        numeric: "yyyyy"
+                    },
+                    month: {
+                        numeric: "M",
+                        "2-digit": "MM",
+                        short: "MMM",
+                        long: "MMMM"
+                    },
+                    day: {
+                        numeric: "d",
+                        "2-digit": "dd"
+                    },
+                    weekday: {
+                        short: "EEE",
+                        long: "EEEE"
+                    },
+                    dayperiod: "a",
+                    dayPeriod: "a",
+                    hour12: {
+                        numeric: "h",
+                        "2-digit": "hh"
+                    },
+                    hour24: {
+                        numeric: "H",
+                        "2-digit": "HH"
+                    },
+                    minute: {
+                        numeric: "m",
+                        "2-digit": "mm"
+                    },
+                    second: {
+                        numeric: "s",
+                        "2-digit": "ss"
+                    },
+                    timeZoneName: {
+                        long: "ZZZZZ",
+                        short: "ZZZ"
+                    }
+                };
+                function tokenForPart(part, formatOpts, resolvedOpts) {
+                    const { type, value } = part;
+                    if ("literal" === type) {
+                        const isSpace = /^\s+$/.test(value);
+                        return {
+                            literal: !isSpace,
+                            val: isSpace ? " " : value
+                        };
+                    }
+                    const style = formatOpts[type];
+                    let actualType = type;
+                    if ("hour" === type) actualType = null != formatOpts.hour12 ? formatOpts.hour12 ? "hour12" : "hour24" : null != formatOpts.hourCycle ? "h11" === formatOpts.hourCycle || "h12" === formatOpts.hourCycle ? "hour12" : "hour24" : resolvedOpts.hour12 ? "hour12" : "hour24";
+                    let val = partTypeStyleToTokenVal[actualType];
+                    if ("object" == typeof val) val = val[style];
+                    if (val) return {
+                        literal: false,
+                        val
+                    };
+                }
+                function buildRegex(units) {
+                    const re = units.map((u)=>u.regex).reduce((f, r)=>`${f}(${r.source})`, "");
+                    return [
+                        `^${re}$`,
+                        units
+                    ];
+                }
+                function luxon_match(input, regex, handlers) {
+                    const matches = input.match(regex);
+                    if (!matches) return [
+                        matches,
+                        {}
+                    ];
+                    {
+                        const all = {};
+                        let matchIndex = 1;
+                        for(const i in handlers)if (luxon_hasOwnProperty(handlers, i)) {
+                            const h = handlers[i], groups = h.groups ? h.groups + 1 : 1;
+                            if (!h.literal && h.token) all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups));
+                            matchIndex += groups;
+                        }
+                        return [
+                            matches,
+                            all
+                        ];
+                    }
+                }
+                function dateTimeFromMatches(matches) {
+                    const toField = (token)=>{
+                        switch(token){
+                            case "S":
+                                return "millisecond";
+                            case "s":
+                                return "second";
+                            case "m":
+                                return "minute";
+                            case "h":
+                            case "H":
+                                return "hour";
+                            case "d":
+                                return "day";
+                            case "o":
+                                return "ordinal";
+                            case "L":
+                            case "M":
+                                return "month";
+                            case "y":
+                                return "year";
+                            case "E":
+                            case "c":
+                                return "weekday";
+                            case "W":
+                                return "weekNumber";
+                            case "k":
+                                return "weekYear";
+                            case "q":
+                                return "quarter";
+                            default:
+                                return null;
+                        }
+                    };
+                    let zone = null;
+                    let specificOffset;
+                    if (!isUndefined(matches.z)) zone = IANAZone.create(matches.z);
+                    if (!isUndefined(matches.Z)) {
+                        if (!zone) zone = new FixedOffsetZone(matches.Z);
+                        specificOffset = matches.Z;
+                    }
+                    if (!isUndefined(matches.q)) matches.M = (matches.q - 1) * 3 + 1;
+                    if (!isUndefined(matches.h)) {
+                        if (matches.h < 12 && 1 === matches.a) matches.h += 12;
+                        else if (12 === matches.h && 0 === matches.a) matches.h = 0;
+                    }
+                    if (0 === matches.G && matches.y) matches.y = -matches.y;
+                    if (!isUndefined(matches.u)) matches.S = parseMillis(matches.u);
+                    const vals = Object.keys(matches).reduce((r, k)=>{
+                        const f = toField(k);
+                        if (f) r[f] = matches[k];
+                        return r;
+                    }, {});
+                    return [
+                        vals,
+                        zone,
+                        specificOffset
+                    ];
+                }
+                let dummyDateTimeCache = null;
+                function getDummyDateTime() {
+                    if (!dummyDateTimeCache) dummyDateTimeCache = DateTime.fromMillis(1555555555555);
+                    return dummyDateTimeCache;
+                }
+                function maybeExpandMacroToken(token, locale) {
+                    if (token.literal) return token;
+                    const formatOpts = Formatter.macroTokenToFormatOpts(token.val);
+                    const tokens = formatOptsToTokens(formatOpts, locale);
+                    if (null == tokens || tokens.includes(void 0)) return token;
+                    return tokens;
+                }
+                function expandMacroTokens(tokens, locale) {
+                    return Array.prototype.concat(...tokens.map((t)=>maybeExpandMacroToken(t, locale)));
+                }
+                class TokenParser {
+                    constructor(locale, format){
+                        this.locale = locale;
+                        this.format = format;
+                        this.tokens = expandMacroTokens(Formatter.parseFormat(format), locale);
+                        this.units = this.tokens.map((t)=>unitForToken(t, locale));
+                        this.disqualifyingUnit = this.units.find((t)=>t.invalidReason);
+                        if (!this.disqualifyingUnit) {
+                            const [regexString, handlers] = buildRegex(this.units);
+                            this.regex = RegExp(regexString, "i");
+                            this.handlers = handlers;
+                        }
+                    }
+                    explainFromTokens(input) {
+                        if (!this.isValid) return {
+                            input,
+                            tokens: this.tokens,
+                            invalidReason: this.invalidReason
+                        };
+                        {
+                            const [rawMatches, matches] = luxon_match(input, this.regex, this.handlers), [result, zone, specificOffset] = matches ? dateTimeFromMatches(matches) : [
+                                null,
+                                null,
+                                void 0
+                            ];
+                            if (luxon_hasOwnProperty(matches, "a") && luxon_hasOwnProperty(matches, "H")) throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
+                            return {
+                                input,
+                                tokens: this.tokens,
+                                regex: this.regex,
+                                rawMatches,
+                                matches,
+                                result,
+                                zone,
+                                specificOffset
+                            };
+                        }
+                    }
+                    get isValid() {
+                        return !this.disqualifyingUnit;
+                    }
+                    get invalidReason() {
+                        return this.disqualifyingUnit ? this.disqualifyingUnit.invalidReason : null;
+                    }
+                }
+                function explainFromTokens(locale, input, format) {
+                    const parser = new TokenParser(locale, format);
+                    return parser.explainFromTokens(input);
+                }
+                function parseFromTokens(locale, input, format) {
+                    const { result, zone, specificOffset, invalidReason } = explainFromTokens(locale, input, format);
+                    return [
+                        result,
+                        zone,
+                        specificOffset,
+                        invalidReason
+                    ];
+                }
+                function formatOptsToTokens(formatOpts, locale) {
+                    if (!formatOpts) return null;
+                    const formatter = Formatter.create(locale, formatOpts);
+                    const df = formatter.dtFormatter(getDummyDateTime());
+                    const parts = df.formatToParts();
+                    const resolvedOpts = df.resolvedOptions();
+                    return parts.map((p)=>tokenForPart(p, formatOpts, resolvedOpts));
+                }
+                const INVALID = "Invalid DateTime";
+                const MAX_DATE = 8.64e15;
+                function unsupportedZone(zone) {
+                    return new Invalid("unsupported zone", `the zone "${zone.name}" is not supported`);
+                }
+                function possiblyCachedWeekData(dt) {
+                    if (null === dt.weekData) dt.weekData = gregorianToWeek(dt.c);
+                    return dt.weekData;
+                }
+                function possiblyCachedLocalWeekData(dt) {
+                    if (null === dt.localWeekData) dt.localWeekData = gregorianToWeek(dt.c, dt.loc.getMinDaysInFirstWeek(), dt.loc.getStartOfWeek());
+                    return dt.localWeekData;
+                }
+                function clone(inst, alts) {
+                    const current = {
+                        ts: inst.ts,
+                        zone: inst.zone,
+                        c: inst.c,
+                        o: inst.o,
+                        loc: inst.loc,
+                        invalid: inst.invalid
+                    };
+                    return new DateTime({
+                        ...current,
+                        ...alts,
+                        old: current
+                    });
+                }
+                function fixOffset(localTS, o, tz) {
+                    let utcGuess = localTS - 60 * o * 1000;
+                    const o2 = tz.offset(utcGuess);
+                    if (o === o2) return [
+                        utcGuess,
+                        o
+                    ];
+                    utcGuess -= (o2 - o) * 60000;
+                    const o3 = tz.offset(utcGuess);
+                    if (o2 === o3) return [
+                        utcGuess,
+                        o2
+                    ];
+                    return [
+                        localTS - 60 * Math.min(o2, o3) * 1000,
+                        Math.max(o2, o3)
+                    ];
+                }
+                function tsToObj(ts, offset) {
+                    ts += 60 * offset * 1000;
+                    const d = new Date(ts);
+                    return {
+                        year: d.getUTCFullYear(),
+                        month: d.getUTCMonth() + 1,
+                        day: d.getUTCDate(),
+                        hour: d.getUTCHours(),
+                        minute: d.getUTCMinutes(),
+                        second: d.getUTCSeconds(),
+                        millisecond: d.getUTCMilliseconds()
+                    };
+                }
+                function objToTS(obj, offset, zone) {
+                    return fixOffset(objToLocalTS(obj), offset, zone);
+                }
+                function adjustTime(inst, dur) {
+                    const oPre = inst.o, year = inst.c.year + Math.trunc(dur.years), month = inst.c.month + Math.trunc(dur.months) + 3 * Math.trunc(dur.quarters), c = {
+                        ...inst.c,
+                        year,
+                        month,
+                        day: Math.min(inst.c.day, daysInMonth(year, month)) + Math.trunc(dur.days) + 7 * Math.trunc(dur.weeks)
+                    }, millisToAdd = Duration.fromObject({
+                        years: dur.years - Math.trunc(dur.years),
+                        quarters: dur.quarters - Math.trunc(dur.quarters),
+                        months: dur.months - Math.trunc(dur.months),
+                        weeks: dur.weeks - Math.trunc(dur.weeks),
+                        days: dur.days - Math.trunc(dur.days),
+                        hours: dur.hours,
+                        minutes: dur.minutes,
+                        seconds: dur.seconds,
+                        milliseconds: dur.milliseconds
+                    }).as("milliseconds"), localTS = objToLocalTS(c);
+                    let [ts, o] = fixOffset(localTS, oPre, inst.zone);
+                    if (0 !== millisToAdd) {
+                        ts += millisToAdd;
+                        o = inst.zone.offset(ts);
+                    }
+                    return {
+                        ts,
+                        o
+                    };
+                }
+                function parseDataToDateTime(parsed, parsedZone, opts, format, text, specificOffset) {
+                    const { setZone, zone } = opts;
+                    if ((!parsed || 0 === Object.keys(parsed).length) && !parsedZone) return DateTime.invalid(new Invalid("unparsable", `the input "${text}" can't be parsed as ${format}`));
+                    {
+                        const interpretationZone = parsedZone || zone, inst = DateTime.fromObject(parsed, {
+                            ...opts,
+                            zone: interpretationZone,
+                            specificOffset
+                        });
+                        return setZone ? inst : inst.setZone(zone);
+                    }
+                }
+                function toTechFormat(dt, format, allowZ = true) {
+                    return dt.isValid ? Formatter.create(Locale.create("en-US"), {
+                        allowZ,
+                        forceSimple: true
+                    }).formatDateTimeFromString(dt, format) : null;
+                }
+                function toISODate(o, extended, precision) {
+                    const longFormat = o.c.year > 9999 || o.c.year < 0;
+                    let c = "";
+                    if (longFormat && o.c.year >= 0) c += "+";
+                    c += padStart(o.c.year, longFormat ? 6 : 4);
+                    if ("year" === precision) return c;
+                    if (extended) {
+                        c += "-";
+                        c += padStart(o.c.month);
+                        if ("month" === precision) return c;
+                        c += "-";
+                    } else {
+                        c += padStart(o.c.month);
+                        if ("month" === precision) return c;
+                    }
+                    c += padStart(o.c.day);
+                    return c;
+                }
+                function toISOTime(o, extended, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision) {
+                    let showSeconds = !suppressSeconds || 0 !== o.c.millisecond || 0 !== o.c.second, c = "";
+                    switch(precision){
+                        case "day":
+                        case "month":
+                        case "year":
+                            break;
+                        default:
+                            c += padStart(o.c.hour);
+                            if ("hour" === precision) break;
+                            if (extended) {
+                                c += ":";
+                                c += padStart(o.c.minute);
+                                if ("minute" === precision) break;
+                                if (showSeconds) {
+                                    c += ":";
+                                    c += padStart(o.c.second);
+                                }
+                            } else {
+                                c += padStart(o.c.minute);
+                                if ("minute" === precision) break;
+                                if (showSeconds) c += padStart(o.c.second);
+                            }
+                            if ("second" === precision) break;
+                            if (showSeconds && (!suppressMilliseconds || 0 !== o.c.millisecond)) {
+                                c += ".";
+                                c += padStart(o.c.millisecond, 3);
+                            }
+                    }
+                    if (includeOffset) if (o.isOffsetFixed && 0 === o.offset && !extendedZone) c += "Z";
+                    else if (o.o < 0) {
+                        c += "-";
+                        c += padStart(Math.trunc(-o.o / 60));
+                        c += ":";
+                        c += padStart(Math.trunc(-o.o % 60));
+                    } else {
+                        c += "+";
+                        c += padStart(Math.trunc(o.o / 60));
+                        c += ":";
+                        c += padStart(Math.trunc(o.o % 60));
+                    }
+                    if (extendedZone) c += "[" + o.zone.ianaName + "]";
+                    return c;
+                }
+                const defaultUnitValues = {
+                    month: 1,
+                    day: 1,
+                    hour: 0,
+                    minute: 0,
+                    second: 0,
+                    millisecond: 0
+                }, defaultWeekUnitValues = {
+                    weekNumber: 1,
+                    weekday: 1,
+                    hour: 0,
+                    minute: 0,
+                    second: 0,
+                    millisecond: 0
+                }, defaultOrdinalUnitValues = {
+                    ordinal: 1,
+                    hour: 0,
+                    minute: 0,
+                    second: 0,
+                    millisecond: 0
+                };
+                const orderedUnits = [
+                    "year",
+                    "month",
+                    "day",
+                    "hour",
+                    "minute",
+                    "second",
+                    "millisecond"
+                ], orderedWeekUnits = [
+                    "weekYear",
+                    "weekNumber",
+                    "weekday",
+                    "hour",
+                    "minute",
+                    "second",
+                    "millisecond"
+                ], orderedOrdinalUnits = [
+                    "year",
+                    "ordinal",
+                    "hour",
+                    "minute",
+                    "second",
+                    "millisecond"
+                ];
+                function normalizeUnit(unit) {
+                    const normalized = {
+                        year: "year",
+                        years: "year",
+                        month: "month",
+                        months: "month",
+                        day: "day",
+                        days: "day",
+                        hour: "hour",
+                        hours: "hour",
+                        minute: "minute",
+                        minutes: "minute",
+                        quarter: "quarter",
+                        quarters: "quarter",
+                        second: "second",
+                        seconds: "second",
+                        millisecond: "millisecond",
+                        milliseconds: "millisecond",
+                        weekday: "weekday",
+                        weekdays: "weekday",
+                        weeknumber: "weekNumber",
+                        weeksnumber: "weekNumber",
+                        weeknumbers: "weekNumber",
+                        weekyear: "weekYear",
+                        weekyears: "weekYear",
+                        ordinal: "ordinal"
+                    }[unit.toLowerCase()];
+                    if (!normalized) throw new InvalidUnitError(unit);
+                    return normalized;
+                }
+                function normalizeUnitWithLocalWeeks(unit) {
+                    switch(unit.toLowerCase()){
+                        case "localweekday":
+                        case "localweekdays":
+                            return "localWeekday";
+                        case "localweeknumber":
+                        case "localweeknumbers":
+                            return "localWeekNumber";
+                        case "localweekyear":
+                        case "localweekyears":
+                            return "localWeekYear";
+                        default:
+                            return normalizeUnit(unit);
+                    }
+                }
+                function guessOffsetForZone(zone) {
+                    if (void 0 === zoneOffsetTs) zoneOffsetTs = Settings.now();
+                    if ("iana" !== zone.type) return zone.offset(zoneOffsetTs);
+                    const zoneName = zone.name;
+                    let offsetGuess = zoneOffsetGuessCache.get(zoneName);
+                    if (void 0 === offsetGuess) {
+                        offsetGuess = zone.offset(zoneOffsetTs);
+                        zoneOffsetGuessCache.set(zoneName, offsetGuess);
+                    }
+                    return offsetGuess;
+                }
+                function quickDT(obj, opts) {
+                    const zone = normalizeZone(opts.zone, Settings.defaultZone);
+                    if (!zone.isValid) return DateTime.invalid(unsupportedZone(zone));
+                    const loc = Locale.fromObject(opts);
+                    let ts, o;
+                    if (isUndefined(obj.year)) ts = Settings.now();
+                    else {
+                        for (const u of orderedUnits)if (isUndefined(obj[u])) obj[u] = defaultUnitValues[u];
+                        const invalid = hasInvalidGregorianData(obj) || hasInvalidTimeData(obj);
+                        if (invalid) return DateTime.invalid(invalid);
+                        const offsetProvis = guessOffsetForZone(zone);
+                        [ts, o] = objToTS(obj, offsetProvis, zone);
+                    }
+                    return new DateTime({
+                        ts,
+                        zone,
+                        loc,
+                        o
+                    });
+                }
+                function diffRelative(start, end, opts) {
+                    const round = isUndefined(opts.round) ? true : opts.round, rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding, format = (c, unit)=>{
+                        c = roundTo(c, round || opts.calendary ? 0 : 2, opts.calendary ? "round" : rounding);
+                        const formatter = end.loc.clone(opts).relFormatter(opts);
+                        return formatter.format(c, unit);
+                    }, differ = (unit)=>{
+                        if (!opts.calendary) return end.diff(start, unit).get(unit);
+                        if (!end.hasSame(start, unit)) return end.startOf(unit).diff(start.startOf(unit), unit).get(unit);
+                        return 0;
+                    };
+                    if (opts.unit) return format(differ(opts.unit), opts.unit);
+                    for (const unit of opts.units){
+                        const count = differ(unit);
+                        if (Math.abs(count) >= 1) return format(count, unit);
+                    }
+                    return format(start > end ? -0 : 0, opts.units[opts.units.length - 1]);
+                }
+                function lastOpts(argList) {
+                    let opts = {}, args;
+                    if (argList.length > 0 && "object" == typeof argList[argList.length - 1]) {
+                        opts = argList[argList.length - 1];
+                        args = Array.from(argList).slice(0, argList.length - 1);
+                    } else args = Array.from(argList);
+                    return [
+                        opts,
+                        args
+                    ];
+                }
+                let zoneOffsetTs;
+                const zoneOffsetGuessCache = new Map();
+                class DateTime {
+                    constructor(config){
+                        const zone = config.zone || Settings.defaultZone;
+                        let invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid("invalid input") : null) || (zone.isValid ? null : unsupportedZone(zone));
+                        this.ts = isUndefined(config.ts) ? Settings.now() : config.ts;
+                        let c = null, o = null;
+                        if (!invalid) {
+                            const unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone);
+                            if (unchanged) [c, o] = [
+                                config.old.c,
+                                config.old.o
+                            ];
+                            else {
+                                const ot = isNumber(config.o) && !config.old ? config.o : zone.offset(this.ts);
+                                c = tsToObj(this.ts, ot);
+                                invalid = Number.isNaN(c.year) ? new Invalid("invalid input") : null;
+                                c = invalid ? null : c;
+                                o = invalid ? null : ot;
+                            }
+                        }
+                        this._zone = zone;
+                        this.loc = config.loc || Locale.create();
+                        this.invalid = invalid;
+                        this.weekData = null;
+                        this.localWeekData = null;
+                        this.c = c;
+                        this.o = o;
+                        this.isLuxonDateTime = true;
+                    }
+                    static now() {
+                        return new DateTime({});
+                    }
+                    static local() {
+                        const [opts, args] = lastOpts(arguments), [year, month, day, hour, minute, second, millisecond] = args;
+                        return quickDT({
+                            year,
+                            month,
+                            day,
+                            hour,
+                            minute,
+                            second,
+                            millisecond
+                        }, opts);
+                    }
+                    static utc() {
+                        const [opts, args] = lastOpts(arguments), [year, month, day, hour, minute, second, millisecond] = args;
+                        opts.zone = FixedOffsetZone.utcInstance;
+                        return quickDT({
+                            year,
+                            month,
+                            day,
+                            hour,
+                            minute,
+                            second,
+                            millisecond
+                        }, opts);
+                    }
+                    static fromJSDate(date, options = {}) {
+                        const ts = isDate(date) ? date.valueOf() : NaN;
+                        if (Number.isNaN(ts)) return DateTime.invalid("invalid input");
+                        const zoneToUse = normalizeZone(options.zone, Settings.defaultZone);
+                        if (!zoneToUse.isValid) return DateTime.invalid(unsupportedZone(zoneToUse));
+                        return new DateTime({
+                            ts: ts,
+                            zone: zoneToUse,
+                            loc: Locale.fromObject(options)
+                        });
+                    }
+                    static fromMillis(milliseconds, options = {}) {
+                        if (isNumber(milliseconds)) if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) return DateTime.invalid("Timestamp out of range");
+                        else return new DateTime({
+                            ts: milliseconds,
+                            zone: normalizeZone(options.zone, Settings.defaultZone),
+                            loc: Locale.fromObject(options)
+                        });
+                        throw new InvalidArgumentError(`fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`);
+                    }
+                    static fromSeconds(seconds, options = {}) {
+                        if (isNumber(seconds)) return new DateTime({
+                            ts: 1000 * seconds,
+                            zone: normalizeZone(options.zone, Settings.defaultZone),
+                            loc: Locale.fromObject(options)
+                        });
+                        throw new InvalidArgumentError("fromSeconds requires a numerical input");
+                    }
+                    static fromObject(obj, opts = {}) {
+                        obj = obj || {};
+                        const zoneToUse = normalizeZone(opts.zone, Settings.defaultZone);
+                        if (!zoneToUse.isValid) return DateTime.invalid(unsupportedZone(zoneToUse));
+                        const loc = Locale.fromObject(opts);
+                        const normalized = normalizeObject(obj, normalizeUnitWithLocalWeeks);
+                        const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized, loc);
+                        const tsNow = Settings.now(), offsetProvis = isUndefined(opts.specificOffset) ? zoneToUse.offset(tsNow) : opts.specificOffset, containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber;
+                        if ((containsGregor || containsOrdinal) && definiteWeekDef) throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals");
+                        if (containsGregorMD && containsOrdinal) throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day");
+                        const useWeekData = definiteWeekDef || normalized.weekday && !containsGregor;
+                        let units, defaultValues, objNow = tsToObj(tsNow, offsetProvis);
+                        if (useWeekData) {
+                            units = orderedWeekUnits;
+                            defaultValues = defaultWeekUnitValues;
+                            objNow = gregorianToWeek(objNow, minDaysInFirstWeek, startOfWeek);
+                        } else if (containsOrdinal) {
+                            units = orderedOrdinalUnits;
+                            defaultValues = defaultOrdinalUnitValues;
+                            objNow = gregorianToOrdinal(objNow);
+                        } else {
+                            units = orderedUnits;
+                            defaultValues = defaultUnitValues;
+                        }
+                        let foundFirst = false;
+                        for (const u of units){
+                            const v = normalized[u];
+                            if (isUndefined(v)) if (foundFirst) normalized[u] = defaultValues[u];
+                            else normalized[u] = objNow[u];
+                            else foundFirst = true;
+                        }
+                        const higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized), invalid = higherOrderInvalid || hasInvalidTimeData(normalized);
+                        if (invalid) return DateTime.invalid(invalid);
+                        const gregorian = useWeekData ? weekToGregorian(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? ordinalToGregorian(normalized) : normalized, [tsFinal, offsetFinal] = objToTS(gregorian, offsetProvis, zoneToUse), inst = new DateTime({
+                            ts: tsFinal,
+                            zone: zoneToUse,
+                            o: offsetFinal,
+                            loc
+                        });
+                        if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) return DateTime.invalid("mismatched weekday", `you can't specify both a weekday of ${normalized.weekday} and a date of ${inst.toISO()}`);
+                        if (!inst.isValid) return DateTime.invalid(inst.invalid);
+                        return inst;
+                    }
+                    static fromISO(text, opts = {}) {
+                        const [vals, parsedZone] = parseISODate(text);
+                        return parseDataToDateTime(vals, parsedZone, opts, "ISO 8601", text);
+                    }
+                    static fromRFC2822(text, opts = {}) {
+                        const [vals, parsedZone] = parseRFC2822Date(text);
+                        return parseDataToDateTime(vals, parsedZone, opts, "RFC 2822", text);
+                    }
+                    static fromHTTP(text, opts = {}) {
+                        const [vals, parsedZone] = parseHTTPDate(text);
+                        return parseDataToDateTime(vals, parsedZone, opts, "HTTP", opts);
+                    }
+                    static fromFormat(text, fmt, opts = {}) {
+                        if (isUndefined(text) || isUndefined(fmt)) throw new InvalidArgumentError("fromFormat requires an input string and a format");
+                        const { locale = null, numberingSystem = null } = opts, localeToUse = Locale.fromOpts({
+                            locale,
+                            numberingSystem,
+                            defaultToEN: true
+                        }), [vals, parsedZone, specificOffset, invalid] = parseFromTokens(localeToUse, text, fmt);
+                        if (invalid) return DateTime.invalid(invalid);
+                        return parseDataToDateTime(vals, parsedZone, opts, `format ${fmt}`, text, specificOffset);
+                    }
+                    static fromString(text, fmt, opts = {}) {
+                        return DateTime.fromFormat(text, fmt, opts);
+                    }
+                    static fromSQL(text, opts = {}) {
+                        const [vals, parsedZone] = parseSQL(text);
+                        return parseDataToDateTime(vals, parsedZone, opts, "SQL", text);
+                    }
+                    static invalid(reason, explanation = null) {
+                        if (!reason) throw new InvalidArgumentError("need to specify a reason the DateTime is invalid");
+                        const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);
+                        if (!Settings.throwOnInvalid) return new DateTime({
+                            invalid
+                        });
+                        throw new InvalidDateTimeError(invalid);
+                    }
+                    static isDateTime(o) {
+                        return o && o.isLuxonDateTime || false;
+                    }
+                    static parseFormatForOpts(formatOpts, localeOpts = {}) {
+                        const tokenList = formatOptsToTokens(formatOpts, Locale.fromObject(localeOpts));
+                        return tokenList ? tokenList.map((t)=>t ? t.val : null).join("") : null;
+                    }
+                    static expandFormat(fmt, localeOpts = {}) {
+                        const expanded = expandMacroTokens(Formatter.parseFormat(fmt), Locale.fromObject(localeOpts));
+                        return expanded.map((t)=>t.val).join("");
+                    }
+                    static resetCache() {
+                        zoneOffsetTs = void 0;
+                        zoneOffsetGuessCache.clear();
+                    }
+                    get(unit) {
+                        return this[unit];
+                    }
+                    get isValid() {
+                        return null === this.invalid;
+                    }
+                    get invalidReason() {
+                        return this.invalid ? this.invalid.reason : null;
+                    }
+                    get invalidExplanation() {
+                        return this.invalid ? this.invalid.explanation : null;
+                    }
+                    get locale() {
+                        return this.isValid ? this.loc.locale : null;
+                    }
+                    get numberingSystem() {
+                        return this.isValid ? this.loc.numberingSystem : null;
+                    }
+                    get outputCalendar() {
+                        return this.isValid ? this.loc.outputCalendar : null;
+                    }
+                    get zone() {
+                        return this._zone;
+                    }
+                    get zoneName() {
+                        return this.isValid ? this.zone.name : null;
+                    }
+                    get year() {
+                        return this.isValid ? this.c.year : NaN;
+                    }
+                    get quarter() {
+                        return this.isValid ? Math.ceil(this.c.month / 3) : NaN;
+                    }
+                    get month() {
+                        return this.isValid ? this.c.month : NaN;
+                    }
+                    get day() {
+                        return this.isValid ? this.c.day : NaN;
+                    }
+                    get hour() {
+                        return this.isValid ? this.c.hour : NaN;
+                    }
+                    get minute() {
+                        return this.isValid ? this.c.minute : NaN;
+                    }
+                    get second() {
+                        return this.isValid ? this.c.second : NaN;
+                    }
+                    get millisecond() {
+                        return this.isValid ? this.c.millisecond : NaN;
+                    }
+                    get weekYear() {
+                        return this.isValid ? possiblyCachedWeekData(this).weekYear : NaN;
+                    }
+                    get weekNumber() {
+                        return this.isValid ? possiblyCachedWeekData(this).weekNumber : NaN;
+                    }
+                    get weekday() {
+                        return this.isValid ? possiblyCachedWeekData(this).weekday : NaN;
+                    }
+                    get isWeekend() {
+                        return this.isValid && this.loc.getWeekendDays().includes(this.weekday);
+                    }
+                    get localWeekday() {
+                        return this.isValid ? possiblyCachedLocalWeekData(this).weekday : NaN;
+                    }
+                    get localWeekNumber() {
+                        return this.isValid ? possiblyCachedLocalWeekData(this).weekNumber : NaN;
+                    }
+                    get localWeekYear() {
+                        return this.isValid ? possiblyCachedLocalWeekData(this).weekYear : NaN;
+                    }
+                    get ordinal() {
+                        return this.isValid ? gregorianToOrdinal(this.c).ordinal : NaN;
+                    }
+                    get monthShort() {
+                        return this.isValid ? Info.months("short", {
+                            locObj: this.loc
+                        })[this.month - 1] : null;
+                    }
+                    get monthLong() {
+                        return this.isValid ? Info.months("long", {
+                            locObj: this.loc
+                        })[this.month - 1] : null;
+                    }
+                    get weekdayShort() {
+                        return this.isValid ? Info.weekdays("short", {
+                            locObj: this.loc
+                        })[this.weekday - 1] : null;
+                    }
+                    get weekdayLong() {
+                        return this.isValid ? Info.weekdays("long", {
+                            locObj: this.loc
+                        })[this.weekday - 1] : null;
+                    }
+                    get offset() {
+                        return this.isValid ? +this.o : NaN;
+                    }
+                    get offsetNameShort() {
+                        if (this.isValid) return this.zone.offsetName(this.ts, {
+                            format: "short",
+                            locale: this.locale
+                        });
+                        return null;
+                    }
+                    get offsetNameLong() {
+                        if (this.isValid) return this.zone.offsetName(this.ts, {
+                            format: "long",
+                            locale: this.locale
+                        });
+                        return null;
+                    }
+                    get isOffsetFixed() {
+                        return this.isValid ? this.zone.isUniversal : null;
+                    }
+                    get isInDST() {
+                        if (this.isOffsetFixed) return false;
+                        return this.offset > this.set({
+                            month: 1,
+                            day: 1
+                        }).offset || this.offset > this.set({
+                            month: 5
+                        }).offset;
+                    }
+                    getPossibleOffsets() {
+                        if (!this.isValid || this.isOffsetFixed) return [
+                            this
+                        ];
+                        const dayMs = 86400000;
+                        const minuteMs = 60000;
+                        const localTS = objToLocalTS(this.c);
+                        const oEarlier = this.zone.offset(localTS - dayMs);
+                        const oLater = this.zone.offset(localTS + dayMs);
+                        const o1 = this.zone.offset(localTS - oEarlier * minuteMs);
+                        const o2 = this.zone.offset(localTS - oLater * minuteMs);
+                        if (o1 === o2) return [
+                            this
+                        ];
+                        const ts1 = localTS - o1 * minuteMs;
+                        const ts2 = localTS - o2 * minuteMs;
+                        const c1 = tsToObj(ts1, o1);
+                        const c2 = tsToObj(ts2, o2);
+                        if (c1.hour === c2.hour && c1.minute === c2.minute && c1.second === c2.second && c1.millisecond === c2.millisecond) return [
+                            clone(this, {
+                                ts: ts1
+                            }),
+                            clone(this, {
+                                ts: ts2
+                            })
+                        ];
+                        return [
+                            this
+                        ];
+                    }
+                    get isInLeapYear() {
+                        return isLeapYear(this.year);
+                    }
+                    get daysInMonth() {
+                        return daysInMonth(this.year, this.month);
+                    }
+                    get daysInYear() {
+                        return this.isValid ? daysInYear(this.year) : NaN;
+                    }
+                    get weeksInWeekYear() {
+                        return this.isValid ? weeksInWeekYear(this.weekYear) : NaN;
+                    }
+                    get weeksInLocalWeekYear() {
+                        return this.isValid ? weeksInWeekYear(this.localWeekYear, this.loc.getMinDaysInFirstWeek(), this.loc.getStartOfWeek()) : NaN;
+                    }
+                    resolvedLocaleOptions(opts = {}) {
+                        const { locale, numberingSystem, calendar } = Formatter.create(this.loc.clone(opts), opts).resolvedOptions(this);
+                        return {
+                            locale,
+                            numberingSystem,
+                            outputCalendar: calendar
+                        };
+                    }
+                    toUTC(offset = 0, opts = {}) {
+                        return this.setZone(FixedOffsetZone.instance(offset), opts);
+                    }
+                    toLocal() {
+                        return this.setZone(Settings.defaultZone);
+                    }
+                    setZone(zone, { keepLocalTime = false, keepCalendarTime = false } = {}) {
+                        zone = normalizeZone(zone, Settings.defaultZone);
+                        if (zone.equals(this.zone)) return this;
+                        {
+                            if (!zone.isValid) return DateTime.invalid(unsupportedZone(zone));
+                            let newTS = this.ts;
+                            if (keepLocalTime || keepCalendarTime) {
+                                const offsetGuess = zone.offset(this.ts);
+                                const asObj = this.toObject();
+                                [newTS] = objToTS(asObj, offsetGuess, zone);
+                            }
+                            return clone(this, {
+                                ts: newTS,
+                                zone
+                            });
+                        }
+                    }
+                    reconfigure({ locale, numberingSystem, outputCalendar } = {}) {
+                        const loc = this.loc.clone({
+                            locale,
+                            numberingSystem,
+                            outputCalendar
+                        });
+                        return clone(this, {
+                            loc
+                        });
+                    }
+                    setLocale(locale) {
+                        return this.reconfigure({
+                            locale
+                        });
+                    }
+                    set(values) {
+                        if (!this.isValid) return this;
+                        const normalized = normalizeObject(values, normalizeUnitWithLocalWeeks);
+                        const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized, this.loc);
+                        const settingWeekStuff = !isUndefined(normalized.weekYear) || !isUndefined(normalized.weekNumber) || !isUndefined(normalized.weekday), containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber;
+                        if ((containsGregor || containsOrdinal) && definiteWeekDef) throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals");
+                        if (containsGregorMD && containsOrdinal) throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day");
+                        let mixed;
+                        if (settingWeekStuff) mixed = weekToGregorian({
+                            ...gregorianToWeek(this.c, minDaysInFirstWeek, startOfWeek),
+                            ...normalized
+                        }, minDaysInFirstWeek, startOfWeek);
+                        else if (isUndefined(normalized.ordinal)) {
+                            mixed = {
+                                ...this.toObject(),
+                                ...normalized
+                            };
+                            if (isUndefined(normalized.day)) mixed.day = Math.min(daysInMonth(mixed.year, mixed.month), mixed.day);
+                        } else mixed = ordinalToGregorian({
+                            ...gregorianToOrdinal(this.c),
+                            ...normalized
+                        });
+                        const [ts, o] = objToTS(mixed, this.o, this.zone);
+                        return clone(this, {
+                            ts,
+                            o
+                        });
+                    }
+                    plus(duration) {
+                        if (!this.isValid) return this;
+                        const dur = Duration.fromDurationLike(duration);
+                        return clone(this, adjustTime(this, dur));
+                    }
+                    minus(duration) {
+                        if (!this.isValid) return this;
+                        const dur = Duration.fromDurationLike(duration).negate();
+                        return clone(this, adjustTime(this, dur));
+                    }
+                    startOf(unit, { useLocaleWeeks = false } = {}) {
+                        if (!this.isValid) return this;
+                        const o = {}, normalizedUnit = Duration.normalizeUnit(unit);
+                        switch(normalizedUnit){
+                            case "years":
+                                o.month = 1;
+                            case "quarters":
+                            case "months":
+                                o.day = 1;
+                            case "weeks":
+                            case "days":
+                                o.hour = 0;
+                            case "hours":
+                                o.minute = 0;
+                            case "minutes":
+                                o.second = 0;
+                            case "seconds":
+                                o.millisecond = 0;
+                                break;
+                        }
+                        if ("weeks" === normalizedUnit) if (useLocaleWeeks) {
+                            const startOfWeek = this.loc.getStartOfWeek();
+                            const { weekday } = this;
+                            if (weekday < startOfWeek) o.weekNumber = this.weekNumber - 1;
+                            o.weekday = startOfWeek;
+                        } else o.weekday = 1;
+                        if ("quarters" === normalizedUnit) {
+                            const q = Math.ceil(this.month / 3);
+                            o.month = (q - 1) * 3 + 1;
+                        }
+                        return this.set(o);
+                    }
+                    endOf(unit, opts) {
+                        return this.isValid ? this.plus({
+                            [unit]: 1
+                        }).startOf(unit, opts).minus(1) : this;
+                    }
+                    toFormat(fmt, opts = {}) {
+                        return this.isValid ? Formatter.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID;
+                    }
+                    toLocaleString(formatOpts = DATE_SHORT, opts = {}) {
+                        return this.isValid ? Formatter.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID;
+                    }
+                    toLocaleParts(opts = {}) {
+                        return this.isValid ? Formatter.create(this.loc.clone(opts), opts).formatDateTimeParts(this) : [];
+                    }
+                    toISO({ format = "extended", suppressSeconds = false, suppressMilliseconds = false, includeOffset = true, extendedZone = false, precision = "milliseconds" } = {}) {
+                        if (!this.isValid) return null;
+                        precision = normalizeUnit(precision);
+                        const ext = "extended" === format;
+                        let c = toISODate(this, ext, precision);
+                        if (orderedUnits.indexOf(precision) >= 3) c += "T";
+                        c += toISOTime(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
+                        return c;
+                    }
+                    toISODate({ format = "extended", precision = "day" } = {}) {
+                        if (!this.isValid) return null;
+                        return toISODate(this, "extended" === format, normalizeUnit(precision));
+                    }
+                    toISOWeekDate() {
+                        return toTechFormat(this, "kkkk-'W'WW-c");
+                    }
+                    toISOTime({ suppressMilliseconds = false, suppressSeconds = false, includeOffset = true, includePrefix = false, extendedZone = false, format = "extended", precision = "milliseconds" } = {}) {
+                        if (!this.isValid) return null;
+                        precision = normalizeUnit(precision);
+                        let c = includePrefix && orderedUnits.indexOf(precision) >= 3 ? "T" : "";
+                        return c + toISOTime(this, "extended" === format, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
+                    }
+                    toRFC2822() {
+                        return toTechFormat(this, "EEE, dd LLL yyyy HH:mm:ss ZZZ", false);
+                    }
+                    toHTTP() {
+                        return toTechFormat(this.toUTC(), "EEE, dd LLL yyyy HH:mm:ss 'GMT'");
+                    }
+                    toSQLDate() {
+                        if (!this.isValid) return null;
+                        return toISODate(this, true);
+                    }
+                    toSQLTime({ includeOffset = true, includeZone = false, includeOffsetSpace = true } = {}) {
+                        let fmt = "HH:mm:ss.SSS";
+                        if (includeZone || includeOffset) {
+                            if (includeOffsetSpace) fmt += " ";
+                            if (includeZone) fmt += "z";
+                            else if (includeOffset) fmt += "ZZ";
+                        }
+                        return toTechFormat(this, fmt, true);
+                    }
+                    toSQL(opts = {}) {
+                        if (!this.isValid) return null;
+                        return `${this.toSQLDate()} ${this.toSQLTime(opts)}`;
+                    }
+                    toString() {
+                        return this.isValid ? this.toISO() : INVALID;
+                    }
+                    [Symbol.for("nodejs.util.inspect.custom")]() {
+                        if (this.isValid) return `DateTime { ts: ${this.toISO()}, zone: ${this.zone.name}, locale: ${this.locale} }`;
+                        return `DateTime { Invalid, reason: ${this.invalidReason} }`;
+                    }
+                    valueOf() {
+                        return this.toMillis();
+                    }
+                    toMillis() {
+                        return this.isValid ? this.ts : NaN;
+                    }
+                    toSeconds() {
+                        return this.isValid ? this.ts / 1000 : NaN;
+                    }
+                    toUnixInteger() {
+                        return this.isValid ? Math.floor(this.ts / 1000) : NaN;
+                    }
+                    toJSON() {
+                        return this.toISO();
+                    }
+                    toBSON() {
+                        return this.toJSDate();
+                    }
+                    toObject(opts = {}) {
+                        if (!this.isValid) return {};
+                        const base = {
+                            ...this.c
+                        };
+                        if (opts.includeConfig) {
+                            base.outputCalendar = this.outputCalendar;
+                            base.numberingSystem = this.loc.numberingSystem;
+                            base.locale = this.loc.locale;
+                        }
+                        return base;
+                    }
+                    toJSDate() {
+                        return new Date(this.isValid ? this.ts : NaN);
+                    }
+                    diff(otherDateTime, unit = "milliseconds", opts = {}) {
+                        if (!this.isValid || !otherDateTime.isValid) return Duration.invalid("created by diffing an invalid DateTime");
+                        const durOpts = {
+                            locale: this.locale,
+                            numberingSystem: this.numberingSystem,
+                            ...opts
+                        };
+                        const units = maybeArray(unit).map(Duration.normalizeUnit), otherIsLater = otherDateTime.valueOf() > this.valueOf(), earlier = otherIsLater ? this : otherDateTime, later = otherIsLater ? otherDateTime : this, diffed = diff(earlier, later, units, durOpts);
+                        return otherIsLater ? diffed.negate() : diffed;
+                    }
+                    diffNow(unit = "milliseconds", opts = {}) {
+                        return this.diff(DateTime.now(), unit, opts);
+                    }
+                    until(otherDateTime) {
+                        return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this;
+                    }
+                    hasSame(otherDateTime, unit, opts) {
+                        if (!this.isValid) return false;
+                        const inputMs = otherDateTime.valueOf();
+                        const adjustedToZone = this.setZone(otherDateTime.zone, {
+                            keepLocalTime: true
+                        });
+                        return adjustedToZone.startOf(unit, opts) <= inputMs && inputMs <= adjustedToZone.endOf(unit, opts);
+                    }
+                    equals(other) {
+                        return this.isValid && other.isValid && this.valueOf() === other.valueOf() && this.zone.equals(other.zone) && this.loc.equals(other.loc);
+                    }
+                    toRelative(options = {}) {
+                        if (!this.isValid) return null;
+                        const base = options.base || DateTime.fromObject({}, {
+                            zone: this.zone
+                        }), padding = options.padding ? this < base ? -options.padding : options.padding : 0;
+                        let units = [
+                            "years",
+                            "months",
+                            "days",
+                            "hours",
+                            "minutes",
+                            "seconds"
+                        ];
+                        let unit = options.unit;
+                        if (Array.isArray(options.unit)) {
+                            units = options.unit;
+                            unit = void 0;
+                        }
+                        return diffRelative(base, this.plus(padding), {
+                            ...options,
+                            numeric: "always",
+                            units,
+                            unit
+                        });
+                    }
+                    toRelativeCalendar(options = {}) {
+                        if (!this.isValid) return null;
+                        return diffRelative(options.base || DateTime.fromObject({}, {
+                            zone: this.zone
+                        }), this, {
+                            ...options,
+                            numeric: "auto",
+                            units: [
+                                "years",
+                                "months",
+                                "days"
+                            ],
+                            calendary: true
+                        });
+                    }
+                    static min(...dateTimes) {
+                        if (!dateTimes.every(DateTime.isDateTime)) throw new InvalidArgumentError("min requires all arguments be DateTimes");
+                        return bestBy(dateTimes, (i)=>i.valueOf(), Math.min);
+                    }
+                    static max(...dateTimes) {
+                        if (!dateTimes.every(DateTime.isDateTime)) throw new InvalidArgumentError("max requires all arguments be DateTimes");
+                        return bestBy(dateTimes, (i)=>i.valueOf(), Math.max);
+                    }
+                    static fromFormatExplain(text, fmt, options = {}) {
+                        const { locale = null, numberingSystem = null } = options, localeToUse = Locale.fromOpts({
+                            locale,
+                            numberingSystem,
+                            defaultToEN: true
+                        });
+                        return explainFromTokens(localeToUse, text, fmt);
+                    }
+                    static fromStringExplain(text, fmt, options = {}) {
+                        return DateTime.fromFormatExplain(text, fmt, options);
+                    }
+                    static buildFormatParser(fmt, options = {}) {
+                        const { locale = null, numberingSystem = null } = options, localeToUse = Locale.fromOpts({
+                            locale,
+                            numberingSystem,
+                            defaultToEN: true
+                        });
+                        return new TokenParser(localeToUse, fmt);
+                    }
+                    static fromFormatParser(text, formatParser, opts = {}) {
+                        if (isUndefined(text) || isUndefined(formatParser)) throw new InvalidArgumentError("fromFormatParser requires an input string and a format parser");
+                        const { locale = null, numberingSystem = null } = opts, localeToUse = Locale.fromOpts({
+                            locale,
+                            numberingSystem,
+                            defaultToEN: true
+                        });
+                        if (!localeToUse.equals(formatParser.locale)) throw new InvalidArgumentError(`fromFormatParser called with a locale of ${localeToUse}, but the format parser was created for ${formatParser.locale}`);
+                        const { result, zone, specificOffset, invalidReason } = formatParser.explainFromTokens(text);
+                        if (invalidReason) return DateTime.invalid(invalidReason);
+                        return parseDataToDateTime(result, zone, opts, `format ${formatParser.format}`, text, specificOffset);
+                    }
+                    static get DATE_SHORT() {
+                        return DATE_SHORT;
+                    }
+                    static get DATE_MED() {
+                        return DATE_MED;
+                    }
+                    static get DATE_MED_WITH_WEEKDAY() {
+                        return DATE_MED_WITH_WEEKDAY;
+                    }
+                    static get DATE_FULL() {
+                        return DATE_FULL;
+                    }
+                    static get DATE_HUGE() {
+                        return DATE_HUGE;
+                    }
+                    static get TIME_SIMPLE() {
+                        return TIME_SIMPLE;
+                    }
+                    static get TIME_WITH_SECONDS() {
+                        return TIME_WITH_SECONDS;
+                    }
+                    static get TIME_WITH_SHORT_OFFSET() {
+                        return TIME_WITH_SHORT_OFFSET;
+                    }
+                    static get TIME_WITH_LONG_OFFSET() {
+                        return TIME_WITH_LONG_OFFSET;
+                    }
+                    static get TIME_24_SIMPLE() {
+                        return TIME_24_SIMPLE;
+                    }
+                    static get TIME_24_WITH_SECONDS() {
+                        return TIME_24_WITH_SECONDS;
+                    }
+                    static get TIME_24_WITH_SHORT_OFFSET() {
+                        return TIME_24_WITH_SHORT_OFFSET;
+                    }
+                    static get TIME_24_WITH_LONG_OFFSET() {
+                        return TIME_24_WITH_LONG_OFFSET;
+                    }
+                    static get DATETIME_SHORT() {
+                        return DATETIME_SHORT;
+                    }
+                    static get DATETIME_SHORT_WITH_SECONDS() {
+                        return DATETIME_SHORT_WITH_SECONDS;
+                    }
+                    static get DATETIME_MED() {
+                        return DATETIME_MED;
+                    }
+                    static get DATETIME_MED_WITH_SECONDS() {
+                        return DATETIME_MED_WITH_SECONDS;
+                    }
+                    static get DATETIME_MED_WITH_WEEKDAY() {
+                        return DATETIME_MED_WITH_WEEKDAY;
+                    }
+                    static get DATETIME_FULL() {
+                        return DATETIME_FULL;
+                    }
+                    static get DATETIME_FULL_WITH_SECONDS() {
+                        return DATETIME_FULL_WITH_SECONDS;
+                    }
+                    static get DATETIME_HUGE() {
+                        return DATETIME_HUGE;
+                    }
+                    static get DATETIME_HUGE_WITH_SECONDS() {
+                        return DATETIME_HUGE_WITH_SECONDS;
+                    }
+                }
+                function friendlyDateTime(dateTimeish) {
+                    if (DateTime.isDateTime(dateTimeish)) return dateTimeish;
+                    if (dateTimeish && dateTimeish.valueOf && isNumber(dateTimeish.valueOf())) return DateTime.fromJSDate(dateTimeish);
+                    if (dateTimeish && "object" == typeof dateTimeish) return DateTime.fromObject(dateTimeish);
+                    throw new InvalidArgumentError(`Unknown datetime argument: ${dateTimeish}, of type ${typeof dateTimeish}`);
+                }
+                function history_danmaku_fast_forward_main(that, query_history_date) {
+                    const qhd = DateTime.fromFormat(query_history_date, 'yyyy-MM-dd', {
+                        zone: 'Asia/Shanghai'
+                    }).setZone('Asia/Shanghai');
+                    if (!qhd.isValid) throw new Error('Invalid query_history_date');
+                    const s = qhd.startOf('day');
+                    const before = that.dans.filter((d)=>d.ctime < s.toJSDate());
+                    if (0 === before.length) return {
+                        earliest: null,
+                        FastForward: [],
+                        skip: [],
+                        SpecificDate: qhd.toFormat('yyyy-MM-dd')
+                    };
+                    const earliestCtime = before.toSorted((a, b)=>a.ctime.getTime() - b.ctime.getTime())[0].ctime;
+                    const earliestDate = DateTime.fromJSDate(earliestCtime).setZone('Asia/Shanghai').startOf('day');
+                    const datesWithDanmaku = new Set();
+                    for (const dan of before){
+                        const dateStr = DateTime.fromJSDate(dan.ctime).setZone('Asia/Shanghai').toFormat('yyyy-MM-dd');
+                        datesWithDanmaku.add(dateStr);
+                    }
+                    let current = earliestDate;
+                    const allDates = [];
+                    while(current < s){
+                        allDates.push(current.toFormat('yyyy-MM-dd'));
+                        current = current.plus({
+                            days: 1
+                        });
+                    }
+                    const FastForward = allDates.filter((d)=>datesWithDanmaku.has(d));
+                    const skip = allDates.filter((d)=>!datesWithDanmaku.has(d));
+                    return {
+                        earliest: earliestDate.toFormat('yyyy-MM-dd'),
+                        FastForward,
+                        skip,
+                        SpecificDate: qhd.toFormat('yyyy-MM-dd')
+                    };
+                }
+                function bili_history_fast_forward(query_history_date) {
+                    return (that)=>history_danmaku_fast_forward_main(that, query_history_date);
+                }
             },
             "./src/plugins/stats/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
                 "use strict";
@@ -25038,10 +29653,10 @@ and limitations under the License.
             "use strict";
             __webpack_require__.r(__webpack_exports__);
             __webpack_require__.d(__webpack_exports__, {
-                bili_dedupe: ()=>_bili_dedupe__rspack_import_0,
+                bili: ()=>_bili__rspack_import_0,
                 stats: ()=>_stats__rspack_import_1
             });
-            var _bili_dedupe__rspack_import_0 = __webpack_require__("./src/plugins/bili-dedupe/index.ts");
+            var _bili__rspack_import_0 = __webpack_require__("./src/plugins/bili/index.ts");
             var _stats__rspack_import_1 = __webpack_require__("./src/plugins/stats/index.ts");
         })();
         return __webpack_exports__;