croner 6.0.0-dev.0 → 6.0.0-dev.1

package/dist/croner.cjs

@@ -0,0 +1,1653 @@
+'use strict';
+
+/* ------------------------------------------------------------------------------------
+
+	minitz - MIT License - Hexagon <hexagon@56k.guru>
+
+	Version 4.0.4
+	
+	------------------------------------------------------------------------------------
+
+	License:
+
+	Copyright (c) 2022 Hexagon <hexagon@56k.guru>
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+
+  ------------------------------------------------------------------------------------  */
+
+/**
+ * @typedef {Object} TimePoint
+ * @property {Number} y - 1970--
+ * @property {Number} m - 1-12
+ * @property {Number} d - 1-31
+ * @property {Number} h - 0-24
+ * @property {Number} i - 0-60 Minute
+ * @property {Number} s - 0-60
+ * @property {string} tz - Time zone in IANA database format 'Europe/Stockholm'
+ */
+
+/**
+ * Converts a date/time from a specific timezone to a normal date object using the system local time
+ *
+ * Shortcut for minitz.fromTZ(minitz.tp(...));
+ *
+ * @constructor
+ *
+ * @param {Number} y - 1970--
+ * @param {Number} m - 1-12
+ * @param {Number} d - 1-31
+ * @param {Number} h - 0-24
+ * @param {Number} i - 0-60 Minute
+ * @param {Number} s - 0-60
+ * @param {string} tz - Time zone in IANA database format 'Europe/Stockholm'
+ * @param {boolean} [throwOnInvalid] - Default is to return the adjusted time if the call happens during a Daylight-Saving-Time switch.
+ *										E.g. Value "01:01:01" is returned if input time is 00:01:01 while one hour got actually
+ *										skipped, going from 23:59:59 to 01:00:00. Setting this flag makes the library throw an exception instead.
+ * @returns {date} - Normal date object with correct UTC and system local time
+ *
+ */
+ function minitz(y, m, d, h, i, s, tz, throwOnInvalid) {
+	return minitz.fromTZ(minitz.tp(y, m, d, h, i, s, tz), throwOnInvalid);
+}
+
+/**
+ * Converts a date/time from a specific timezone to a normal date object using the system local time
+ * 
+ * @public
+ * @static
+ * 
+ * @param {string} localTimeStr - ISO8601 formatted local time string, non UTC
+ * @param {string} tz - Time zone in IANA database format 'Europe/Stockholm'
+ * @param {boolean} [throwOnInvalid] - Default is to return the adjusted time if the call happens during a Daylight-Saving-Time switch.
+ *										E.g. Value "01:01:01" is returned if input time is 00:01:01 while one hour got actually
+ *										skipped, going from 23:59:59 to 01:00:00. Setting this flag makes the library throw an exception instead.
+ * @return {date} - Normal date object
+ * 
+ */
+minitz.fromTZISO = (localTimeStr, tz, throwOnInvalid) => {
+	return minitz.fromTZ(parseISOLocal(localTimeStr, tz), throwOnInvalid);
+};
+
+/**
+ * Converts a date/time from a specific timezone to a normal date object using the system local time
+ *
+ * @public
+ * @static
+ *
+ * @param {TimePoint} tp - Object with specified timezone
+ * @param {boolean} [throwOnInvalid] - Default is to return the adjusted time if the call happens during a Daylight-Saving-Time switch.
+ *										E.g. Value "01:01:01" is returned if input time is 00:01:01 while one hour got actually
+ *										skipped, going from 23:59:59 to 01:00:00. Setting this flag makes the library throw an exception instead.
+ * @returns {date} - Normal date object
+ */
+minitz.fromTZ = function(tp, throwOnInvalid) {
+
+	const
+
+		// Construct a fake Date object with UTC date/time set to local date/time in source timezone
+		inDate = new Date(Date.UTC(
+			tp.y,
+			tp.m - 1,
+			tp.d,
+			tp.h,
+			tp.i,
+			tp.s
+		)),
+
+		// Get offset between UTC and source timezone
+		offset = getTimezoneOffset(tp.tz, inDate),
+
+		// Remove offset from inDate to hopefully get a true date object
+		dateGuess = new Date(inDate.getTime() - offset),
+
+		// Get offset between UTC and guessed time in target timezone
+		dateOffsGuess = getTimezoneOffset(tp.tz, dateGuess);
+
+	// If offset between guessed true date object and UTC matches initial calculation, the guess
+	// was spot on
+	if ((dateOffsGuess - offset) === 0) {
+		return dateGuess;
+	} else {
+		// Not quite there yet, make a second try on guessing the local time, adjust by the offset indicated by the previous guess
+		// Try recreating input time again
+		// Then calculate and check the offset again
+		const
+			dateGuess2 = new Date(inDate.getTime() - dateOffsGuess),
+			dateOffsGuess2 = getTimezoneOffset(tp.tz, dateGuess2);
+		if ((dateOffsGuess2 - dateOffsGuess) === 0) {
+			// All good, return local time
+			return dateGuess2;
+		} else if(!throwOnInvalid && (dateOffsGuess2 - dateOffsGuess) > 0) {
+			// We're most probably dealing with a DST transition where we should use the offset of the second guess
+			return dateGuess2; 
+		} else if (!throwOnInvalid) {
+			// We're most probably dealing with a DST transition where we should use the offset of the initial guess
+			return dateGuess;
+		} else {
+			// Input time is invalid, and the library is instructed to throw, so let's do it
+			throw new Error("Invalid date passed to fromTZ()");
+		}
+	}
+};
+
+/**
+ * Converts a date to a specific time zone and returns an object containing year, month,
+ * day, hour, (...) and timezone used for the conversion
+ *
+ * **Please note**: If you just want to _display_ date/time in another
+ * time zone, use vanilla JS. See the example below.
+ *
+ * @public
+ * @static
+ *
+ * @param {d} date - Input date
+ * @param {string} [tzStr] - Timezone string in Europe/Stockholm format
+ *
+ * @returns {TimePoint}
+ *
+ * @example <caption>Example using minitz:</caption>
+ * let normalDate = new Date(); // d is a normal Date instance, with local timezone and correct utc representation
+ *
+ * tzDate = minitz.toTZ(d, 'America/New_York');
+ *
+ * // Will result in the following object:
+ * // {
+ * //  y: 2022,
+ * //  m: 9,
+ * //  d: 28,
+ * //  h: 13,
+ * //  i: 28,
+ * //  s: 28,
+ * //  tz: "America/New_York"
+ * // }
+ *
+ * @example <caption>Example using vanilla js:</caption>
+ * console.log(
+ *	// Display current time in America/New_York, using sv-SE locale
+ *	new Date().toLocaleTimeString("sv-SE", { timeZone: "America/New_York" }),
+ * );
+ *
+ */
+minitz.toTZ = function (d, tzStr) {
+	const td = new Date(d.toLocaleString("sv-SE", {timeZone: tzStr}));
+	return {
+		y: td.getFullYear(),
+		m: td.getMonth() + 1,
+		d: td.getDate(),
+		h: td.getHours(),
+		i: td.getMinutes(),
+		s: td.getSeconds(),
+		tz: tzStr
+	};
+};
+
+/**
+ * Convenience function which returns a TimePoint object for later use in fromTZ
+ *
+ * @public
+ * @static
+ *
+ * @param {Number} y - 1970--
+ * @param {Number} m - 1-12
+ * @param {Number} d - 1-31
+ * @param {Number} h - 0-24
+ * @param {Number} i - 0-60 Minute
+ * @param {Number} s - 0-60
+ * @param {string} tz - Time zone in format 'Europe/Stockholm'
+ *
+ * @returns {TimePoint}
+ *
+*/
+minitz.tp = (y,m,d,h,i,s,tz) => { return { y, m, d, h, i, s, tz: tz }; };
+
+/**
+ * Helper function that returns the current UTC offset (in ms) for a specific timezone at a specific point in time
+ *
+ * @private
+ *
+ * @param {timeZone} string - Target time zone in IANA database format 'Europe/Stockholm'
+ * @param {date} [date] - Point in time to use as base for offset calculation
+ *
+ * @returns {number} - Offset in ms between UTC and timeZone
+ */
+function getTimezoneOffset(timeZone, date = new Date()) {
+
+	// Get timezone 
+	const tz = date.toLocaleString("en", {timeZone, timeStyle: "long"}).split(" ").slice(-1)[0];
+
+	// Extract time in en-US format
+	// - replace narrow no break space with regular space to compensate for bug in Node.js 19.1
+	const dateString = date.toLocaleString("en-US").replace(/[\u202f]/," ");
+
+	// Check ms offset between GMT and extracted timezone
+	return Date.parse(`${dateString} GMT`) - Date.parse(`${dateString} ${tz}`);
+}
+
+
+/**
+ * Helper function that takes a ISO8001 local date time string and creates a Date object.
+ * Throws on failure. Throws on invalid date or time.
+ * 
+ * @private
+ *
+ * @param {string} dtStr - an ISO 8601 format date and time string
+ *					  with all components, e.g. 2015-11-24T19:40:00
+ * @returns {TimePoint} - TimePoint instance from parsing the string
+ */
+function parseISOLocal(dtStr, tz) {
+
+	// Parse date using built in Date.parse
+	const pd = new Date(Date.parse(dtStr));
+
+	// Check for completeness
+	if (isNaN(pd)) {
+		throw new Error("minitz: Invalid ISO8601 passed to parser.");
+	}
+	
+	// If 
+	//   * date/time is specified in UTC (Z-flag included)
+	//   * or UTC offset is specified (+ or - included after character 9 (20200101 or 2020-01-0))
+	// Return time in utc, else return local time and include timezone identifier
+	const stringEnd = dtStr.substring(9);
+	if (dtStr.includes("Z") || stringEnd.includes("-") || stringEnd.includes("+")) {
+		return minitz.tp(pd.getUTCFullYear(), pd.getUTCMonth()+1, pd.getUTCDate(),pd.getUTCHours(), pd.getUTCMinutes(),pd.getUTCSeconds(), "Etc/UTC");
+	} else {
+		return minitz.tp(pd.getFullYear(), pd.getMonth()+1, pd.getDate(),pd.getHours(), pd.getMinutes(),pd.getSeconds(), tz);
+	}
+	// Treat date as local time, in target timezone
+
+}
+
+minitz.minitz = minitz;
+
+/**
+ * @callback CatchCallbackFn
+ * @param {unknown} e
+ * @param {Cron} job
+ */
+
+/**
+ * @callback ProtectCallbackFn
+ * @param {Cron} job
+ */
+
+/**
+ * @typedef {Object} CronOptions - Cron scheduler options
+ * @property {string} [name] - Name of a job
+ * @property {boolean} [paused] - Job is paused
+ * @property {boolean} [kill] - Job is about to be killed or killed
+ * @property {boolean | CatchCallbackFn} [catch] - Continue exection even if a unhandled error is thrown by triggered function
+ * 										  - If set to a function, execute function on catching the error.
+ * @property {boolean} [unref] - Abort job instantly if nothing else keeps the event loop running.
+ * @property {number} [maxRuns] - Maximum nuber of executions
+ * @property {number} [interval] - Minimum interval between executions, in seconds
+ * @property {boolean | ProtectCallbackFn} [protect] - Skip current run if job is already running
+ * @property {string | Date} [startAt] - When to start running
+ * @property {string | Date} [stopAt] - When to stop running
+ * @property {string} [timezone] - Time zone in Europe/Stockholm format
+ * @property {number} [utcOffset] - Offset from UTC in minutes
+ * @property {boolean} [legacyMode] - Combine day-of-month and day-of-week using true = OR, false = AND. Default is true = OR.
+ * @property {?} [context] - Used to pass any object to scheduled function
+ */
+
+/**
+ * Internal function that validates options, and sets defaults
+ * @private
+ * 
+ * @param {CronOptions} options 
+ * @returns {CronOptions}
+ */
+function CronOptions(options) {
+	
+	// If no options are passed, create empty object
+	if (options === void 0) {
+		options = {};
+	}
+	
+	// Don't duplicate the 'name' property
+	delete options.name;
+
+	// Keep options, or set defaults
+	options.legacyMode = (options.legacyMode === void 0) ? true : options.legacyMode;
+	options.paused = (options.paused === void 0) ? false : options.paused;
+	options.maxRuns = (options.maxRuns === void 0) ? Infinity : options.maxRuns;
+	options.catch = (options.catch === void 0) ? false : options.catch;
+	options.interval = (options.interval === void 0) ? 0 : parseInt(options.interval, 10);
+	options.utcOffset = (options.utcOffset === void 0) ? void 0 : parseInt(options.utcOffset, 10);
+	options.unref = (options.unref === void 0) ? false : options.unref;
+	
+	// startAt is set, validate it
+	if( options.startAt ) {
+		options.startAt = new CronDate(options.startAt, options.timezone);
+	} 
+	if( options.stopAt ) {
+		options.stopAt = new CronDate(options.stopAt, options.timezone);
+	}
+
+	// Validate interval
+	if (options.interval !== null) {
+		if (isNaN(options.interval)) {
+			throw new Error("CronOptions: Supplied value for interval is not a number");
+		} else if (options.interval < 0) {
+			throw new Error("CronOptions: Supplied value for interval can not be negative");
+		}
+	}
+
+	// Validate utcOffset
+	if (options.utcOffset !== void 0) {
+		
+		// Limit range for utcOffset
+		if (isNaN(options.utcOffset)) {
+			throw new Error("CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.");
+		} else if (options.utcOffset < -870 || options.utcOffset > 870 ) {
+			throw new Error("CronOptions: utcOffset out of bounds.");
+		}
+		
+		// Do not allow both timezone and utcOffset
+		if (options.utcOffset !== void 0 && options.timezone) {
+			throw new Error("CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.");
+		}
+
+	}
+
+	// Unref should be true, false or undefined
+	if (options.unref !== true && options.unref !== false) {
+		throw new Error("CronOptions: Unref should be either true, false or undefined(false).");
+	}
+	
+	return options;
+
+}
+
+/** 
+ * Constant defining the minimum number of days per month where index 0 = January etc.
+ * 
+ * Used to look if a date _could be_ out of bounds. The "could be" part is why february is pinned to 28 days.
+ * 
+ * @private
+ * 
+ * @constant
+ * @type {Number[]}
+ * 
+*/
+const DaysOfMonth = [31,28,31,30,31,30,31,31,30,31,30,31];
+
+/**
+ * Array of work to be done, consisting of subarrays described below:
+ * @private
+ * 
+ * @constant
+ * 
+ * [
+ *   First item is which member to process,
+ *   Second item is which member to increment if we didn't find a mathch in current item,
+ *   Third item is an offset. if months is handled 0-11 in js date object, and we get 1-12 from `this.minute`
+ *   from pattern. Offset should be -1
+ * ]
+ * 
+ */
+const RecursionSteps = [
+	["month", "year",  0],
+	["day", "month", -1],
+	["hour", "day",  0],
+	["minute", "hour",  0],
+	["second", "minute",  0],
+];
+    
+/**
+ * Converts date to CronDate
+ * @constructor
+ * 
+ * @param {CronDate|Date|string} [d] - Input date, if using string representation ISO 8001 (2015-11-24T19:40:00) local timezone is expected
+ * @param {string|number} [tz] - String representation of target timezone in Europe/Stockholm format, or a number representing offset in minutes.
+*/
+function CronDate (d, tz) {	
+
+	/**
+	 * TimeZone
+	 * @type {string|number|undefined}
+	 */
+	this.tz = tz;
+
+	// Populate object using input date, or throw
+	if (d && d instanceof Date) {
+		if (!isNaN(d)) {
+			this.fromDate(d);
+		} else {
+			throw new TypeError("CronDate: Invalid date passed to CronDate constructor");
+		}
+	} else if (d === void 0) {
+		this.fromDate(new Date());
+	} else if (d && typeof d === "string") {
+		this.fromString(d);
+	} else if (d instanceof CronDate) {
+		this.fromCronDate(d);
+	} else {
+		throw new TypeError("CronDate: Invalid type (" + typeof d + ") passed to CronDate constructor");
+	}
+
+}
+
+/**
+ * Sets internals using a Date 
+ * @private
+ * 
+ * @param {Date} inDate - Input date in local time
+ */
+CronDate.prototype.fromDate = function (inDate) {
+	
+	/* If this instance of CronDate has a target timezone set, 
+	 * use minitz to convert input date object to target timezone
+	 * before extracting hours, minutes, seconds etc.
+	 * 
+	 * If not, extract all parts from inDate as-is.
+	 */
+	if (this.tz !== void 0) {
+		if (typeof this.tz === "number") {
+			this.ms = inDate.getUTCMilliseconds();
+			this.second = inDate.getUTCSeconds();
+			this.minute = inDate.getUTCMinutes()+this.tz;
+			this.hour = inDate.getUTCHours();
+			this.day = inDate.getUTCDate();
+			this.month  = inDate.getUTCMonth();
+			this.year = inDate.getUTCFullYear();
+			// Minute could be out of bounds, apply
+			this.apply();
+		} else {
+			const d = minitz.toTZ(inDate, this.tz);
+			this.ms = inDate.getMilliseconds();
+			this.second = d.s;
+			this.minute = d.i;
+			this.hour = d.h;
+			this.day = d.d;
+			this.month  = d.m - 1;
+			this.year = d.y;
+		}
+	} else {
+		this.ms = inDate.getMilliseconds();
+		this.second = inDate.getSeconds();
+		this.minute = inDate.getMinutes();
+		this.hour = inDate.getHours();
+		this.day = inDate.getDate();
+		this.month  = inDate.getMonth();
+		this.year = inDate.getFullYear();
+	}
+
+};
+
+/**
+ * Sets internals by deep copying another CronDate
+ * @private
+ * 
+ * @param {CronDate} d - Input date
+ */
+CronDate.prototype.fromCronDate = function (d) {
+	this.tz = d.tz;
+
+	/**
+	 * Current full year, in local time or target timezone specified by `this.tz` 
+	 * @type {number}
+	 */
+	this.year = d.year;
+
+	/**
+	 * Current month (1-12), in local time or target timezone specified by `this.tz`
+	 * @type {number}
+	 */
+	this.month = d.month;
+
+	/**
+	 * Current day (1-31), in local time or target timezone specified by `this.tz`
+	 * @type {number}
+	 */
+	this.day = d.day;
+
+	/**
+	 * Current hour (0-23), in local time or target timezone specified by `this.tz`
+	 * @type {number}
+	 */
+	this.hour = d.hour;
+
+	/**
+	 * Current minute (0-59), in local time or target timezone specified by `this.tz`
+	 * @type {number}
+	 */
+	this.minute = d.minute;
+
+	/**
+	 * Current second (0-59), in local time or target timezone specified by `this.tz`
+	 * @type {number}
+	 */
+	this.second = d.second;
+	
+	/**
+	 * Current milliseconds
+	 * @type {number}
+	 */
+	this.ms = d.ms;
+};
+
+/**
+ * Reset internal parameters (seconds, minutes, hours) if any of them have exceeded (or could have exceeded) their normal ranges
+ * 
+ * Will alway return true on february 29th, as that is a date that _could_ be out of bounds
+ * 
+ * @private
+ */
+CronDate.prototype.apply = function () {
+	// If any value could be out of bounds, apply 
+	if (this.month>11||this.day>DaysOfMonth[this.month]||this.hour>59||this.minute>59||this.second>59||this.hour<0||this.minute<0||this.second<0) {
+		const d = new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms));
+		this.ms = d.getUTCMilliseconds();
+		this.second = d.getUTCSeconds();
+		this.minute = d.getUTCMinutes();
+		this.hour = d.getUTCHours();
+		this.day = d.getUTCDate();
+		this.month  = d.getUTCMonth();
+		this.year = d.getUTCFullYear();
+		return true;
+	} else {
+		return false;
+	}
+};
+
+/**
+ * Sets internals by parsing a string
+ * @private
+ * 
+ * @param {Date} date - Input date
+ */
+CronDate.prototype.fromString = function (str) {
+	return this.fromDate(minitz.fromTZISO(str, this.tz));
+};
+
+/**
+ * Find next match of current part
+ * @private
+ *  
+ * @param {CronOptions} options - Cron options used for incrementing
+ * @param {string} target
+ * @param {CronPattern} pattern
+ * @param {Number} offset
+ * 
+ * @returns {boolean}
+ * 
+ */
+CronDate.prototype.findNext = function (options, target, pattern, offset) {
+	const originalTarget = this[target];
+
+	// In the conditions below, local time is not relevant. And as new Date(Date.UTC(y,m,d)) is way faster 
+	// than new Date(y,m,d). We use the UTC functions to set/get date parts.
+
+	// Pre-calculate last day of month if needed
+	let lastDayOfMonth;
+	if (pattern.lastDayOfMonth || pattern.lastWeekdayOfMonth) {
+		// This is an optimization for every month except february, which has different number of days different years
+		if (this.month !== 1) {
+			lastDayOfMonth = DaysOfMonth[this.month]; // About 20% performance increase when using L
+		} else {
+			lastDayOfMonth = new Date(Date.UTC(this.year, this.month+1, 0,0,0,0,0)).getUTCDate();
+		}
+	}
+
+	// Pre-calculate weekday if needed
+	// Calculate offset weekday by ((fDomWeekDay + (targetDate - 1)) % 7)
+	const fDomWeekDay = (!pattern.starDOW && target == "day") ? new Date(Date.UTC(this.year, this.month, 1,0,0,0,0)).getUTCDay() : undefined;
+
+	for( let i = this[target] + offset; i < pattern[target].length; i++ ) {
+
+		// this applies to all "levels"
+		let match = pattern[target][i];
+
+		// Special case for last day of month
+		if (target === "day" && pattern.lastDayOfMonth && i-offset == lastDayOfMonth) {
+			match = true;
+		}
+
+		// Special case for day of week
+		if (target === "day" && !pattern.starDOW) {
+
+			let dowMatch = pattern.dayOfWeek[(fDomWeekDay + ((i-offset) - 1)) % 7];
+
+			// Extra check for l-flag
+			if (dowMatch && pattern.lastWeekdayOfMonth) {
+				dowMatch = dowMatch && ( i-offset > lastDayOfMonth - 7 );
+			}
+
+			// If we use legacyMode, and dayOfMonth is specified - use "OR" to combine day of week with day of month
+			// In all other cases use "AND"
+			if (options.legacyMode && !pattern.starDOM) {
+				match = match || dowMatch;
+			} else {
+				match = match && dowMatch;
+			}
+		}
+
+		if (match) {
+			this[target] = i-offset;
+
+			// Return 2 if changed, 1 if unchanged
+			return (originalTarget !== this[target]) ? 2 : 1;
+		}
+	}
+
+	// Return 3 if part was not matched
+	return 3;
+};
+
+/**
+ * Increment to next run time recursively
+ * 
+ * This function is currently capped at year 3000. Do you have a reason to go further? Open an issue on GitHub!
+
+ * @private
+ * 
+ * @param {string} pattern - The pattern used to increment current state
+ * @param {CronOptions} options - Cron options used for incrementing
+ * @param {integer} doing - Which part to increment, 0 represent first item of RecursionSteps-array etc.
+ * @return {CronDate|null} - Returns itthis for chaining, or null if increment wasnt possible
+ */
+CronDate.prototype.recurse = function (pattern, options, doing)  {
+
+	// Find next month (or whichever part we're at)
+	const res = this.findNext(options, RecursionSteps[doing][0], pattern, RecursionSteps[doing][2]);
+
+	// Month (or whichever part we're at) changed
+	if (res > 1) {
+		// Flag following levels for reset
+		let resetLevel = doing + 1;
+		while(resetLevel < RecursionSteps.length) {
+			this[RecursionSteps[resetLevel][0]] = -RecursionSteps[resetLevel][2];
+			resetLevel++;
+		}
+		// Parent changed
+		if (res=== 3) {
+			// Do increment parent, and reset current level
+			this[RecursionSteps[doing][1]]++;
+			this[RecursionSteps[doing][0]] = -RecursionSteps[doing][2];
+			this.apply();
+
+			// Restart
+			return this.recurse(pattern, options, 0);
+		} else if (this.apply()) {
+			return this.recurse(pattern, options, doing-1);
+		}
+
+	}
+
+	// Move to next level
+	doing += 1;
+
+	// Done?
+	if (doing >= RecursionSteps.length) {
+		return this;
+
+		// ... or out of bounds ?
+	} else if (this.year >= 3000) {
+		return null;
+
+		// ... oh, go to next part then
+	} else {
+
+		return this.recurse(pattern, options, doing);
+	}
+    
+};
+
+/**
+ * Increment to next run time
+ * @public
+ * 
+ * @param {string} pattern - The pattern used to increment current state
+ * @param {CronOptions} options - Cron options used for incrementing
+ * @param {boolean} [hasPreviousRun] - If this run should adhere to minimum interval
+ * @return {CronDate|null} - Returns itthis for chaining, or null if increment wasnt possible
+ */
+CronDate.prototype.increment = function (pattern, options, hasPreviousRun) {
+	
+	// Move to next second, or increment according to minimum interval indicated by option `interval: x`
+	// Do not increment a full interval if this is the very first run
+	this.second += (options.interval > 1 && hasPreviousRun) ? options.interval : 1;
+
+	// Always reset milliseconds, so we are at the next second exactly
+	this.ms = 0;
+
+	// Make sure seconds has not gotten out of bounds
+	this.apply();
+
+	// Recursively change each part (y, m, d ...) until next match is found, return null on failure
+	return this.recurse(pattern, options, 0);
+	
+};
+
+/**
+ * Convert current state back to a javascript Date()
+ * @public
+ * 
+ * @param {boolean} internal - If this is an internal call
+ * @returns {Date}
+ */
+CronDate.prototype.getDate = function (internal) {
+	// If this is an internal call, return the date as is
+	// Also use this option when no timezone or utcOffset is set
+	if (internal || this.tz === void 0) {
+		return new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms);
+	} else {
+		// If .tz is a number, it indicates offset in minutes. UTC timestamp of the internal date objects will be off by the same number of minutes. 
+		// Restore this, and return a date object with correct time set.
+		if (typeof this.tz === "number") {
+			return new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute-this.tz, this.second, this.ms));
+
+		// If .tz is something else (hopefully a string), it indicates the timezone of the "local time" of the internal date object
+		// Use minitz to create a normal Date object, and return that.
+		} else {
+			return minitz(this.year, this.month+1, this.day, this.hour, this.minute, this.second, this.tz);
+		}
+	}
+};
+
+/**
+ * Convert current state back to a javascript Date() and return UTC milliseconds
+ * @public
+ * 
+ * @returns {Date}
+ */
+CronDate.prototype.getTime = function () {
+	return this.getDate().getTime();
+};
+
+/**
+ * Name for each part of the cron pattern
+ * @typedef {("second" | "minute" | "hour" | "day" | "month" | "dayOfWeek")} CronPatternPart
+ */
+
+/**
+ * Offset, 0 or -1. 
+ * 
+ * 0 offset is used for seconds,minutes and hours as they start on 1. 
+ * -1 on days and months, as they start on 0
+ * 
+ * @typedef {Number} CronIndexOffset
+ */
+
+/**
+ * Create a CronPattern instance from pattern string ('* * * * * *')
+ * @constructor
+ * @param {string} pattern - Input pattern
+ * @param {string} timezone - Input timezone, used for '?'-substitution
+ */
+function CronPattern (pattern, timezone) {
+
+	this.pattern 		= pattern;
+	this.timezone		= timezone;
+
+	this.second			= Array(60).fill(0); // 0-59
+	this.minute			= Array(60).fill(0); // 0-59
+	this.hour			= Array(24).fill(0); // 0-23
+	this.day			= Array(31).fill(0); // 0-30 in array, 1-31 in config
+	this.month			= Array(12).fill(0); // 0-11 in array, 1-12 in config
+	this.dayOfWeek		= Array(8).fill(0);  // 0-7 Where 0 = Sunday and 7=Sunday;
+
+	this.lastDayOfMonth = false;
+	this.lastWeekdayOfMonth = false;
+
+	this.starDOM = false;  // Asterisk used for dayOfMonth
+	this.starDOW  = false; // Asterisk used for dayOfWeek
+
+	this.parse();
+
+}
+
+/**
+ * Parse current pattern, will throw on any type of failure
+ * @private
+ */
+CronPattern.prototype.parse = function () {
+
+	// Sanity check
+	if( !(typeof this.pattern === "string" || this.pattern.constructor === String) ) {
+		throw new TypeError("CronPattern: Pattern has to be of type string.");
+	}
+
+	// Handle @yearly, @monthly etc
+	if (this.pattern.indexOf("@") >= 0) this.pattern = this.handleNicknames(this.pattern).trim();
+
+	// Split configuration on whitespace
+	const parts = this.pattern.replace(/\s+/g, " ").split(" ");
+
+	// Validite number of configuration entries
+	if( parts.length < 5 || parts.length > 6 ) {
+		throw new TypeError("CronPattern: invalid configuration format ('" + this.pattern + "'), exacly five or six space separated parts required.");
+	}
+
+	// If seconds is omitted, insert 0 for seconds
+	if( parts.length === 5) {
+		parts.unshift("0");
+	}
+
+	// Convert 'L' to lastDayOfMonth flag in day-of-month field
+	if(parts[3].indexOf("L") >= 0) {
+		parts[3] = parts[3].replace("L","");
+		this.lastDayOfMonth = true;
+	}
+
+	// Convert 'L' to lastWeekdayOfMonth flag in day-of-week field
+	if(parts[5].indexOf("L") >= 0) {
+		parts[5] = parts[5].replace("L","");
+		this.lastWeekdayOfMonth = true;
+	}
+	
+	// Check for starDOM
+	if(parts[3] == "*") {
+		this.starDOM = true;
+	}
+
+	// Replace alpha representations
+	if (parts[4].length >= 3) parts[4] = this.replaceAlphaMonths(parts[4]);
+	if (parts[5].length >= 3) parts[5] = this.replaceAlphaDays(parts[5]);
+
+	// Check for starDOW
+	if(parts[5] == "*") {
+		this.starDOW = true;
+	}
+	
+	// Implement '?' in the simplest possible way - replace ? with current value, before further processing
+	if (this.pattern.indexOf("?") >= 0) {
+		const initDate = new CronDate(new Date(),this.timezone).getDate(true);
+		parts[0] = parts[0].replace("?", initDate.getSeconds());
+		parts[1] = parts[1].replace("?", initDate.getMinutes());
+		parts[2] = parts[2].replace("?", initDate.getHours());
+		if (!this.starDOM) parts[3] = parts[3].replace("?", initDate.getDate());
+		parts[4] = parts[4].replace("?", initDate.getMonth()+1); // getMonth is zero indexed while pattern starts from 1
+		if (!this.starDOW) parts[5] = parts[5].replace("?", initDate.getDay());
+	}
+
+	// Check part content
+	this.throwAtIllegalCharacters(parts);
+
+	// Parse parts into arrays, validates as we go
+	this.partToArray("second",    parts[0], 0);
+	this.partToArray("minute",    parts[1], 0);
+	this.partToArray("hour",      parts[2], 0);
+	this.partToArray("day",       parts[3], -1);
+	this.partToArray("month",     parts[4], -1);
+	this.partToArray("dayOfWeek", parts[5], 0);
+
+	// 0 = Sunday, 7 = Sunday
+	if( this.dayOfWeek[7] ) {
+		this.dayOfWeek[0] = 1;
+	}
+
+};
+
+/**
+ * Convert current part (seconds/minutes etc) to an array of 1 or 0 depending on if the part is about to trigger a run or not.
+ * @private
+ * 
+ * @param {CronPatternPart} type - Seconds/minutes etc
+ * @param {string} conf - Current pattern part - *, 0-1 etc
+ * @param {CronIndexOffset} valueIndexOffset
+ * @param {boolean} [recursed] - Is this a recursed call 
+ */
+CronPattern.prototype.partToArray = function (type, conf, valueIndexOffset) {
+
+	const arr = this[type];
+
+	// First off, handle wildcard
+	if( conf === "*" ) return arr.fill(1);
+
+	// Handle separated entries (,) by recursion
+	const split = conf.split(",");
+	if( split.length > 1 ) {
+		for( let i = 0; i < split.length; i++ ) {
+			this.partToArray(type, split[i], valueIndexOffset);
+		}
+
+	// Handle range with stepping (x-y/z)
+	} else if( conf.indexOf("-") !== -1 && conf.indexOf("/") !== -1 ) {
+		this.handleRangeWithStepping(conf, type, valueIndexOffset);
+	
+	// Handle range
+	} else if( conf.indexOf("-") !== -1 ) {
+		this.handleRange(conf, type, valueIndexOffset);
+
+	// Handle stepping
+	} else if( conf.indexOf("/") !== -1 ) {
+		this.handleStepping(conf, type, valueIndexOffset);
+
+	// Anything left should be a number
+	} else if( conf !== "" ) {
+		this.handleNumber(conf, type, valueIndexOffset);
+	}
+
+};
+
+/**
+ * After converting JAN-DEC, SUN-SAT only 0-9 * , / - are allowed, throw if anything else pops up
+ * @private
+ * 
+ * @param {string[]} parts - Each part split as strings
+ */
+CronPattern.prototype.throwAtIllegalCharacters = function (parts) {
+	const reValidCron = /[^/*0-9,-]+/;
+	for(let i = 0; i < parts.length; i++) {
+		if( reValidCron.test(parts[i]) ) {
+			throw new TypeError("CronPattern: configuration entry " + i + " (" + parts[i] + ") contains illegal characters.");
+		}
+	}
+};
+
+/**
+ * Nothing but a number left, handle that
+ * @private
+ * 
+ * @param {string} conf - Current part, expected to be a number, as a string
+ * @param {string} type - One of "seconds", "minutes" etc
+ * @param {number} valueIndexOffset - -1 for day of month, and month, as they start at 1. 0 for seconds, hours, minutes
+ */
+CronPattern.prototype.handleNumber = function (conf, type, valueIndexOffset) {
+	const i = (parseInt(conf, 10) + valueIndexOffset);
+
+	if( isNaN(i) ) {
+		throw new TypeError("CronPattern: " + type + " is not a number: '" + conf + "'");
+	}
+
+	if( i < 0 || i >= this[type].length ) {
+		throw new TypeError("CronPattern: " + type + " value out of range: '" + conf + "'");
+	}
+
+	this[type][i] = 1;
+};
+
+/**
+ * Take care of ranges with stepping (e.g. 3-23/5)
+ * @private
+ *
+ * @param {string} conf - Current part, expected to be a string like 3-23/5
+ * @param {string} type - One of "seconds", "minutes" etc
+ * @param {number} valueIndexOffset - -1 for day of month, and month, as they start at 1. 0 for seconds, hours, minutes
+ */
+CronPattern.prototype.handleRangeWithStepping = function (conf, type, valueIndexOffset) {
+	const matches = conf.match(/^(\d+)-(\d+)\/(\d+)$/);
+
+	if( matches === null ) throw new TypeError("CronPattern: Syntax error, illegal range with stepping: '" + conf + "'");
+
+	let [, lower, upper, steps] = matches;
+	lower = parseInt(lower, 10) + valueIndexOffset;
+	upper = parseInt(upper, 10) + valueIndexOffset;
+	steps = parseInt(steps, 10);
+
+	if( isNaN(lower) ) throw new TypeError("CronPattern: Syntax error, illegal lower range (NaN)");
+	if( isNaN(upper) ) throw new TypeError("CronPattern: Syntax error, illegal upper range (NaN)");
+	if( isNaN(steps) ) throw new TypeError("CronPattern: Syntax error, illegal stepping: (NaN)");
+
+	if( steps === 0 ) throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+	if( steps > this[type].length ) throw new TypeError("CronPattern: Syntax error, steps cannot be greater than maximum value of part ("+this[type].length+")");
+
+	if( lower < 0 || upper >= this[type].length ) throw new TypeError("CronPattern: Value out of range: '" + conf + "'");
+	if( lower > upper ) throw new TypeError("CronPattern: From value is larger than to value: '" + conf + "'");
+
+	for (let i = lower; i <= upper; i += steps) {
+		this[type][i] = 1;
+	}
+};
+
+/**
+ * Take care of ranges (e.g. 1-20)
+ * @private
+ * 
+ * @param {string} conf - Current part, expected to be a string like 1-20
+ * @param {string} type - One of "seconds", "minutes" etc
+ * @param {number} valueIndexOffset - -1 for day of month, and month, as they start at 1. 0 for seconds, hours, minutes
+ */
+CronPattern.prototype.handleRange = function (conf, type, valueIndexOffset) {
+	const split = conf.split("-");
+
+	if( split.length !== 2 ) {
+		throw new TypeError("CronPattern: Syntax error, illegal range: '" + conf + "'");
+	}
+
+	const lower = parseInt(split[0], 10) + valueIndexOffset,
+		upper = parseInt(split[1], 10) + valueIndexOffset;
+
+	if( isNaN(lower) ) {
+		throw new TypeError("CronPattern: Syntax error, illegal lower range (NaN)");
+	} else if( isNaN(upper) ) {
+		throw new TypeError("CronPattern: Syntax error, illegal upper range (NaN)");
+	}
+
+	// Check that value is within range
+	if( lower < 0 || upper >= this[type].length ) {
+		throw new TypeError("CronPattern: Value out of range: '" + conf + "'");
+	}
+
+	//
+	if( lower > upper ) {
+		throw new TypeError("CronPattern: From value is larger than to value: '" + conf + "'");
+	}
+
+	for( let i = lower; i <= upper; i++ ) {
+		this[type][i] = 1;
+	}
+};
+
+/**
+ * Handle stepping (e.g. * / 14)
+ * @private
+ * 
+ * @param {string} conf - Current part, expected to be a string like * /20 (without the space)
+ * @param {string} type - One of "seconds", "minutes" etc
+ */
+CronPattern.prototype.handleStepping = function (conf, type) {
+
+	const split = conf.split("/");
+
+	if( split.length !== 2 ) {
+		throw new TypeError("CronPattern: Syntax error, illegal stepping: '" + conf + "'");
+	}
+
+	let start = 0;
+	if( split[0] !== "*" ) {
+		start = parseInt(split[0], 10);
+	}
+
+	const steps = parseInt(split[1], 10);
+
+	if( isNaN(steps) ) throw new TypeError("CronPattern: Syntax error, illegal stepping: (NaN)");
+	if( steps === 0 ) throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+	if( steps > this[type].length ) throw new TypeError("CronPattern: Syntax error, max steps for part is ("+this[type].length+")");
+
+	for( let i = start; i < this[type].length; i+= steps ) {
+		this[type][i] = 1;
+	}
+};
+
+
+/**
+ * Replace day name with day numbers
+ * @private
+ * 
+ * @param {string} conf - Current part, expected to be a string that might contain sun,mon etc.
+ * 
+ * @returns {string} - conf with 0 instead of sun etc.
+ */
+CronPattern.prototype.replaceAlphaDays = function (conf) {
+	return conf
+		.replace(/-sun/gi, "-7") // choose 7 if sunday is the upper value of a range because the upper value must not be smaller than the lower value
+		.replace(/sun/gi, "0")
+		.replace(/mon/gi, "1")
+		.replace(/tue/gi, "2")
+		.replace(/wed/gi, "3")
+		.replace(/thu/gi, "4")
+		.replace(/fri/gi, "5")
+		.replace(/sat/gi, "6");
+};
+
+/**
+ * Replace month name with month numbers
+ * @private
+ * 
+ * @param {string} conf - Current part, expected to be a string that might contain jan,feb etc.
+ * 
+ * @returns {string} - conf with 0 instead of sun etc.
+ */
+CronPattern.prototype.replaceAlphaMonths = function (conf) {
+	return conf
+		.replace(/jan/gi, "1")
+		.replace(/feb/gi, "2")
+		.replace(/mar/gi, "3")
+		.replace(/apr/gi, "4")
+		.replace(/may/gi, "5")
+		.replace(/jun/gi, "6")
+		.replace(/jul/gi, "7")
+		.replace(/aug/gi, "8")
+		.replace(/sep/gi, "9")
+		.replace(/oct/gi, "10")
+		.replace(/nov/gi, "11")
+		.replace(/dec/gi, "12");
+};
+
+/**
+ * Replace nicknames with actual cron patterns
+ * @private
+ * 
+ * @param {string} pattern - Pattern, may contain nicknames, or not
+ * 
+ * @returns {string} - Pattern, with cron expression insted of nicknames
+ */
+CronPattern.prototype.handleNicknames = function (pattern) {
+	// Replace textual representations of pattern
+	const cleanPattern = pattern.trim().toLowerCase();
+	if (cleanPattern === "@yearly" || cleanPattern === "@annually") {
+		return "0 0 1 1 *";
+	} else if (cleanPattern === "@monthly") {
+		return  "0 0 1 * *";
+	} else if (cleanPattern === "@weekly") {
+		return "0 0 * * 0";
+	} else if (cleanPattern === "@daily") {
+		return "0 0 * * *";
+	} else if (cleanPattern === "@hourly") {
+		return "0 * * * *";
+	} else {
+		return pattern;
+	}
+};
+
+/**
+ * Helper function to check if a variable is a function
+ * @private
+ *
+ * @param {?} [v] - Variable to check
+ * @returns {boolean}
+ */
+function isFunction(v) {
+	return (
+		Object.prototype.toString.call(v) === "[object Function]" ||
+		"function" === typeof v ||
+		v instanceof Function
+	);
+}
+
+/**
+ * Helper function to unref a timer in both Deno and Node
+ * @private
+ * @param {unknown} [timer] - Timer to unref
+ */
+function unrefTimer(timer) {
+	/* global Deno */
+	if (typeof Deno !== "undefined" && typeof Deno.unrefTimer !== "undefined") {
+		Deno.unrefTimer(timer);
+		// Node
+	} else if (timer && typeof timer.unref !== "undefined") {
+		timer.unref();
+	}
+}
+
+/* ------------------------------------------------------------------------------------
+
+  Croner - MIT License - Hexagon <github.com/Hexagon>
+
+  Pure JavaScript Isomorphic cron parser and scheduler without dependencies.
+
+  ------------------------------------------------------------------------------------
+
+  License:
+
+	Copyright (c) 2015-2022 Hexagon <github.com/Hexagon>
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+
+  ------------------------------------------------------------------------------------  */
+
+/**
+ * Many JS engines stores the delay as a 32-bit signed integer internally.
+ * This causes an integer overflow when using delays larger than 2147483647,
+ * resulting in the timeout being executed immediately.
+ *
+ * All JS engines implements an immediate execution of delays larger that a 32-bit
+ * int to keep the behaviour concistent.
+ *
+ * @constant
+ * @type {number}
+ */
+const maxDelay = Math.pow(2, 32 - 1) - 1;
+
+/**
+ * An array containing all named cron jobs.
+ *
+ * @constant
+ * @type {Cron[]}
+ */
+const scheduledJobs = [];
+
+/**
+ * Cron entrypoint
+ *
+ * @constructor
+ * @param {string|Date} pattern - Input pattern, input date, or input ISO 8601 time string
+ * @param {CronOptions|Function} [fnOrOptions1] - Options or function to be run each iteration of pattern
+ * @param {CronOptions|Function} [fnOrOptions2] - Options or function to be run each iteration of pattern
+ * @returns {Cron}
+ */
+function Cron(pattern, fnOrOptions1, fnOrOptions2) {
+	// Optional "new" keyword
+	if (!(this instanceof Cron)) {
+		return new Cron(pattern, fnOrOptions1, fnOrOptions2);
+	}
+
+	// Make options and func optional and interchangable
+	let options, func;
+
+	if (isFunction(fnOrOptions1)) {
+		func = fnOrOptions1;
+	} else if (typeof fnOrOptions1 === "object") {
+		options = fnOrOptions1;
+	} else if (fnOrOptions1 !== void 0) {
+		throw new Error(
+			"Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).",
+		);
+	}
+
+	if (isFunction(fnOrOptions2)) {
+		func = fnOrOptions2;
+	} else if (typeof fnOrOptions2 === "object") {
+		options = fnOrOptions2;
+	} else if (fnOrOptions2 !== void 0) {
+		throw new Error(
+			"Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).",
+		);
+	}
+
+	/**
+	 * @public
+	 * @type {string|undefined} */
+	this.name = options ? options.name : void 0;
+
+	/**
+	 * @public
+	 * @type {CronOptions} */
+	this.options = CronOptions(options);
+
+	/**
+	 * Encapsulate all internal states in an object.
+	 * Duplicate all options that can change to internal states, for example maxRuns and paused.
+	 * @private
+	 */
+	this._states = {
+		/** @type {boolean} */
+		kill: false,
+
+		/** @type {boolean} */
+		blocking: false,
+
+		/**
+		 * Start time of previous trigger, updated after each trigger
+		 * @type {CronDate}
+		 */
+		previousRun: void 0,
+
+		/**
+		 * Start time of current trigger, this is updated just before triggering
+		 * @type {CronDate}
+		 */
+		currentRun: void 0,
+
+		/** @type {CronDate|undefined} */
+		once: void 0,
+
+		/** @type {unknown|undefined} */
+		currentTimeout: void 0,
+
+		/** @type {number} */
+		maxRuns: options ? options.maxRuns : void 0,
+
+		/** @type {boolean} */
+		paused: options ? options.paused : false,
+	};
+
+	/**
+	 * @public
+	 * @type {CronPattern|undefined} */
+	this.pattern = void 0;
+
+	// Check if we got a date, or a pattern supplied as first argument
+	// Then set either this._states.once or this.pattern
+	if (
+		pattern &&
+		(pattern instanceof Date || ((typeof pattern === "string") && pattern.indexOf(":") > 0))
+	) {
+		this._states.once = new CronDate(pattern, this.options.timezone || this.options.utcOffset);
+	} else {
+		this.pattern = new CronPattern(pattern, this.options.timezone);
+	}
+
+	// Allow shorthand scheduling
+	if (func !== void 0) {
+		this.fn = func;
+		this.schedule();
+	}
+
+	// Only store the job in scheduledJobs if a name is specified in the options.
+	if (this.name) {
+		const existing = scheduledJobs.find((j) => j.name === this.name);
+		if (existing) {
+			throw new Error(
+				"Cron: Tried to initialize new named job '" + this.name + "', but name already taken.",
+			);
+		} else {
+			scheduledJobs.push(this);
+		}
+	}
+
+	return this;
+}
+
+/**
+ * Find next runtime, based on supplied date. Strips milliseconds.
+ *
+ * @param {CronDate|Date|string} [prev] - Date to start from
+ * @returns {Date | null} - Next run time
+ */
+Cron.prototype.next = function (prev) {
+	const next = this._next(prev);
+	return next ? next.getDate() : null;
+};
+
+/**
+ * Find next n runs, based on supplied date. Strips milliseconds.
+ *
+ * @param {number} n - Number of runs to enumerate
+ * @param {Date|string} [previous] - Date to start from
+ * @returns {Date[]} - Next n run times
+ */
+Cron.prototype.enumerate = function (n, previous) {
+	if (n > this._states.maxRuns) {
+		n = this._states.maxRuns;
+	}
+	const enumeration = [];
+	let prev = previous || this._states.previousRun;
+	while (n-- && (prev = this.next(prev))) {
+		enumeration.push(prev);
+	}
+
+	return enumeration;
+};
+
+/**
+ * Indicates wether or not the cron job is active, e.g. awaiting next trigger
+ * @public
+ *
+ * @returns {boolean} - Running or not
+ */
+Cron.prototype.running = function () {
+	const msLeft = this.msToNext(this._states.previousRun);
+	const running = !this._states.paused && this.fn !== void 0;
+	return msLeft !== null && running;
+};
+
+/**
+ * Indicates wether or not the cron job is currently working
+ * @public
+ *
+ * @returns {boolean} - Running or not
+ */
+Cron.prototype.busy = function () {
+	return this._states.blocking;
+};
+
+/**
+ * Return current/previous run start time
+ * @public
+ *
+ * @returns {Date | null} - Previous run time
+ */
+Cron.prototype.started = function () {
+	return this._states.currentRun ? this._states.currentRun.getDate() : null;
+};
+
+/**
+ * Return previous run start time
+ * @public
+ *
+ * @returns {Date | null} - Previous run time
+ */
+Cron.prototype.previous = function () {
+	return this._states.previousRun ? this._states.previousRun.getDate() : null;
+};
+
+/**
+ * Returns number of milliseconds to next run
+ * @public
+ *
+ * @param {CronDate|Date|string} [prev] - Starting date, defaults to now - minimum interval
+ * @returns {number | null}
+ */
+Cron.prototype.msToNext = function (prev) {
+	// Get next run time
+	const next = this._next(prev);
+
+	// Default previous for millisecond calculation
+	prev = new CronDate(prev, this.options.timezone || this.options.utcOffset);
+
+	if (next) {
+		return (next.getTime(true) - prev.getTime(true));
+	} else {
+		return null;
+	}
+};
+
+/**
+ * Stop execution
+ *
+ * Running this will forcefully stop the job, and prevent furter exection. `.resume()` will not work after stopping.
+ *
+ * @public
+ */
+Cron.prototype.stop = function () {
+	this._states.kill = true;
+	// Stop any awaiting call
+	if (this._states.currentTimeout) {
+		clearTimeout(this._states.currentTimeout);
+	}
+};
+
+/**
+ * Pause execution
+ * @public
+ *
+ * @returns {boolean} - Wether pause was successful
+ */
+Cron.prototype.pause = function () {
+	
+	this._states.paused = true;
+
+	return !this._states.kill;
+};
+
+/**
+ * Resume execution
+ * @public
+ *
+ * @returns {boolean} - Wether resume was successful
+ */
+Cron.prototype.resume = function () {
+
+	this._states.paused = false;
+
+	return !this._states.kill;
+};
+
+/**
+ * Schedule a new job
+ * @public
+ *
+ * @param {Function} func - Function to be run each iteration of pattern
+ * @param {Date} [partial] - Internal function indicating a partial run
+ * @returns {Cron}
+ */
+Cron.prototype.schedule = function (func, partial) {
+	// If a function is already scheduled, bail out
+	if (func && this.fn) {
+		throw new Error(
+			"Cron: It is not allowed to schedule two functions using the same Croner instance.",
+		);
+
+		// Update function if passed
+	} else if (func) {
+		this.fn = func;
+	}
+
+	// Get ms to next run, bail out early if any of them is null (no next run)
+	let waitMs = this.msToNext(partial ? partial : this._states.previousRun);
+	const target = this.next(partial ? partial : this._states.previousRun);
+	if (waitMs === null || target === null) return this;
+
+	// setTimeout cant handle more than Math.pow(2, 32 - 1) - 1 ms
+	if (waitMs > maxDelay) {
+		waitMs = maxDelay;
+	}
+
+	// Start the timer loop
+	// _checkTrigger will either call _trigger (if it's time, croner isn't paused and whatever), 
+	// or recurse back to this function to wait for next trigger
+	this._states.currentTimeout = setTimeout(() => this._checkTrigger(target), waitMs);
+
+	// If unref option is set - unref the current timeout, which allows the process to exit even if there is a pending schedule
+	if (this._states.currentTimeout && this.options.unref) {
+		unrefTimer(this._states.currentTimeout);
+	}
+
+	return this;
+};
+
+/**
+ * Internal function to trigger a run, used by both scheduled and manual trigger
+ * @private
+ *
+ * @param {Date} [initiationDate]
+ */
+Cron.prototype._trigger = async function (initiationDate) {
+
+	this._states.blocking = true;
+
+	this._states.currentRun = new CronDate(
+		initiationDate,
+		this.options.timezone || this.options.utcOffset,
+	);
+
+	if (this.options.catch) {
+		try {
+			await this.fn(this, this.options.context);
+		} catch (_e) {
+			if (isFunction(this.options.catch)) {
+				// Do not await catch, even if it is synchronous
+				setTimeout(() => this.options.catch(_e, this), 0);
+			}
+		}
+	} else {
+		// Trigger the function without catching
+		await this.fn(this, this.options.context);
+
+	}
+
+	this._states.previousRun = new CronDate(
+		initiationDate,
+		this.options.timezone || this.options.utcOffset,
+	);
+
+	this._states.blocking = false;
+
+};
+
+/**
+ * Trigger a run manually
+ * @public
+ */
+Cron.prototype.trigger = async function () {
+	await this._trigger();
+};
+
+/**
+ * Called when it's time to trigger.
+ * Checks if all conditions are currently met,
+ * then instantly triggers the scheduled function.
+ * @private
+ *
+ * @param {Date} target - Target Date
+ */
+Cron.prototype._checkTrigger = function (target) {
+	const now = new Date(),
+		shouldRun = !this._states.paused && now.getTime() >= target,
+		isBlocked = this.blocking && this.options.protect;
+
+	if (shouldRun && !isBlocked) {
+		this._states.maxRuns--;
+
+		// We do not await this
+		this._trigger();
+
+	} else {
+		// If this trigger were blocked, and protect is a function, trigger protect (without awaiting it, even if it's an synchronous function)
+		if (shouldRun && isBlocked && isFunction(this.options.protect)) {
+			setTimeout(() => this.options.protect(this), 0);
+		}
+	}
+
+	// Always reschedule
+	this.schedule(undefined, now);
+};
+
+/**
+ * Internal version of next. Cron needs millseconds internally, hence _next.
+ * @private
+ *
+ * @param {CronDate|Date|string} prev - previousRun
+ * @returns {CronDate | null} - Next run time
+ */
+Cron.prototype._next = function (prev) {
+	const hasPreviousRun = (prev || this._states.previousRun) ? true : false;
+
+	// Ensure previous run is a CronDate
+	prev = new CronDate(prev, this.options.timezone || this.options.utcOffset);
+
+	// Previous run should never be before startAt
+	if (this.options.startAt && prev && prev.getTime() < this.options.startAt.getTime()) {
+		prev = this.options.startAt;
+	}
+
+	// Calculate next run according to pattern or one-off timestamp, pass actual previous run to increment
+	const nextRun = this._states.once ||
+		new CronDate(prev, this.options.timezone || this.options.utcOffset).increment(
+			this.pattern,
+			this.options,
+			hasPreviousRun, // hasPreviousRun is used to allow 
+		);
+
+	if (this._states.once && this._states.once.getTime() <= prev.getTime()) {
+		return null;
+	} else if (
+		(nextRun === null) ||
+		(this._states.maxRuns <= 0) ||
+		(this._states.kill) ||
+		(this.options.stopAt && nextRun.getTime() >= this.options.stopAt.getTime())
+	) {
+		return null;
+	} else {
+		// All seem good, return next run
+		return nextRun;
+	}
+};
+
+Cron.Cron = Cron;
+Cron.scheduledJobs = scheduledJobs;
+
+module.exports = Cron;