@dan-uni/dan-any 1.2.2 → 1.2.5

package/dist/umd/plugins/{bili-dedupe.umd.min.js → bili.umd.min.js}

@@ -1,4 +1,4 @@
-/*! For license information please see bili-dedupe.umd.min.js.LICENSE.txt */
+/*! For license information please see bili.umd.min.js.LICENSE.txt */
 (function(root, factory) {
     if ('object' == typeof exports && 'object' == typeof module) module.exports = factory();
     else if ('function' == typeof define && define.amd) define([], factory);
@@ -14398,11 +14398,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;
@@ -14778,6 +14778,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 +20339,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.5","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;
@@ -23763,10 +23768,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() {
@@ -24997,14 +24999,20 @@ and limitations under the License.
             "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();
@@ -25013,7 +25021,7 @@ and limitations under the License.
             }
             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);
             }
@@ -25023,6 +25031,4609 @@ and limitations under the License.
                     ...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);
+            }
         })();
         return __webpack_exports__;
     })());