Difference between revisions of "MediaWiki:Gadget-cron.js"

From Moegirlpedia
Jump to: navigation, search
(同步小工具)
(Tag: Bot)
 
m (跨站同步)
(Tag: Bot)
 
Line 1: Line 1:
// https://cdn.jsdelivr.net/npm/cron@1.8.2/lib/cron.js
+
/* <pre> */
 +
/**
 +
* -------------------------------------------------------------------------
 +
* !!! DON'T MODIFY THIS PAGE MANUALLY, YOUR CHANGES WILL BE OVERWRITTEN !!!
 +
* -------------------------------------------------------------------------
 +
*/
 +
var _addText = '{{GHIACode|page=GHIA:MoegirlPediaInterfaceCodes/blob/master/src/gadgets/cron/MediaWiki:Gadget-cron.js|user=[[U:AnnAngela]]|longId=3820b56ff2ac6eb2e6bb95dd82dd71db679b0c81|shortId=3820b56|message=auto: auto browserify - commit from GitHub Actions}}';
 +
 
 
"use strict";
 
"use strict";
(function (root, factory) {
+
var require = function () { return window.luxon; };
     if (typeof define === 'function' && define.amd) {
+
(function () {
        define(['moment-timezone'], factory);
+
     var createModuleFactory = function createModuleFactory(t) { var e; return function (r) { return e || t(e = { exports: {}, parent: r }, e.exports), e.exports; }; };
    }
+
     var _$CronJob_3 = createModuleFactory(function (module, exports) {
    else if (typeof exports === 'object') {
+
         function CronJob(CronTime, spawn) {
        module.exports = factory(require('moment-timezone'), require('child_process'));
+
            function fnWrap(cmd) {
    }
+
                var command;
     else {
+
                var args;
         root.Cron = factory(root.moment);
+
                switch (typeof cmd) {
    }
+
                    case 'string':
})(window, function (moment, childProcess) {
+
                        args = cmd.split(' ');
    var exports = {};
+
                        command = args.shift();
    var timeUnits = [
+
                        return spawn.bind(undefined, command, args);
        'second',
+
                    case 'object':
        'minute',
+
                        command = cmd && cmd.command;
        'hour',
+
                        if (command) {
        'dayOfMonth',
+
                            args = cmd.args;
        'month',
+
                            var options = cmd.options;
        'dayOfWeek'
+
                            return spawn.bind(undefined, command, args, options);
    ];
+
                        }
    var spawn = childProcess && childProcess.spawn;
+
                        break;
    function CronTime(source, zone, utcOffset) {
+
                }
        this.source = source;
+
                 return cmd;
        if (zone) {
 
            if (moment.tz.names().indexOf(zone) === -1) {
 
                 throw new Error('Invalid timezone.');
 
 
             }
 
             }
             this.zone = zone;
+
             function CJ(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
        }
+
                var _cronTime = cronTime;
        if (typeof utcOffset !== 'undefined')
+
                var argCount = 0;
            this.utcOffset = utcOffset;
+
                for (var i = 0; i < arguments.length; i++) {
        var that = this;
+
                    if (arguments[i] !== undefined) {
        timeUnits.map(function (timeUnit) {
+
                        argCount++;
            that[timeUnit] = {};
 
        });
 
        if (this.source instanceof Date || this.source._isAMomentObject) {
 
            this.source = moment(this.source);
 
            this.realDate = true;
 
        }
 
        else {
 
            this._parse();
 
            this._verifyParse();
 
        }
 
    }
 
    CronTime.constraints = [[0, 59], [0, 59], [0, 23], [1, 31], [0, 11], [0, 6]];
 
    CronTime.monthConstraints = [
 
        31,
 
        29,
 
        31,
 
        30,
 
        31,
 
        30,
 
        31,
 
        31,
 
        30,
 
        31,
 
        30,
 
        31
 
    ];
 
    CronTime.parseDefaults = ['0', '*', '*', '*', '*', '*'];
 
    CronTime.aliases = {
 
        jan: 0,
 
        feb: 1,
 
        mar: 2,
 
        apr: 3,
 
        may: 4,
 
        jun: 5,
 
        jul: 6,
 
        aug: 7,
 
        sep: 8,
 
        oct: 9,
 
        nov: 10,
 
        dec: 11,
 
        sun: 0,
 
        mon: 1,
 
        tue: 2,
 
        wed: 3,
 
        thu: 4,
 
        fri: 5,
 
        sat: 6
 
    };
 
    CronTime.prototype = {
 
        _verifyParse: function () {
 
            var months = Object.keys(this.month);
 
            var ok = false;
 
            /* if a dayOfMonth is not found in all months, we only need to fix the last
 
            wrong month  to prevent infinite loop */
 
            var lastWrongMonth = NaN;
 
            for (var i = 0; i < months.length; i++) {
 
                var m = months[i];
 
                var con = CronTime.monthConstraints[parseInt(m, 10)];
 
                var dsom = Object.keys(this.dayOfMonth);
 
                for (var j = 0; j < dsom.length; j++) {
 
                    var dom = dsom[j];
 
                    if (dom <= con) {
 
                        ok = true;
 
 
                     }
 
                     }
 
                 }
 
                 }
                 if (!ok) {
+
                 if (typeof cronTime !== 'string' && argCount === 1) {
                     // save the month in order to be fixed if all months fails (infinite loop)
+
                     onTick = cronTime.onTick;
                     lastWrongMonth = m;
+
                    onComplete = cronTime.onComplete;
                     console.warn("Month '" + m + "' is limited to '" + con + "' days.");
+
                    context = cronTime.context;
 +
                    startNow = cronTime.start || cronTime.startNow || cronTime.startJob;
 +
                    timeZone = cronTime.timeZone;
 +
                    runOnInit = cronTime.runOnInit;
 +
                     _cronTime = cronTime.cronTime;
 +
                     utcOffset = cronTime.utcOffset;
 +
                    unrefTimeout = cronTime.unrefTimeout;
 
                 }
 
                 }
 +
                this.context = context || this;
 +
                this._callbacks = [];
 +
                this.onComplete = fnWrap(onComplete);
 +
                this.cronTime = new CronTime(_cronTime, timeZone, utcOffset);
 +
                this.unrefTimeout = unrefTimeout;
 +
                addCallback.call(this, fnWrap(onTick));
 +
                if (runOnInit) {
 +
                    this.lastExecution = new Date();
 +
                    fireOnTick.call(this);
 +
                }
 +
                if (startNow) {
 +
                    start.call(this);
 +
                }
 +
                return this;
 
             }
 
             }
             // infinite loop detected (dayOfMonth is not found in all months)
+
             var addCallback = function (callback) {
            if (!ok) {
+
                if (typeof callback === 'function') {
                var con = CronTime.monthConstraints[parseInt(lastWrongMonth, 10)];
+
                     this._callbacks.push(callback);
                var dsom = Object.keys(this.dayOfMonth);
 
                for (var k = 0; k < dsom.length; k++) {
 
                     var dom = dsom[k];
 
                    if (dom > con) {
 
                        delete this.dayOfMonth[dom];
 
                        var fixedDay = Number(dom) % con;
 
                        this.dayOfMonth[fixedDay] = true;
 
                    }
 
 
                 }
 
                 }
             }
+
             };
        },
+
             CJ.prototype.addCallback = addCallback;
        /**
+
             CJ.prototype.setTime = function (time) {
        * calculates the next send time
+
                 if (typeof time !== 'object') {
        */
+
                     throw new Error('time must be an instance of CronTime.');
        sendAt: function (i) {
 
             var date = this.realDate ? this.source : moment();
 
             // Set the timezone if given (http://momentjs.com/timezone/docs/#/using-timezones/parsing-in-zone/)
 
            if (this.zone) {
 
                 date = date.tz(this.zone);
 
            }
 
            if (typeof this.utcOffset !== 'undefined') {
 
                date = date.utcOffset(this.utcOffset);
 
            }
 
            if (this.realDate) {
 
                var diff = moment().diff(date, 's');
 
                if (diff > 0) {
 
                     throw new Error('WARNING: Date in past. Will never be fired.');
 
 
                 }
 
                 }
                 return date;
+
                 this.stop();
             }
+
                this.cronTime = time;
             // If the i argument is not given, return the next send time
+
                this.start();
            if (isNaN(i) || i < 0) {
+
             };
                 date = this._getNextDateFrom(date);
+
             CJ.prototype.nextDate = function () {
                return date;
+
                 return this.cronTime.sendAt();
             }
+
             };
             else {
+
             var fireOnTick = function () {
                // Else return the next i send times
+
                 for (var i = this._callbacks.length - 1; i >= 0; i--) {
                var dates = [];
+
                     this._callbacks[i].call(this.context, this.onComplete);
                 for (; i > 0; i--) {
 
                     date = this._getNextDateFrom(date);
 
                    dates.push(moment(date));
 
 
                 }
 
                 }
                return dates;
+
             };
             }
+
             CJ.prototype.fireOnTick = fireOnTick;
        },
+
             CJ.prototype.nextDates = function (i) {
        /**
+
                 return this.cronTime.sendAt(i);
        * Get the number of milliseconds in the future at which to fire our callbacks.
+
             };
        */
+
             var start = function () {
        getTimeout: function () {
+
                 if (this.running) {
             return Math.max(-1, this.sendAt() - moment());
+
                     return;
        },
 
        /**
 
        * writes out a cron string
 
        */
 
        toString: function () {
 
             return this.toJSON().join(' ');
 
        },
 
        /**
 
        * Json representation of the parsed cron syntax.
 
        */
 
        toJSON: function () {
 
            var self = this;
 
            return timeUnits.map(function (timeName) {
 
                 return self._wcOrAll(timeName);
 
             });
 
        },
 
        /**
 
        * get next date that matches parsed cron time
 
        */
 
        _getNextDateFrom: function (start, zone) {
 
             var date;
 
            var firstDate = moment(start).valueOf();
 
            if (zone) {
 
                date = moment(start).tz(zone);
 
            }
 
            else {
 
                 date = moment(start);
 
            }
 
            if (!this.realDate) {
 
                var milliseconds = (start.milliseconds && start.milliseconds()) ||
 
                     (start.getMilliseconds && start.getMilliseconds()) ||
 
                    0;
 
                if (milliseconds > 0) {
 
                    date.milliseconds(0);
 
                    date.seconds(date.seconds() + 1);
 
 
                 }
 
                 }
            }
+
                 var MAXDELAY = 2147483647;
            if (date.toString() === 'Invalid date') {
+
                 var self = this;
                 throw new Error('ERROR: You specified an invalid date.');
+
                 var timeout = this.cronTime.getTimeout();
            }
+
                 var remaining = 0;
            // it shouldn't take more than 5 seconds to find the next execution time
+
                 var startTime;
            // being very generous with this. Throw error if it takes too long to find the next time to protect from
+
                 if (this.cronTime.realDate) {
            // infinite loop.
+
                     this.runOnce = true;
            var timeout = Date.now() + 5000;
 
            // determine next date
 
            while (true) {
 
                 var diff = date - start;
 
                 var prevMonth = date.month();
 
                var prevDay = date.days();
 
                var prevMinute = date.minutes();
 
                 var prevSeconds = date.seconds();
 
                 var origDate = new Date(date);
 
                 if (Date.now() > timeout) {
 
                     throw new Error("Something went wrong. cron reached maximum iterations.\n\t\t\t\t\t\tPlease open an  issue (https://github.com/kelektiv/node-cron/issues/new) and provide the following string\n\t\t\t\t\t\tTime Zone: " + (zone || '""') + " - Cron String: " + this + " - UTC offset: " + date.format('Z') + " - current Date: " + moment().toString());
 
 
                 }
 
                 }
                 if (!(date.month() in this.month) &&
+
                 function _setTimeout(timeout) {
                     Object.keys(this.month).length !== 12) {
+
                     startTime = Date.now();
                     date.add(1, 'M');
+
                     self._timeout = setTimeout(callbackWrapper, timeout);
                     if (date.month() === prevMonth) {
+
                     if (self.unrefTimeout && typeof self._timeout.unref === 'function') {
                         date.add(1, 'M');
+
                         self._timeout.unref();
 
                     }
 
                     }
                    date.date(1);
 
                    date.hours(0);
 
                    date.minutes(0);
 
                    date.seconds(0);
 
                    continue;
 
 
                 }
 
                 }
                 if (!(date.date() in this.dayOfMonth) &&
+
                 function callbackWrapper() {
                     Object.keys(this.dayOfMonth).length !== 31 &&
+
                     var diff = startTime + timeout - Date.now();
                     !(date.day() in this.dayOfWeek &&
+
                     if (diff > 0) {
                         Object.keys(this.dayOfWeek).length !== 7)) {
+
                         var newTimeout = self.cronTime.getTimeout();
                    date.add(1, 'd');
+
                        if (newTimeout > diff) {
                    if (date.days() === prevDay) {
+
                            newTimeout = diff;
                         date.add(1, 'd');
+
                        }
 +
                         remaining += newTimeout;
 
                     }
 
                     }
                     date.hours(0);
+
                     self.lastExecution = new Date();
                     date.minutes(0);
+
                     if (remaining) {
                    date.seconds(0);
+
                        if (remaining > MAXDELAY) {
                    continue;
+
                            remaining -= MAXDELAY;
                }
+
                            timeout = MAXDELAY;
                if (!(date.day() in this.dayOfWeek) &&
+
                        }
                    Object.keys(this.dayOfWeek).length !== 7 &&
+
                        else {
                    !(date.date() in this.dayOfMonth &&
+
                            timeout = remaining;
                        Object.keys(this.dayOfMonth).length !== 31)) {
+
                            remaining = 0;
                    date.add(1, 'd');
+
                        }
                    if (date.days() === prevDay) {
+
                         _setTimeout(timeout);
                         date.add(1, 'd');
 
 
                     }
 
                     }
                     date.hours(0);
+
                     else {
                    date.minutes(0);
+
                        self.running = false;
                    date.seconds(0);
+
                        if (!self.runOnce) {
                    if (date <= origDate) {
+
                            self.start();
                         date = this._findDST(origDate);
+
                        }
 +
                         self.fireOnTick();
 
                     }
 
                     }
                    continue;
 
 
                 }
 
                 }
                 if (!(date.hours() in this.hour) &&
+
                 if (timeout >= 0) {
                    Object.keys(this.hour).length !== 24) {
+
                     this.running = true;
                     origDate = moment(date);
+
                     if (timeout > MAXDELAY) {
                    var curHour = date.hours();
+
                        remaining = timeout - MAXDELAY;
                    date.hours(date.hours() === 23 && diff > 86400000 ? 0 : date.hours() + 1);
+
                         timeout = MAXDELAY;
                     /*
 
                    * Moment Date will not allow you to set the time to 2 AM if there is no 2 AM (on the day we change the clock)
 
                    * We will therefore jump to 3AM if time stayed at 1AM
 
                    */
 
                    if (curHour === date.hours()) {
 
                         date.hours(date.hours() + 2);
 
 
                     }
 
                     }
                     date.minutes(0);
+
                     _setTimeout(timeout);
                    date.seconds(0);
+
                }
                     if (date <= origDate) {
+
                else {
                        date = this._findDST(origDate);
+
                    this.stop();
 +
                }
 +
            };
 +
            CJ.prototype.start = start;
 +
            CJ.prototype.lastDate = function () {
 +
                return this.lastExecution;
 +
            };
 +
            CJ.prototype.stop = function () {
 +
                if (this._timeout)
 +
                     clearTimeout(this._timeout);
 +
                this.running = false;
 +
                if (typeof this.onComplete === 'function') {
 +
                    this.onComplete();
 +
                }
 +
            };
 +
            return CJ;
 +
        }
 +
        module.exports = CronJob;
 +
    });
 +
    var _$CronTime_4 = createModuleFactory(function (module, exports) {
 +
        var CONSTRAINTS = [
 +
            [0, 59],
 +
            [0, 59],
 +
            [0, 23],
 +
            [1, 31],
 +
            [0, 11],
 +
            [0, 6]
 +
        ];
 +
        var MONTH_CONSTRAINTS = [
 +
            31,
 +
            29,
 +
            31,
 +
            30,
 +
            31,
 +
            30,
 +
            31,
 +
            31,
 +
            30,
 +
            31,
 +
            30,
 +
            31
 +
        ];
 +
        var PARSE_DEFAULTS = ['0', '*', '*', '*', '*', '*'];
 +
        var ALIASES = {
 +
            jan: 0,
 +
            feb: 1,
 +
            mar: 2,
 +
            apr: 3,
 +
            may: 4,
 +
            jun: 5,
 +
            jul: 6,
 +
            aug: 7,
 +
            sep: 8,
 +
            oct: 9,
 +
            nov: 10,
 +
            dec: 11,
 +
            sun: 0,
 +
            mon: 1,
 +
            tue: 2,
 +
            wed: 3,
 +
            thu: 4,
 +
            fri: 5,
 +
            sat: 6
 +
        };
 +
        var TIME_UNITS = [
 +
            'second',
 +
            'minute',
 +
            'hour',
 +
            'dayOfMonth',
 +
            'month',
 +
            'dayOfWeek'
 +
        ];
 +
        var TIME_UNITS_LEN = TIME_UNITS.length;
 +
        var PRESETS = {
 +
            '@yearly': '0 0 0 1 0 *',
 +
            '@monthly': '0 0 0 1 * *',
 +
            '@weekly': '0 0 0 * * 0',
 +
            '@daily': '0 0 0 * * *',
 +
            '@hourly': '0 0 * * * *',
 +
            '@minutely': '0 * * * * *',
 +
            '@secondly': '* * * * * *',
 +
            '@weekdays': '0 0 0 * * 1-5',
 +
            '@weekends': '0 0 0 * * 0,6'
 +
        };
 +
        var RE_WILDCARDS = /\*/g;
 +
        var RE_RANGE = /^(\d+)(?:-(\d+))?(?:\/(\d+))?$/g;
 +
        function CronTime(luxon) {
 +
            function CT(source, zone, utcOffset) {
 +
                this.source = source;
 +
                if (zone) {
 +
                    var dt = luxon.DateTime.fromObject({ zone: zone });
 +
                    if (dt.invalid) {
 +
                        throw new Error('Invalid timezone.');
 
                     }
 
                     }
                     continue;
+
                     this.zone = zone;
 
                 }
 
                 }
                 if (!(date.minutes() in this.minute) &&
+
                 if (typeof utcOffset !== 'undefined') {
                    Object.keys(this.minute).length !== 60) {
+
                     this.utcOffset = utcOffset;
                     origDate = moment(date);
 
                    date.minutes(date.minutes() === 59 && diff > 60 * 60 * 1000
 
                        ? 0
 
                        : date.minutes() + 1);
 
                    date.seconds(0);
 
                    if (date <= origDate) {
 
                        date = this._findDST(origDate);
 
                    }
 
                    continue;
 
 
                 }
 
                 }
                 if (!(date.seconds() in this.second) &&
+
                 var that = this;
                    Object.keys(this.second).length !== 60) {
+
                TIME_UNITS.map(function (timeUnit) {
                     origDate = moment(date);
+
                     that[timeUnit] = {};
                    date.seconds(date.seconds() === 59 && diff > 60 * 1000 ? 0 : date.seconds() + 1);
+
                });
                     if (date <= origDate) {
+
                if (this.source instanceof Date || this.source instanceof luxon.DateTime) {
                         date = this._findDST(origDate);
+
                     if (this.source instanceof Date) {
 +
                         this.source = luxon.DateTime.fromJSDate(this.source);
 
                     }
 
                     }
                     continue;
+
                     this.realDate = true;
 
                 }
 
                 }
                 if (date.valueOf() === firstDate) {
+
                 else {
                     date.seconds(date.seconds() + 1);
+
                     this._parse(this.source);
                     continue;
+
                     this._verifyParse();
 
                 }
 
                 }
                break;
 
 
             }
 
             }
             return date;
+
             CT.prototype = {
        },
+
                _verifyParse: function () {
        /**
+
                    var months = Object.keys(this.month);
        * get next date that is a valid DST date
+
                    var dom = Object.keys(this.dayOfMonth);
        */
+
                    var ok = false;
        _findDST: function (date) {
+
                    var lastWrongMonth = NaN;
            var newDate = moment(date);
+
                    for (var i = 0; i < months.length; i++) {
            while (newDate <= date) {
+
                        var m = months[i];
                // eslint seems to trigger here, it is wrong
+
                        var con = MONTH_CONSTRAINTS[parseInt(m, 10)];
                newDate.add(1, 's');
+
                        for (var j = 0; j < dom.length; j++) {
            }
+
                            var day = dom[j];
            return newDate;
+
                            if (day <= con) {
        },
+
                                ok = true;
        /**
+
                            }
        * wildcard, or all params in array (for to string)
+
                        }
        */
+
                        if (!ok) {
        _wcOrAll: function (type) {
+
                            lastWrongMonth = m;
            if (this._hasAll(type))
+
                            console.warn("Month '".concat(m, "' is limited to '").concat(con, "' days."));
                return '*';
+
                        }
            var all = [];
+
                    }
            for (var time in this[type]) {
+
                    if (!ok) {
                all.push(time);
+
                        var notOkCon = MONTH_CONSTRAINTS[parseInt(lastWrongMonth, 10)];
            }
+
                        for (var k = 0; k < dom.length; k++) {
            return all.join(',');
+
                            var notOkDay = dom[k];
        },
+
                            if (notOkDay > notOkCon) {
        _hasAll: function (type) {
+
                                delete this.dayOfMonth[notOkDay];
            var constrain = CronTime.constraints[timeUnits.indexOf(type)];
+
                                var fixedDay = Number(notOkDay) % notOkCon;
            for (var i = constrain[0], n = constrain[1]; i < n; i++) {
+
                                this.dayOfMonth[fixedDay] = true;
                if (!(i in this[type]))
+
                            }
                    return false;
+
                        }
            }
+
                    }
            return true;
+
                },
        },
+
                sendAt: function (i) {
        _parse: function () {
+
                    var date = this.realDate ? this.source : luxon.DateTime.local();
            var aliases = CronTime.aliases;
+
                    if (this.zone) {
            var source = this.source.replace(/[a-z]{1,3}/gi, function (alias) {
+
                        date = date.setZone(this.zone);
                alias = alias.toLowerCase();
+
                    }
                if (alias in aliases) {
+
                    if (typeof this.utcOffset !== 'undefined') {
                    return aliases[alias];
+
                        var offset = this.utcOffset >= 60 || this.utcOffset <= -60
                }
+
                            ? this.utcOffset / 60
                throw new Error('Unknown alias: ' + alias);
+
                            : this.utcOffset;
            });
+
                        offset = parseInt(offset);
            var split = source.replace(/^\s\s*|\s\s*$/g, '').split(/\s+/);
+
                        var utcZone = 'UTC';
            var cur;
+
                        if (offset < 0) {
            var i = 0;
+
                            utcZone += offset;
            var len = timeUnits.length;
+
                        }
            // seconds are optional
+
                        else if (offset > 0) {
            if (split.length < timeUnits.length - 1) {
+
                            utcZone += "+".concat(offset);
                throw new Error('Too few fields');
+
                        }
            }
+
                        date = date.setZone(utcZone);
            if (split.length > timeUnits.length) {
+
                        if (date.invalid) {
                throw new Error('Too many fields');
+
                            throw new Error('ERROR: You specified an invalid UTC offset.');
            }
+
                        }
            for (; i < timeUnits.length; i++) {
+
                    }
                // If the split source string doesn't contain all digits,
+
                    if (this.realDate) {
                // assume defaults for first n missing digits.
+
                        if (luxon.DateTime.local() > date) {
                 // This adds support for 5-digit standard cron syntax
+
                            throw new Error('WARNING: Date in past. Will never be fired.');
                 cur = split[i - (len - split.length)] || CronTime.parseDefaults[i];
+
                        }
                 this._parseField(cur, timeUnits[i], CronTime.constraints[i]);
+
                        return date;
            }
+
                    }
        },
+
                    if (isNaN(i) || i < 0) {
        _parseField: function (field, type, constraints) {
+
                        return this._getNextDateFrom(date);
            var rangePattern = /^(\d+)(?:-(\d+))?(?:\/(\d+))?$/g;
+
                    }
            var typeObj = this[type];
+
                    else {
            var pointer;
+
                        var dates = [];
            var low = constraints[0];
+
                        for (; i > 0; i--) {
            var high = constraints[1];
+
                            date = this._getNextDateFrom(date);
            var fields = field.split(',');
+
                            dates.push(date);
            fields.forEach(function (field) {
+
                        }
                var wildcardIndex = field.indexOf('*');
+
                        return dates;
                if (wildcardIndex !== -1 && wildcardIndex !== 0) {
+
                    }
                    throw new Error('Field (' + field + ') has an invalid wildcard expression');
+
                 },
                }
+
                 getTimeout: function () {
            });
+
                    return Math.max(-1, this.sendAt() - luxon.DateTime.local());
            // * is a shortcut to [lower-upper] range
+
                 },
            field = field.replace(/\*/g, low + '-' + high);
+
                toString: function () {
            // commas separate information, so split based on those
+
                    return this.toJSON().join(' ');
            var allRanges = field.split(',');
+
                },
            for (var i = 0; i < allRanges.length; i++) {
+
                toJSON: function () {
                if (allRanges[i].match(rangePattern)) {
+
                    var self = this;
                    allRanges[i].replace(rangePattern, function ($0, lower, upper, step) {
+
                    return TIME_UNITS.map(function (timeName) {
                        lower = parseInt(lower, 10);
+
                        return self._wcOrAll(timeName);
                        upper = parseInt(upper, 10) || undefined;
+
                    });
                         var wasStepDefined = !isNaN(parseInt(step, 10));
+
                },
                         if (step === '0') {
+
                _getNextDateFrom: function (start, zone) {
                            throw new Error('Field (' + field + ') has a step of zero');
+
                    if (start instanceof Date) {
 +
                        start = luxon.DateTime.fromJSDate(start);
 +
                    }
 +
                    var date = start;
 +
                    var firstDate = start.toMillis();
 +
                    if (zone) {
 +
                        date = date.setZone(zone);
 +
                    }
 +
                    if (!this.realDate) {
 +
                        if (date.millisecond > 0) {
 +
                            date = date.set({ millisecond: 0, second: date.second + 1 });
 +
                        }
 +
                    }
 +
                    if (date.invalid) {
 +
                        throw new Error('ERROR: You specified an invalid date.');
 +
                    }
 +
                    var timeout = Date.now() + 5000;
 +
                    while (true) {
 +
                        var diff = date - start;
 +
                        if (Date.now() > timeout) {
 +
                            throw new Error("Something went wrong. It took over five seconds to find the next execution time for the cron job.\n\t\t\t\t\t\t\tPlease refer to the canonical issue (https://github.com/kelektiv/node-cron/issues/467) and provide the following string if you would like to help debug:\n\t\t\t\t\t\t\tTime Zone: ".concat(zone || '""', " - Cron String: ").concat(this, " - UTC offset: ").concat(date.format('Z'), " - current Date: ").concat(luxon.DateTime.local().toString()));
 +
                        }
 +
                        if (!(date.month - 1 in this.month) &&
 +
                            Object.keys(this.month).length !== 12) {
 +
                            date = date.plus({ months: 1 });
 +
                            date = date.set({ day: 1, hour: 0, minute: 0, second: 0 });
 +
                            continue;
 +
                        }
 +
                        if (!(date.day in this.dayOfMonth) &&
 +
                            Object.keys(this.dayOfMonth).length !== 31 &&
 +
                            !(date.getWeekDay() in this.dayOfWeek &&
 +
                                Object.keys(this.dayOfWeek).length !== 7)) {
 +
                            date = date.plus({ days: 1 });
 +
                            date = date.set({ hour: 0, minute: 0, second: 0 });
 +
                            continue;
 +
                        }
 +
                        if (!(date.getWeekDay() in this.dayOfWeek) &&
 +
                            Object.keys(this.dayOfWeek).length !== 7 &&
 +
                            !(date.day in this.dayOfMonth &&
 +
                                Object.keys(this.dayOfMonth).length !== 31)) {
 +
                            date = date.plus({ days: 1 });
 +
                            date = date.set({ hour: 0, minute: 0, second: 0 });
 +
                            continue;
 +
                        }
 +
                        if (!(date.hour in this.hour) && Object.keys(this.hour).length !== 24) {
 +
                            date = date.set({
 +
                                hour: date.hour === 23 && diff > 86400000 ? 0 : date.hour + 1
 +
                            });
 +
                            date = date.set({ minute: 0, second: 0 });
 +
                            continue;
 +
                        }
 +
                        if (!(date.minute in this.minute) &&
 +
                            Object.keys(this.minute).length !== 60) {
 +
                            date = date.set({
 +
                                minute: date.minute === 59 && diff > 3600000 ? 0 : date.minute + 1
 +
                            });
 +
                            date = date.set({ second: 0 });
 +
                            continue;
 +
                        }
 +
                         if (!(date.second in this.second) &&
 +
                            Object.keys(this.second).length !== 60) {
 +
                            date = date.set({
 +
                                second: date.second === 59 && diff > 60000 ? 0 : date.second + 1
 +
                            });
 +
                            continue;
 +
                        }
 +
                         if (date.toMillis() === firstDate) {
 +
                            date = date.set({ second: date.second + 1 });
 +
                            continue;
 +
                        }
 +
                        break;
 +
                    }
 +
                    return date;
 +
                },
 +
                _wcOrAll: function (type) {
 +
                    if (this._hasAll(type)) {
 +
                        return '*';
 +
                    }
 +
                    var all = [];
 +
                    for (var time in this[type]) {
 +
                        all.push(time);
 +
                    }
 +
                    return all.join(',');
 +
                },
 +
                _hasAll: function (type) {
 +
                    var constraints = CONSTRAINTS[TIME_UNITS.indexOf(type)];
 +
                    for (var i = constraints[0], n = constraints[1]; i < n; i++) {
 +
                        if (!(i in this[type])) {
 +
                            return false;
 
                         }
 
                         }
                        step = parseInt(step, 10) || 1;
+
                    }
                        if (upper && lower > upper) {
+
                    return true;
                            throw new Error('Field (' + field + ') has an invalid range');
+
                },
 +
                _parse: function (source) {
 +
                    source = source.toLowerCase();
 +
                    if (source in PRESETS) {
 +
                        source = PRESETS[source];
 +
                    }
 +
                    source = source.replace(/[a-z]{1,3}/gi, function (alias) {
 +
                        if (alias in ALIASES) {
 +
                            return ALIASES[alias];
 
                         }
 
                         }
                         var outOfRangeError = lower < low ||
+
                         throw new Error("Unknown alias: ".concat(alias));
                            (upper && upper > high) ||
+
                    });
                            (!upper && lower > high);
+
                    var units = source.trim().split(/\s+/);
                         if (outOfRangeError) {
+
                    if (units.length < TIME_UNITS_LEN - 1) {
                             throw new Error('Field (' + field + ') value is out of range');
+
                        throw new Error('Too few fields');
 +
                    }
 +
                    if (units.length > TIME_UNITS_LEN) {
 +
                        throw new Error('Too many fields');
 +
                    }
 +
                    var unitsLen = units.length;
 +
                    for (var i = 0; i < TIME_UNITS_LEN; i++) {
 +
                        var cur = units[i - (TIME_UNITS_LEN - unitsLen)] || PARSE_DEFAULTS[i];
 +
                        this._parseField(cur, TIME_UNITS[i], CONSTRAINTS[i]);
 +
                    }
 +
                },
 +
                _parseField: function (value, type, constraints) {
 +
                    var typeObj = this[type];
 +
                    var pointer;
 +
                    var low = constraints[0];
 +
                    var high = constraints[1];
 +
                    var fields = value.split(',');
 +
                    fields.forEach(function (field) {
 +
                        var wildcardIndex = field.indexOf('*');
 +
                         if (wildcardIndex !== -1 && wildcardIndex !== 0) {
 +
                             throw new Error("Field (".concat(field, ") has an invalid wildcard expression"));
 
                         }
 
                         }
                         // Positive integer higher than constraints[0]
+
                    });
                        lower = Math.min(Math.max(low, ~~Math.abs(lower)), high);
+
                    value = value.replace(RE_WILDCARDS, "".concat(low, "-").concat(high));
                        // Positive integer lower than constraints[1]
+
                    var allRanges = value.split(',');
                        if (upper) {
+
                    for (var i = 0; i < allRanges.length; i++) {
                            upper = Math.min(high, ~~Math.abs(upper));
+
                         if (allRanges[i].match(RE_RANGE)) {
 +
                            allRanges[i].replace(RE_RANGE, function ($0, lower, upper, step) {
 +
                                lower = parseInt(lower, 10);
 +
                                upper = parseInt(upper, 10) || undefined;
 +
                                var wasStepDefined = !isNaN(parseInt(step, 10));
 +
                                if (step === '0') {
 +
                                    throw new Error("Field (".concat(type, ") has a step of zero"));
 +
                                }
 +
                                step = parseInt(step, 10) || 1;
 +
                                if (upper && lower > upper) {
 +
                                    throw new Error("Field (".concat(type, ") has an invalid range"));
 +
                                }
 +
                                var outOfRangeError = lower < low ||
 +
                                    (upper && upper > high) ||
 +
                                    (!upper && lower > high);
 +
                                if (outOfRangeError) {
 +
                                    throw new Error("Field value (".concat(value, ") is out of range"));
 +
                                }
 +
                                lower = Math.min(Math.max(low, ~~Math.abs(lower)), high);
 +
                                if (upper) {
 +
                                    upper = Math.min(high, ~~Math.abs(upper));
 +
                                }
 +
                                else {
 +
                                    upper = wasStepDefined ? high : lower;
 +
                                }
 +
                                pointer = lower;
 +
                                do {
 +
                                    typeObj[pointer] = true;
 +
                                    pointer += step;
 +
                                } while (pointer <= upper);
 +
                            });
 
                         }
 
                         }
 
                         else {
 
                         else {
                             // If step is provided, the default upper range is the highest value
+
                             throw new Error("Field (".concat(type, ") cannot be parsed"));
                            upper = wasStepDefined ? high : lower;
 
 
                         }
 
                         }
                        // Count from the lower barrier to the upper
+
                     }
                        pointer = lower;
 
                        do {
 
                            typeObj[pointer] = true;
 
                            pointer += step;
 
                        } while (pointer <= upper);
 
                     });
 
 
                 }
 
                 }
                else {
+
             };
                    throw new Error('Field (' + field + ') cannot be parsed');
+
             return CT;
                }
 
             }
 
        }
 
    };
 
    function command2function(cmd) {
 
        var command;
 
        var args;
 
        switch (typeof cmd) {
 
             case 'string':
 
                args = cmd.split(' ');
 
                command = args.shift();
 
                cmd = spawn.bind(undefined, command, args);
 
                break;
 
            case 'object':
 
                command = cmd && cmd.command;
 
                if (command) {
 
                    args = cmd.args;
 
                    var options = cmd.options;
 
                    cmd = spawn.bind(undefined, command, args, options);
 
                }
 
                break;
 
        }
 
        return cmd;
 
    }
 
    function CronJob(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
 
        var _cronTime = cronTime;
 
        var argCount = 0;
 
        for (var i = 0; i < arguments.length; i++) {
 
            if (arguments[i] !== undefined) {
 
                argCount++;
 
            }
 
 
         }
 
         }
         if (typeof cronTime !== 'string' && argCount === 1) {
+
         module.exports = CronTime;
            // crontime is an object...
+
    });
            onTick = cronTime.onTick;
+
    var _$_empty_1 = createModuleFactory(function (module, exports) {
            onComplete = cronTime.onComplete;
+
    });
            context = cronTime.context;
+
    var _$cron_2 = {};
            startNow = cronTime.start || cronTime.startNow || cronTime.startJob;
+
    (function (root, factory) {
            timeZone = cronTime.timeZone;
+
        if (typeof define === 'function' && define.amd) {
            runOnInit = cronTime.runOnInit;
+
             define(['luxon'], factory);
            _cronTime = cronTime.cronTime;
 
            utcOffset = cronTime.utcOffset;
 
             unrefTimeout = cronTime.unrefTimeout;
 
 
         }
 
         }
         this.context = context || this;
+
         else if (typeof _$cron_2 === 'object') {
        this._callbacks = [];
+
             _$cron_2 = factory(require(5), _$_empty_1({}));
        this.onComplete = command2function(onComplete);
 
        this.cronTime = new CronTime(_cronTime, timeZone, utcOffset);
 
        this.unrefTimeout = unrefTimeout;
 
        addCallback.call(this, command2function(onTick));
 
        if (runOnInit) {
 
            this.lastExecution = new Date();
 
            fireOnTick.call(this);
 
        }
 
        if (startNow) {
 
            start.call(this);
 
        }
 
        return this;
 
    }
 
    var addCallback = function (callback) {
 
        if (typeof callback === 'function')
 
            this._callbacks.push(callback);
 
    };
 
    CronJob.prototype.addCallback = addCallback;
 
    CronJob.prototype.setTime = function (time) {
 
        if (!(time instanceof CronTime))
 
            throw new Error('time must be an instance of CronTime.');
 
        this.stop();
 
        this.cronTime = time;
 
    };
 
    CronJob.prototype.nextDate = function () {
 
        return this.cronTime.sendAt();
 
    };
 
    var fireOnTick = function () {
 
        for (var i = this._callbacks.length - 1; i >= 0; i--)
 
            this._callbacks[i].call(this.context, this.onComplete);
 
    };
 
    CronJob.prototype.fireOnTick = fireOnTick;
 
    CronJob.prototype.nextDates = function (i) {
 
        return this.cronTime.sendAt(i);
 
    };
 
    var start = function () {
 
        if (this.running)
 
            return;
 
        var MAXDELAY = 2147483647; // The maximum number of milliseconds setTimeout will wait.
 
        var self = this;
 
        var timeout = this.cronTime.getTimeout();
 
        var remaining = 0;
 
        var startTime;
 
        if (this.cronTime.realDate)
 
            this.runOnce = true;
 
        function _setTimeout(timeout) {
 
            startTime = Date.now();
 
            self._timeout = setTimeout(callbackWrapper, timeout);
 
            if (self.unrefTimeout && typeof self._timeout.unref === 'function') {
 
                self._timeout.unref();
 
             }
 
        }
 
        // The callback wrapper checks if it needs to sleep another period or not
 
        // and does the real callback logic when it's time.
 
        function callbackWrapper() {
 
            var diff = startTime + timeout - Date.now();
 
            if (diff > 0) {
 
                var newTimeout = self.cronTime.getTimeout();
 
                if (newTimeout > diff) {
 
                    newTimeout = diff;
 
                }
 
                remaining += newTimeout;
 
            }
 
            // If there is sleep time remaining, calculate how long and go to sleep
 
            // again. This processing might make us miss the deadline by a few ms
 
            // times the number of sleep sessions. Given a MAXDELAY of almost a
 
            // month, this should be no issue.
 
            self.lastExecution = new Date();
 
            if (remaining) {
 
                if (remaining > MAXDELAY) {
 
                    remaining -= MAXDELAY;
 
                    timeout = MAXDELAY;
 
                }
 
                else {
 
                    timeout = remaining;
 
                    remaining = 0;
 
                }
 
                _setTimeout(timeout);
 
            }
 
            else {
 
                // We have arrived at the correct point in time.
 
                self.running = false;
 
                // start before calling back so the callbacks have the ability to stop the cron job
 
                if (!self.runOnce)
 
                    self.start();
 
                self.fireOnTick();
 
            }
 
        }
 
        if (timeout >= 0) {
 
            this.running = true;
 
            // Don't try to sleep more than MAXDELAY ms at a time.
 
            if (timeout > MAXDELAY) {
 
                remaining = timeout - MAXDELAY;
 
                timeout = MAXDELAY;
 
            }
 
            _setTimeout(timeout);
 
 
         }
 
         }
 
         else {
 
         else {
             this.stop();
+
             root.Cron = factory(root.luxon);
 
         }
 
         }
     };
+
     })(this, function (luxon, childProcess) {
    CronJob.prototype.start = start;
+
         var exports = {};
    CronJob.prototype.lastDate = function () {
+
        var spawn = childProcess && childProcess.spawn;
         return this.lastExecution;
+
        var CronTime = _$CronTime_4({})(luxon);
    };
+
         var CronJob = _$CronJob_3({})(CronTime, spawn);
    /**
+
         luxon.DateTime.prototype.getWeekDay = function () {
    * Stop the cronjob.
+
            return this.weekday === 7 ? 0 : this.weekday;
    */
+
        };
    CronJob.prototype.stop = function () {
+
        exports.job = function (cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
         if (this._timeout)
+
            return new CronJob(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout);
            clearTimeout(this._timeout);
+
        };
         this.running = false;
+
        exports.time = function (cronTime, timeZone) { return new CronTime(cronTime, timeZone); };
        if (typeof this.onComplete === 'function')
+
        exports.sendAt = function (cronTime) { return exports.time(cronTime).sendAt(); };
            this.onComplete();
+
        exports.timeout = function (cronTime) { return exports.time(cronTime).getTimeout(); };
    };
+
        exports.CronJob = CronJob;
    exports.job = function (cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
+
        exports.CronTime = CronTime;
        return new CronJob(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout);
+
        return exports;
    };
+
     });
    exports.time = function (cronTime, timeZone) {
+
    var _$input_6 = {};
        return new CronTime(cronTime, timeZone);
+
    (function (global) {
    };
+
        (function () {
    exports.sendAt = function (cronTime) {
+
            "use strict";
        return exports.time(cronTime).sendAt();
+
            var _cron = _interopRequireDefault(_$cron_2);
    };
+
            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    exports.timeout = function (cronTime) {
+
            global["Cron"] = _cron["default"];
        return exports.time(cronTime).getTimeout();
+
        }).call(this);
    };
+
    }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
    exports.CronJob = CronJob;
+
}());
    exports.CronTime = CronTime;
+
 
     return exports;
+
/* </pre> */
});
 

Latest revision as of 18:17, 5 September 2022

/* <pre> */
/**
 * -------------------------------------------------------------------------
 * !!! DON'T MODIFY THIS PAGE MANUALLY, YOUR CHANGES WILL BE OVERWRITTEN !!!
 * -------------------------------------------------------------------------
 */
var _addText = '{{GHIACode|page=GHIA:MoegirlPediaInterfaceCodes/blob/master/src/gadgets/cron/MediaWiki:Gadget-cron.js|user=[[U:AnnAngela]]|longId=3820b56ff2ac6eb2e6bb95dd82dd71db679b0c81|shortId=3820b56|message=auto: auto browserify - commit from GitHub Actions}}';

"use strict";
var require = function () { return window.luxon; };
(function () {
    var createModuleFactory = function createModuleFactory(t) { var e; return function (r) { return e || t(e = { exports: {}, parent: r }, e.exports), e.exports; }; };
    var _$CronJob_3 = createModuleFactory(function (module, exports) {
        function CronJob(CronTime, spawn) {
            function fnWrap(cmd) {
                var command;
                var args;
                switch (typeof cmd) {
                    case 'string':
                        args = cmd.split(' ');
                        command = args.shift();
                        return spawn.bind(undefined, command, args);
                    case 'object':
                        command = cmd && cmd.command;
                        if (command) {
                            args = cmd.args;
                            var options = cmd.options;
                            return spawn.bind(undefined, command, args, options);
                        }
                        break;
                }
                return cmd;
            }
            function CJ(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
                var _cronTime = cronTime;
                var argCount = 0;
                for (var i = 0; i < arguments.length; i++) {
                    if (arguments[i] !== undefined) {
                        argCount++;
                    }
                }
                if (typeof cronTime !== 'string' && argCount === 1) {
                    onTick = cronTime.onTick;
                    onComplete = cronTime.onComplete;
                    context = cronTime.context;
                    startNow = cronTime.start || cronTime.startNow || cronTime.startJob;
                    timeZone = cronTime.timeZone;
                    runOnInit = cronTime.runOnInit;
                    _cronTime = cronTime.cronTime;
                    utcOffset = cronTime.utcOffset;
                    unrefTimeout = cronTime.unrefTimeout;
                }
                this.context = context || this;
                this._callbacks = [];
                this.onComplete = fnWrap(onComplete);
                this.cronTime = new CronTime(_cronTime, timeZone, utcOffset);
                this.unrefTimeout = unrefTimeout;
                addCallback.call(this, fnWrap(onTick));
                if (runOnInit) {
                    this.lastExecution = new Date();
                    fireOnTick.call(this);
                }
                if (startNow) {
                    start.call(this);
                }
                return this;
            }
            var addCallback = function (callback) {
                if (typeof callback === 'function') {
                    this._callbacks.push(callback);
                }
            };
            CJ.prototype.addCallback = addCallback;
            CJ.prototype.setTime = function (time) {
                if (typeof time !== 'object') {
                    throw new Error('time must be an instance of CronTime.');
                }
                this.stop();
                this.cronTime = time;
                this.start();
            };
            CJ.prototype.nextDate = function () {
                return this.cronTime.sendAt();
            };
            var fireOnTick = function () {
                for (var i = this._callbacks.length - 1; i >= 0; i--) {
                    this._callbacks[i].call(this.context, this.onComplete);
                }
            };
            CJ.prototype.fireOnTick = fireOnTick;
            CJ.prototype.nextDates = function (i) {
                return this.cronTime.sendAt(i);
            };
            var start = function () {
                if (this.running) {
                    return;
                }
                var MAXDELAY = 2147483647;
                var self = this;
                var timeout = this.cronTime.getTimeout();
                var remaining = 0;
                var startTime;
                if (this.cronTime.realDate) {
                    this.runOnce = true;
                }
                function _setTimeout(timeout) {
                    startTime = Date.now();
                    self._timeout = setTimeout(callbackWrapper, timeout);
                    if (self.unrefTimeout && typeof self._timeout.unref === 'function') {
                        self._timeout.unref();
                    }
                }
                function callbackWrapper() {
                    var diff = startTime + timeout - Date.now();
                    if (diff > 0) {
                        var newTimeout = self.cronTime.getTimeout();
                        if (newTimeout > diff) {
                            newTimeout = diff;
                        }
                        remaining += newTimeout;
                    }
                    self.lastExecution = new Date();
                    if (remaining) {
                        if (remaining > MAXDELAY) {
                            remaining -= MAXDELAY;
                            timeout = MAXDELAY;
                        }
                        else {
                            timeout = remaining;
                            remaining = 0;
                        }
                        _setTimeout(timeout);
                    }
                    else {
                        self.running = false;
                        if (!self.runOnce) {
                            self.start();
                        }
                        self.fireOnTick();
                    }
                }
                if (timeout >= 0) {
                    this.running = true;
                    if (timeout > MAXDELAY) {
                        remaining = timeout - MAXDELAY;
                        timeout = MAXDELAY;
                    }
                    _setTimeout(timeout);
                }
                else {
                    this.stop();
                }
            };
            CJ.prototype.start = start;
            CJ.prototype.lastDate = function () {
                return this.lastExecution;
            };
            CJ.prototype.stop = function () {
                if (this._timeout)
                    clearTimeout(this._timeout);
                this.running = false;
                if (typeof this.onComplete === 'function') {
                    this.onComplete();
                }
            };
            return CJ;
        }
        module.exports = CronJob;
    });
    var _$CronTime_4 = createModuleFactory(function (module, exports) {
        var CONSTRAINTS = [
            [0, 59],
            [0, 59],
            [0, 23],
            [1, 31],
            [0, 11],
            [0, 6]
        ];
        var MONTH_CONSTRAINTS = [
            31,
            29,
            31,
            30,
            31,
            30,
            31,
            31,
            30,
            31,
            30,
            31
        ];
        var PARSE_DEFAULTS = ['0', '*', '*', '*', '*', '*'];
        var ALIASES = {
            jan: 0,
            feb: 1,
            mar: 2,
            apr: 3,
            may: 4,
            jun: 5,
            jul: 6,
            aug: 7,
            sep: 8,
            oct: 9,
            nov: 10,
            dec: 11,
            sun: 0,
            mon: 1,
            tue: 2,
            wed: 3,
            thu: 4,
            fri: 5,
            sat: 6
        };
        var TIME_UNITS = [
            'second',
            'minute',
            'hour',
            'dayOfMonth',
            'month',
            'dayOfWeek'
        ];
        var TIME_UNITS_LEN = TIME_UNITS.length;
        var PRESETS = {
            '@yearly': '0 0 0 1 0 *',
            '@monthly': '0 0 0 1 * *',
            '@weekly': '0 0 0 * * 0',
            '@daily': '0 0 0 * * *',
            '@hourly': '0 0 * * * *',
            '@minutely': '0 * * * * *',
            '@secondly': '* * * * * *',
            '@weekdays': '0 0 0 * * 1-5',
            '@weekends': '0 0 0 * * 0,6'
        };
        var RE_WILDCARDS = /\*/g;
        var RE_RANGE = /^(\d+)(?:-(\d+))?(?:\/(\d+))?$/g;
        function CronTime(luxon) {
            function CT(source, zone, utcOffset) {
                this.source = source;
                if (zone) {
                    var dt = luxon.DateTime.fromObject({ zone: zone });
                    if (dt.invalid) {
                        throw new Error('Invalid timezone.');
                    }
                    this.zone = zone;
                }
                if (typeof utcOffset !== 'undefined') {
                    this.utcOffset = utcOffset;
                }
                var that = this;
                TIME_UNITS.map(function (timeUnit) {
                    that[timeUnit] = {};
                });
                if (this.source instanceof Date || this.source instanceof luxon.DateTime) {
                    if (this.source instanceof Date) {
                        this.source = luxon.DateTime.fromJSDate(this.source);
                    }
                    this.realDate = true;
                }
                else {
                    this._parse(this.source);
                    this._verifyParse();
                }
            }
            CT.prototype = {
                _verifyParse: function () {
                    var months = Object.keys(this.month);
                    var dom = Object.keys(this.dayOfMonth);
                    var ok = false;
                    var lastWrongMonth = NaN;
                    for (var i = 0; i < months.length; i++) {
                        var m = months[i];
                        var con = MONTH_CONSTRAINTS[parseInt(m, 10)];
                        for (var j = 0; j < dom.length; j++) {
                            var day = dom[j];
                            if (day <= con) {
                                ok = true;
                            }
                        }
                        if (!ok) {
                            lastWrongMonth = m;
                            console.warn("Month '".concat(m, "' is limited to '").concat(con, "' days."));
                        }
                    }
                    if (!ok) {
                        var notOkCon = MONTH_CONSTRAINTS[parseInt(lastWrongMonth, 10)];
                        for (var k = 0; k < dom.length; k++) {
                            var notOkDay = dom[k];
                            if (notOkDay > notOkCon) {
                                delete this.dayOfMonth[notOkDay];
                                var fixedDay = Number(notOkDay) % notOkCon;
                                this.dayOfMonth[fixedDay] = true;
                            }
                        }
                    }
                },
                sendAt: function (i) {
                    var date = this.realDate ? this.source : luxon.DateTime.local();
                    if (this.zone) {
                        date = date.setZone(this.zone);
                    }
                    if (typeof this.utcOffset !== 'undefined') {
                        var offset = this.utcOffset >= 60 || this.utcOffset <= -60
                            ? this.utcOffset / 60
                            : this.utcOffset;
                        offset = parseInt(offset);
                        var utcZone = 'UTC';
                        if (offset < 0) {
                            utcZone += offset;
                        }
                        else if (offset > 0) {
                            utcZone += "+".concat(offset);
                        }
                        date = date.setZone(utcZone);
                        if (date.invalid) {
                            throw new Error('ERROR: You specified an invalid UTC offset.');
                        }
                    }
                    if (this.realDate) {
                        if (luxon.DateTime.local() > date) {
                            throw new Error('WARNING: Date in past. Will never be fired.');
                        }
                        return date;
                    }
                    if (isNaN(i) || i < 0) {
                        return this._getNextDateFrom(date);
                    }
                    else {
                        var dates = [];
                        for (; i > 0; i--) {
                            date = this._getNextDateFrom(date);
                            dates.push(date);
                        }
                        return dates;
                    }
                },
                getTimeout: function () {
                    return Math.max(-1, this.sendAt() - luxon.DateTime.local());
                },
                toString: function () {
                    return this.toJSON().join(' ');
                },
                toJSON: function () {
                    var self = this;
                    return TIME_UNITS.map(function (timeName) {
                        return self._wcOrAll(timeName);
                    });
                },
                _getNextDateFrom: function (start, zone) {
                    if (start instanceof Date) {
                        start = luxon.DateTime.fromJSDate(start);
                    }
                    var date = start;
                    var firstDate = start.toMillis();
                    if (zone) {
                        date = date.setZone(zone);
                    }
                    if (!this.realDate) {
                        if (date.millisecond > 0) {
                            date = date.set({ millisecond: 0, second: date.second + 1 });
                        }
                    }
                    if (date.invalid) {
                        throw new Error('ERROR: You specified an invalid date.');
                    }
                    var timeout = Date.now() + 5000;
                    while (true) {
                        var diff = date - start;
                        if (Date.now() > timeout) {
                            throw new Error("Something went wrong. It took over five seconds to find the next execution time for the cron job.\n\t\t\t\t\t\t\tPlease refer to the canonical issue (https://github.com/kelektiv/node-cron/issues/467) and provide the following string if you would like to help debug:\n\t\t\t\t\t\t\tTime Zone: ".concat(zone || '""', " - Cron String: ").concat(this, " - UTC offset: ").concat(date.format('Z'), " - current Date: ").concat(luxon.DateTime.local().toString()));
                        }
                        if (!(date.month - 1 in this.month) &&
                            Object.keys(this.month).length !== 12) {
                            date = date.plus({ months: 1 });
                            date = date.set({ day: 1, hour: 0, minute: 0, second: 0 });
                            continue;
                        }
                        if (!(date.day in this.dayOfMonth) &&
                            Object.keys(this.dayOfMonth).length !== 31 &&
                            !(date.getWeekDay() in this.dayOfWeek &&
                                Object.keys(this.dayOfWeek).length !== 7)) {
                            date = date.plus({ days: 1 });
                            date = date.set({ hour: 0, minute: 0, second: 0 });
                            continue;
                        }
                        if (!(date.getWeekDay() in this.dayOfWeek) &&
                            Object.keys(this.dayOfWeek).length !== 7 &&
                            !(date.day in this.dayOfMonth &&
                                Object.keys(this.dayOfMonth).length !== 31)) {
                            date = date.plus({ days: 1 });
                            date = date.set({ hour: 0, minute: 0, second: 0 });
                            continue;
                        }
                        if (!(date.hour in this.hour) && Object.keys(this.hour).length !== 24) {
                            date = date.set({
                                hour: date.hour === 23 && diff > 86400000 ? 0 : date.hour + 1
                            });
                            date = date.set({ minute: 0, second: 0 });
                            continue;
                        }
                        if (!(date.minute in this.minute) &&
                            Object.keys(this.minute).length !== 60) {
                            date = date.set({
                                minute: date.minute === 59 && diff > 3600000 ? 0 : date.minute + 1
                            });
                            date = date.set({ second: 0 });
                            continue;
                        }
                        if (!(date.second in this.second) &&
                            Object.keys(this.second).length !== 60) {
                            date = date.set({
                                second: date.second === 59 && diff > 60000 ? 0 : date.second + 1
                            });
                            continue;
                        }
                        if (date.toMillis() === firstDate) {
                            date = date.set({ second: date.second + 1 });
                            continue;
                        }
                        break;
                    }
                    return date;
                },
                _wcOrAll: function (type) {
                    if (this._hasAll(type)) {
                        return '*';
                    }
                    var all = [];
                    for (var time in this[type]) {
                        all.push(time);
                    }
                    return all.join(',');
                },
                _hasAll: function (type) {
                    var constraints = CONSTRAINTS[TIME_UNITS.indexOf(type)];
                    for (var i = constraints[0], n = constraints[1]; i < n; i++) {
                        if (!(i in this[type])) {
                            return false;
                        }
                    }
                    return true;
                },
                _parse: function (source) {
                    source = source.toLowerCase();
                    if (source in PRESETS) {
                        source = PRESETS[source];
                    }
                    source = source.replace(/[a-z]{1,3}/gi, function (alias) {
                        if (alias in ALIASES) {
                            return ALIASES[alias];
                        }
                        throw new Error("Unknown alias: ".concat(alias));
                    });
                    var units = source.trim().split(/\s+/);
                    if (units.length < TIME_UNITS_LEN - 1) {
                        throw new Error('Too few fields');
                    }
                    if (units.length > TIME_UNITS_LEN) {
                        throw new Error('Too many fields');
                    }
                    var unitsLen = units.length;
                    for (var i = 0; i < TIME_UNITS_LEN; i++) {
                        var cur = units[i - (TIME_UNITS_LEN - unitsLen)] || PARSE_DEFAULTS[i];
                        this._parseField(cur, TIME_UNITS[i], CONSTRAINTS[i]);
                    }
                },
                _parseField: function (value, type, constraints) {
                    var typeObj = this[type];
                    var pointer;
                    var low = constraints[0];
                    var high = constraints[1];
                    var fields = value.split(',');
                    fields.forEach(function (field) {
                        var wildcardIndex = field.indexOf('*');
                        if (wildcardIndex !== -1 && wildcardIndex !== 0) {
                            throw new Error("Field (".concat(field, ") has an invalid wildcard expression"));
                        }
                    });
                    value = value.replace(RE_WILDCARDS, "".concat(low, "-").concat(high));
                    var allRanges = value.split(',');
                    for (var i = 0; i < allRanges.length; i++) {
                        if (allRanges[i].match(RE_RANGE)) {
                            allRanges[i].replace(RE_RANGE, function ($0, lower, upper, step) {
                                lower = parseInt(lower, 10);
                                upper = parseInt(upper, 10) || undefined;
                                var wasStepDefined = !isNaN(parseInt(step, 10));
                                if (step === '0') {
                                    throw new Error("Field (".concat(type, ") has a step of zero"));
                                }
                                step = parseInt(step, 10) || 1;
                                if (upper && lower > upper) {
                                    throw new Error("Field (".concat(type, ") has an invalid range"));
                                }
                                var outOfRangeError = lower < low ||
                                    (upper && upper > high) ||
                                    (!upper && lower > high);
                                if (outOfRangeError) {
                                    throw new Error("Field value (".concat(value, ") is out of range"));
                                }
                                lower = Math.min(Math.max(low, ~~Math.abs(lower)), high);
                                if (upper) {
                                    upper = Math.min(high, ~~Math.abs(upper));
                                }
                                else {
                                    upper = wasStepDefined ? high : lower;
                                }
                                pointer = lower;
                                do {
                                    typeObj[pointer] = true;
                                    pointer += step;
                                } while (pointer <= upper);
                            });
                        }
                        else {
                            throw new Error("Field (".concat(type, ") cannot be parsed"));
                        }
                    }
                }
            };
            return CT;
        }
        module.exports = CronTime;
    });
    var _$_empty_1 = createModuleFactory(function (module, exports) {
    });
    var _$cron_2 = {};
    (function (root, factory) {
        if (typeof define === 'function' && define.amd) {
            define(['luxon'], factory);
        }
        else if (typeof _$cron_2 === 'object') {
            _$cron_2 = factory(require(5), _$_empty_1({}));
        }
        else {
            root.Cron = factory(root.luxon);
        }
    })(this, function (luxon, childProcess) {
        var exports = {};
        var spawn = childProcess && childProcess.spawn;
        var CronTime = _$CronTime_4({})(luxon);
        var CronJob = _$CronJob_3({})(CronTime, spawn);
        luxon.DateTime.prototype.getWeekDay = function () {
            return this.weekday === 7 ? 0 : this.weekday;
        };
        exports.job = function (cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout) {
            return new CronJob(cronTime, onTick, onComplete, startNow, timeZone, context, runOnInit, utcOffset, unrefTimeout);
        };
        exports.time = function (cronTime, timeZone) { return new CronTime(cronTime, timeZone); };
        exports.sendAt = function (cronTime) { return exports.time(cronTime).sendAt(); };
        exports.timeout = function (cronTime) { return exports.time(cronTime).getTimeout(); };
        exports.CronJob = CronJob;
        exports.CronTime = CronTime;
        return exports;
    });
    var _$input_6 = {};
    (function (global) {
        (function () {
            "use strict";
            var _cron = _interopRequireDefault(_$cron_2);
            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
            global["Cron"] = _cron["default"];
        }).call(this);
    }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
}());

/* </pre> */