feat: 초기 프로젝트 설정 및 룰.md 파일 추가

api.hyungi.net/node_modules/croner/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2021 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.
+

api.hyungi.net/node_modules/croner/README.md

@@ -0,0 +1,338 @@
+<p align="center">
+<img src="/croner.png" alt="Croner" width="150" height="150"><br>
+Trigger functions and/or evaluate cron expressions in JavaScript. No dependencies. Most features. Node. Deno. Browser. <br><br>Try it live on <a href="https://jsfiddle.net/hexag0n/hoa8kwsb/">jsfiddle</a>.<br>
+</p>
+
+# Croner
+
+![Node.js CI](https://github.com/Hexagon/croner/workflows/Node.js%20CI/badge.svg?branch=master) [![npm version](https://badge.fury.io/js/croner.svg)](https://badge.fury.io/js/croner) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/4978bdbf495941c087ecb32b120f28ff)](https://www.codacy.com/gh/Hexagon/croner/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Hexagon/croner&amp;utm_campaign=Badge_Grade)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Hexagon/croner/blob/master/LICENSE) [![NPM Downloads](https://img.shields.io/npm/dm/croner.svg)](https://www.npmjs.org/package/croner)
+![No dependencies](https://img.shields.io/badge/dependencies-none-brightgreen)
+
+*   Trigger functions in JavaScript using [Cron](https://en.wikipedia.org/wiki/Cron#CRON_expression) syntax.
+*   Find first date of next month, find date of next tuesday, etc.
+*   Pause, resume or stop execution after a task is scheduled.
+*   Works in Node.js >=4.0 (both require and import).
+*   Works in Deno >=1.16.
+*   Works in browsers as standalone, UMD or ES-module.
+*   **Experimental feature:** Schedule in specific target timezones.
+*   Includes [TypeScript](https://www.typescriptlang.org/) typings.
+
+Quick examples:
+
+```javascript
+// Basic: Run a function at the interval defined by a cron expression
+const job = Cron('*/5 * * * * *', () => {
+	console.log('This will run every fifth second');
+});
+
+// Enumeration: What dates do the next 100 sundays occur at?
+const nextSundays = Cron('0 0 0 * * 7').enumerate(100);
+console.log(nextSundays);
+
+// Days left to a specific date
+const msLeft = Cron('59 59 23 24 DEC *').next() - new Date();
+console.log(Math.floor(msLeft/1000/3600/24) + " days left to next christmas eve");
+
+// Run a function at a specific date/time using a non-local timezone (time is ISO 8601 local time)
+// This will run 2023-01-23 00:00:00 according to the time in Asia/Kolkata
+Cron('2023-01-23T00:00:00', { timezone: 'Asia/Kolkata' }, () => { console.log('Yay') });
+
+```
+
+More [examples](#examples)...
+
+## Why another javascript cron implementation
+
+Because the existing ones aren't good enough. They have serious bugs, use bloated dependencies, do not work in all environments and/or simply don't work as expected.
+
+Benchmark at 2022-02-01:
+
+```
+> node cron-implementation-test.js
+
+Test: When is next monday in october, pattern '0 0 0 * 10 1'
+
+node-schedule: 2022-10-03 00:00:00 in 15.26ms
+node-cron:     ???                 in 1.076ms
+cron:          2022-11-07 00:00:00 in 2.923ms
+croner:        2022-10-03 00:00:00 in 1.774ms
+```
+
+<details>
+	<summary>More test results</summary>
+	
+```
+Test: When is next 15th of february, pattern '0 0 0 15 2 *'
+
+node-schedule: 2022-02-15 00:00:00 in 13.306ms
+node-cron:     ???                 in 1.676ms
+cron:          2022-03-15 00:00:00 in 6.066ms
+croner:        2022-02-15 00:00:00 in 0.575ms
+
+Test: When is 23:00 next 31st march, pattern '0 0 23 31 3 *'
+
+node-schedule: 2022-03-31 23:00:00 in 18.894ms
+node-cron:     ???                 in 3.017ms
+Month '3' is limited to '30' days.
+cron:          2022-04-01 23:00:00 in 4.508ms
+croner:        2022-03-31 23:00:00 in 1.381ms
+```
+
+</details>
+
+https://gist.github.com/Hexagon/703f85f2dd86443cc17eef8f5cc6cb70
+
+## Installation
+
+### Node.js
+
+```npm install croner --save```
+
+JavaScript
+
+```javascript
+// ESM Import ...
+import Cron from "croner";
+
+// ... or CommonJS Require
+const Cron = require("croner");
+```
+
+TypeScript
+
+*Note that only default export is available in Node.js TypeScript, as the commonjs module is used internally.*
+
+```typescript
+import Cron from "croner";
+
+const scheduler : Cron = new Cron("* * * * * *", () => {
+	console.log("This will run every second.");
+});
+```
+
+### Deno
+
+JavaScript
+
+```javascript
+import Cron from "https://cdn.jsdelivr.net/gh/hexagon/croner@4/src/croner.js";
+
+Cron("* * * * * *", () => {
+	console.log("This will run every second.");
+});
+```
+
+TypeScript
+
+```typescript
+import { Cron } from "https://cdn.jsdelivr.net/gh/hexagon/croner@4/src/croner.js";
+
+const _scheduler : Cron = new Cron("* * * * * *", () => {
+	console.log("This will run every second.");
+});
+```
+
+### Browser 
+
+#### Manual
+
+*   Download latest [zipball](https://github.com/Hexagon/croner/archive/refs/heads/master.zip)
+*   Unpack
+*   Grab ```croner.min.js``` (UMD and standalone) or ```croner.min.mjs``` (ES-module) from the [dist/](/dist) folder
+
+#### CDN
+
+To use as a [UMD](https://github.com/umdjs/umd)-module (stand alone, [RequireJS](https://requirejs.org/) etc.)
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/croner@4/dist/croner.min.js"></script>
+```
+
+To use as a [ES-module](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+
+```html
+<script type="module">
+	import Cron from "https://cdn.jsdelivr.net/npm/croner@4/dist/croner.min.mjs";
+
+	// ... see usage section ...
+</script>
+```
+## Documentation
+
+Full documentation available at [hexagon.github.io/croner](https://hexagon.github.io/croner/Cron.html).
+
+The short version:
+
+### Signature
+
+Cron takes three arguments
+
+*   [pattern](#pattern)
+*   [options](#options) (optional) 
+*   scheduled function (optional)
+
+```javascript
+const job = Cron("* * * * * *" /* Or a date object, or ISO 8601 local time */ , /*optional*/ { maxRuns: 1 } , /*optional*/ () => {} );
+
+// If function is omitted in constructor, it can be scheduled later
+job.schedule((/* optional */ job, /* optional */ context) => {});		
+
+// States
+const nextRun = job.next( /*optional*/ previousRun );	// Get a Date object representing next run
+const nextRuns = job.enumerate(10, /*optional*/ startFrom ); // Get a array of Dates, containing next 10 runs according to pattern
+const prevRun = job.previous( );	
+const msToNext = job.msToNext( /*optional*/ previousRun ); // Milliseconds left to next execution
+const isRunning = job.running();
+
+// Control scheduled execution
+job.pause();				
+job.resume();
+job.stop();
+
+```
+
+#### Options
+
+| Key          | Default value  | Data type      | Remarks                               |
+|--------------|----------------|----------------|---------------------------------------|
+| maxRuns      | Infinite       | Number         |                                       |
+| catch	       | false          | Boolean        | Catch and ignore unhandled errors in triggered function |
+| timezone     | undefined      | String         | Timezone in Europe/Stockholm format   |
+| startAt      | undefined      | String         | ISO 8601 formatted datetime (2021-10-17T23:43:00)<br>in local or specified timezone |
+| stopAt       | undefined      | String         | ISO 8601 formatted datetime (2021-10-17T23:43:00)<br>in local or specified timezone |
+| paused       | false          | Boolean        | If the job should be paused from start. |
+| context      | undefined      | Any            | Passed as the second parameter to triggered function |
+
+#### Pattern
+
+The expressions of Croner are very similar to the ones of Vixie Cron, with a few additions and changes listed below. 
+
+*   In croner, a combination of day-of-week and day-of-month will only trigger when both conditions match. An example: ```0 20 1 * MON``` will only trigger when monday occur the first day of any month. In Vixie Cron, it would trigger every monday AND the first day of every month. See issue [#53](https://github.com/Hexagon/croner/issues/53).
+
+*   Croner expressions support the following additional modifiers
+	-   *?* A question mark is substituted with croner initialization time, as an example - `? ? * * * *` would be substituted with `25 8 * * * *` if time is `<any hour>:08:25` at the time of `new Cron('? ? * * * *', <...>)`. The question mark can be used in any field.
+	-   *L* L can be used in the day of month field, to specify the last day of the month.
+
+*   Croner also allow you to pass a javascript Date object, or a ISO 8601 formatted string, as a pattern. The scheduled function will trigger once at the specified date/time. If you use a timezone different from local, you pass ISO 8601 local time in target location, and specify timezone using the options (2nd parameter).
+
+```javascript
+// ┌──────────────── (optional) second (0 - 59)
+// │ ┌────────────── minute (0 - 59)
+// │ │ ┌──────────── hour (0 - 23)
+// │ │ │ ┌────────── day of month (1 - 31)
+// │ │ │ │ ┌──────── month (1 - 12, JAN-DEC)
+// │ │ │ │ │ ┌────── day of week (0 - 6, SUN-Mon) 
+// │ │ │ │ │ │       (0 to 6 are Sunday to Saturday; 7 is Sunday, the same as 0)
+// │ │ │ │ │ │
+// * * * * * *
+```
+
+| Field        | Required | Allowed values | Allowed special characters | Remarks                               |
+|--------------|----------|----------------|----------------------------|---------------------------------------|
+| Seconds      | Optional | 0-59           | * , - / ?                  |                                       |
+| Minutes      | Yes      | 0-59           | * , - / ?                  |                                       |
+| Hours        | Yes      | 0-23           | * , - / ?                  |                                       |
+| Day of Month | Yes      | 1-31           | * , - / ? L                |                                       |
+| Month        | Yes      | 1-12 or JAN-DEC| * , - / ?                  |                                       |
+| Day of Week  | Yes      | 0-7 or SUN-MON | * , - / ?                  | 0 to 6 are Sunday to Saturday<br>7 is Sunday, the same as 0            |
+
+**Note**: Weekday and month names are case insensitive. Both MON and mon works.
+
+### Examples 
+
+#### Expressions
+```javascript
+// Run a function according to pattern
+Cron('15-45/10 */5 1,2,3 ? JAN-MAR SAT', function () {
+	console.log('This will run every tenth second between second 15-45');
+	console.log('every fifth minute of hour 1,2 and 3 when day of month');
+	console.log('is the same as when Cron started, every saturday in January to March.');
+});
+```
+
+#### Find dates
+```javascript
+// Find next month
+const nextMonth = Cron("0 0 0 1 * *").next(),
+	nextSunday = Cron("0 0 0 * * 7").next(),
+	nextSat29feb = Cron("0 0 0 29 2 6").next(),
+	nextSunLastOfMonth = Cron("0 0 0 L * 7").next();
+
+console.log("First day of next month: " +  nextMonth.toLocaleDateString());
+console.log("Next sunday: " +  nextSunday.toLocaleDateString());
+console.log("Next saturday at 29th of february: " +  nextSat29feb.toLocaleDateString());  // 2048-02-29
+console.log("Next month ending with a sunday: " +  nextSunLastOfMonth.toLocaleDateString()); 
+```
+
+#### With options
+```javascript
+
+const job = Cron(
+	'* * * * *', 
+	{ 
+		maxRuns: Infinity, 
+		startAt: "2021-11-01T00:00:00", 
+		stopAt: "2021-12-01T00:00:00",
+		timezone: "Europe/Stockholm"
+	},
+	function() {
+		console.log('This will run every minute, from 2021-11-01 to 2021-12-01 00:00:00');
+	}
+);
+```
+
+#### Job controls
+```javascript
+const job = Cron('* * * * * *', (self) => {
+	console.log('This will run every second. Pause on second 10. Resume on 15. And quit on 20.');
+	console.log('Current second: ', new Date().getSeconds());
+	console.log('Previous run: ' + self.previous());
+	console.log('Next run: ' + self.next());
+});
+
+Cron('10 * * * * *', {maxRuns: 1}, () => job.pause());
+Cron('15 * * * * *', {maxRuns: 1}, () => job.resume());
+Cron('20 * * * * *', {maxRuns: 1}, () => job.stop());
+```
+
+#### Passing a context
+```javascript
+const data = {
+	what: "stuff"
+};
+
+Cron('* * * * * *', { context: data }, (_self, context) => {
+	console.log('This will print stuff: ' + context.what);
+});
+
+Cron('*/5 * * * * *', { context: data }, (self, context) => {
+	console.log('After this, other stuff will be printed instead');
+	context.what = "other stuff";
+	self.stop();
+});
+```
+
+
+#### Fire on a specific date/time
+```javascript
+// A javascript date, or a ISO 8601 local time string can be passed, to fire a function once. 
+// Always specify which timezone the ISO 8601 time string has with the timezone option.
+let job = Cron("2025-01-01T23:00:00",{timezone: "Europe/Stockholm"},() => {
+	console.log('This will run at 2025-01-01 23:00:00 in timezone Europe/Stockholm');
+});
+
+if (job.next() === null) {
+	// The job will not fire for some reason
+} else {
+	console.log("Job will fire at " + job.next());
+}
+```
+
+## Contributing
+
+See [Contribution Guide](/CONTRIBUTING.md)
+
+## License
+
+MIT

api.hyungi.net/node_modules/croner/SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 4.0.x   | :white_check_mark: |
+| < 4.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Email hexagon@56k.guru. Do NOT report an issue, we will have a look at it asap.

api.hyungi.net/node_modules/croner/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "croner",
+  "version": "4.1.97",
+  "description": "Trigger functions and/or evaluate cron expressions in JavaScript. No dependencies. Most features. All environmens.",
+  "author": "Hexagon <github.com/hexagon>",
+  "homepage": "https://hexagon.github.io/croner",
+  "contributors": [
+    {
+      "name": "Pehr Boman",
+      "email": "github.com/unkelpehr"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hexagon/croner"
+  },
+  "bugs": {
+    "url": "https://github.com/hexagon/croner/issues"
+  },
+  "files": [
+    "dist/*",
+    "src/*",
+    "types/*",
+    "SECURITY.md",
+    "croner.png"
+  ],
+  "keywords": [
+    "cron",
+    "parser",
+    "croner",
+    "sheduler",
+    "timer",
+    "isomorphic"
+  ],
+  "scripts": {
+    "test": "uvu test test.croner.js",
+    "test:dist": "uvu test js && npm run test:ts",
+    "test:coverage": "c8 --include=src npm test",
+    "test:lint": "eslint ./**/*.js ./**/*.cjs",
+    "test:lint:fix": "eslint --fix  ./**/*.js ./**/*.cjs",
+    "test:ts": "tsc --noEmit ./test/ts/basics.ts",
+    "build": "npm update && npm run build:precleanup && npm run test:lint && npm run build:typings && npm run build:dist && npm run build:minify && npm run build:cleanup && npm run test:coverage && npm run test:dist",
+    "build:ci": "npm run test:lint && npm run build:typings && npm run build:dist && npm run build:minify && npm run build:cleanup && npm run test:coverage && npm run test:dist",
+    "build:precleanup": "(rm -rf types/* || del /Q types\\*) && (rm -rf dist/* || del /Q dist\\*)",
+    "build:dist": "rollup -c ./rollup.config.js",
+    "build:minify": "uglifyjs dist/croner.cjs --source-map -o dist/croner.min.js && uglifyjs dist/croner.mjs --source-map -o dist/croner.min.mjs",
+    "build:typings": "tsc",
+    "build:cleanup": "(rm dist/croner.mjs || del dist\\croner.mjs)",
+    "build:docs": "(rm -rf docs/* || rd /S /Q docs) && jsdoc -c .jsdoc.json"
+  },
+  "type": "module",
+  "main": "./dist/croner.cjs",
+  "browser": "./dist/croner.min.js",
+  "module": "./src/croner.js",
+  "types": "types/croner.single.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./src/croner.js",
+      "require": "./dist/croner.cjs",
+      "browser": "./dist/croner.min.js"
+    },
+    "./minified": {
+      "import": "./dist/croner.min.mjs",
+      "require": "./dist/croner.min.js",
+      "browser": "./dist/croner.min.js"
+    }
+  },
+  "devDependencies": {
+    "c8": "^7.10.0",
+    "eslint": "^8.8.0",
+    "jsdoc": "^3.6.7",
+    "jsdoc-chameleon-template": "^1.0.2",
+    "rollup": "^2.59.0",
+    "typescript": "^4.4.4",
+    "uglify-js": "^3.14.3",
+    "uvu": "^0.5.2"
+  },
+  "license": "MIT"
+}

api.hyungi.net/node_modules/croner/src/croner.js

@@ -0,0 +1,329 @@
+/* ------------------------------------------------------------------------------------
+
+  Croner - MIT License - Hexagon <github.com/Hexagon>
+
+  Pure JavaScript Isomorphic cron parser and scheduler without dependencies.
+
+  ------------------------------------------------------------------------------------
+
+  License:
+
+	Copyright (c) 2015-2021 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.
+
+  ------------------------------------------------------------------------------------  */
+import { CronDate } from "./date.js";
+import { CronPattern } from "./pattern.js";
+	
+/**
+ * @typedef {Object} CronOptions - Cron scheduler options
+ * @property {boolean} [paused] - Job is paused
+ * @property {boolean} [kill] - Job is about to be killed or killed
+ * @property {boolean} [catch] - Continue exection even if a unhandled error is thrown by triggered function
+ * @property {number} [maxRuns] - Maximum nuber of executions
+ * @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 {?} [context] - Used to pass any object to scheduled function
+ */
+
+/**
+ * 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. 
+ * 
+ * @type {number}
+ */
+const maxDelay = Math.pow(2, 32 - 1) - 1;
+	
+/**
+ * Cron entrypoint
+ * 
+ * @constructor
+ * @param {string|Date} pattern - Input pattern, input date, or input ISO 8601 time string
+ * @param {CronOptions|Function} [options] - Options
+ * @param {Function} [func] - Function to be run each iteration of pattern
+ * @returns {Cron}
+ */
+function Cron (pattern, options, func) {
+	
+	// Optional "new" keyword
+	if( !(this instanceof Cron) ) {
+		return new Cron(pattern, options, func);
+	}
+	
+	// Make options optional
+	if( typeof options === "function" ) {
+		func = options;
+		options = void 0;
+	}
+	
+	/** @type {CronOptions} */
+	this.options = this.processOptions(options);
+	
+	// Check if we got a date, or a pattern supplied as first argument
+	if (pattern && (pattern instanceof Date)) {
+		this.once = new CronDate(pattern, this.options.timezone);
+	} else if (pattern && (typeof pattern === "string") && pattern.indexOf(":") > 0) {
+		/** @type {CronDate} */
+		this.once = new CronDate(pattern, this.options.timezone);
+	} else {
+		/** @type {CronPattern} */
+		this.pattern = new CronPattern(pattern, this.options.timezone);
+	}
+	
+	/**
+	 * Allow shorthand scheduling
+	 */
+	if( func !== void 0 ) {
+		this.fn = func;
+		this.schedule();
+	}
+	
+	return this;
+	
+}
+	
+/**
+ * Internal function that validates options, and sets defaults
+ * @private
+ * 
+ * @param {CronOptions} options 
+ * @returns {CronOptions}
+ */
+Cron.prototype.processOptions = function (options) {
+	
+	// If no options are passed, create empty object
+	if (options === void 0) {
+		options = {};
+	}
+	
+	// Keep options, or set defaults
+	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.kill = false;
+	
+	// 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);
+	}	
+	
+	return options;
+};
+	
+/**
+ * Find next runtime, based on supplied date. Strips milliseconds.
+ * 
+ * @param {Date|string} [prev] - Date to start from
+ * @returns {Date | null} - Next run time
+ */
+Cron.prototype.next = function (prev) {
+	prev = new CronDate(prev, this.options.timezone);
+	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) {
+	let enumeration = [];
+	
+	while(n-- && (previous = this.next(previous))) {
+		enumeration.push(previous);
+	}
+	
+	return enumeration;
+};
+	
+/**
+ * Is running?
+ * @public
+ * 
+ * @returns {boolean} - Running or not
+ */
+Cron.prototype.running = function () {
+	const msLeft = this.msToNext(this.previousrun);
+	const running = !this.options.paused && this.fn !== void 0;
+	return msLeft !== null && running;
+};
+	
+/**
+ * Return previous run time
+ * @public
+ * 
+ * @returns {Date | null} - Previous run time
+ */
+Cron.prototype.previous = function () {
+	return this.previousrun ? this.previousrun.getDate() : null;
+};
+	
+/**
+ * Internal version of next. Cron needs millseconds internally, hence _next.
+ * @private
+ * 
+ * @param {CronDate} prev - Input pattern
+ * @returns {CronDate | null} - Next run time
+ */
+Cron.prototype._next = function (prev) {
+	
+	// Previous run should never be before startAt
+	if( this.options.startAt && prev && prev.getTime(true) < this.options.startAt.getTime(true) ) {
+		prev = this.options.startAt;
+	}
+	
+	// Calculate next run according to pattern or one-off timestamp
+	const nextRun = this.once || new CronDate(prev, this.options.timezone).increment(this.pattern);
+	
+	if (this.once && this.once.getTime(true) <= prev.getTime(true)) {
+		return null;
+  
+	} else if ((nextRun === null) ||
+		(this.options.maxRuns <= 0) ||	
+		(this.options.kill) ||
+		(this.options.stopAt && nextRun.getTime(true) >= this.options.stopAt.getTime(true) )) {
+		return null;
+
+	} else {
+		// All seem good, return next run
+		return nextRun;
+  
+	}
+		
+};
+	
+/**
+ * Returns number of milliseconds to next run
+ * @public
+ * 
+ * @param {Date} [prev] - Starting date, defaults to now
+ * @returns {number | null}
+ */
+Cron.prototype.msToNext = function (prev) {
+	prev = new CronDate(prev, this.options.timezone);
+	const next = this._next(prev);
+	if( next ) {
+		return (next.getTime(true) - prev.getTime(true));
+	} else {
+		return null;
+	}
+};
+	
+/**
+ * Stop execution 
+ * @public
+ */
+Cron.prototype.stop = function () {
+	this.options.kill = true;
+	// Stop any awaiting call
+	if( this.currentTimeout ) {
+		clearTimeout( this.currentTimeout );
+	}
+};
+	
+/**
+ * Pause executionR
+ * @public
+ * 
+ * @returns {boolean} - Wether pause was successful
+ */
+Cron.prototype.pause = function () {
+	return (this.options.paused = true) && !this.options.kill;
+};
+	
+/**
+ * Pause execution
+ * @public
+ * 
+ * @returns {boolean} - Wether resume was successful
+ */
+Cron.prototype.resume = function () {
+	return !(this.options.paused = false) && !this.options.kill;
+};
+	
+/**
+ * Schedule a new job
+ * @public
+ * 
+ * @param {Function} func - Function to be run each iteration of pattern
+ * @returns {Cron}
+ */
+Cron.prototype.schedule = function (func) {
+	
+	// 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 waitMs is null (no next run)
+	let waitMs = this.msToNext(this.previousrun);
+	if  ( waitMs === null )  return this;
+	
+	// setTimeout cant handle more than Math.pow(2, 32 - 1) - 1 ms
+	if( waitMs > maxDelay ) {
+		waitMs = maxDelay;
+	}
+	
+	// Ok, go!
+	this.currentTimeout = setTimeout(() => {
+	
+		if( waitMs !== maxDelay && !this.options.paused ) {
+	
+			this.options.maxRuns--;
+	
+			// Always catch errors, but only re-throw if options.catch is not set
+			if (this.options.catch) {
+				try {
+					this.fn(this, this.options.context);
+				} catch (_e) {
+					// Ignore
+				}
+			} else {
+				this.fn(this, this.options.context);
+			}
+	
+			this.previousrun = new CronDate(void 0, this.options.timezone);
+	
+		}
+	
+		// Recurse
+		this.schedule();
+	
+	}, waitMs );
+		
+	return this;
+	
+};
+	
+export default Cron;
+export { Cron };

api.hyungi.net/node_modules/croner/src/croner.single.js

@@ -0,0 +1,3 @@
+import Cron from "./croner.js";
+
+export default Cron;

api.hyungi.net/node_modules/croner/src/date.js

@@ -0,0 +1,348 @@
+import convertTZ from "./timezone.js";
+
+/**
+ * Converts date to CronDate
+ * @constructor
+ * 
+ * @param {CronDate|date|string} [date] - Input date, if using string representation ISO 8001 (2015-11-24T19:40:00) local timezone is expected
+ * @param {string} [timezone] - String representation of target timezone in Europe/Stockholm format.
+ */
+function CronDate (date, timezone) {	
+
+	this.timezone = timezone;
+
+	if (date && date instanceof Date) {
+		this.fromDate(date);
+	} else if (date === void 0) {
+		this.fromDate(new Date());
+	} else if (date && typeof date === "string") {
+		this.fromString(date);
+	} else if (date instanceof CronDate) {
+		this.fromCronDate(date);
+	} else {
+		throw new TypeError("CronDate: Invalid type (" + typeof date + ") passed as parameter to CronDate constructor");
+	}
+}
+
+/**
+ * Sets internals using a Date 
+ * @private
+ * 
+ * @param {Date} date - Input date
+ */
+CronDate.prototype.fromDate = function (date) {
+	
+	if (this.timezone) {
+		date = convertTZ(date, this.timezone);
+	}
+
+	this.milliseconds = date.getMilliseconds();
+	this.seconds = date.getSeconds();
+	this.minutes = date.getMinutes();
+	this.hours = date.getHours();
+	this.days = date.getDate();
+	this.months  = date.getMonth();
+	this.years = date.getFullYear();
+
+};
+
+/**
+ * Sets internals by deep copying another CronDate
+ * @private
+ * 
+ * @param {CronDate} date - Input date
+ */
+CronDate.prototype.fromCronDate = function (date) {
+	this.timezone = date.timezone;
+	this.milliseconds = date.milliseconds;
+	this.seconds = date.seconds;
+	this.minutes = date.minutes;
+	this.hours = date.hours;
+	this.days = date.days;
+	this.months = date.months;
+	this.years = date.years;
+};
+
+/**
+ * Reset internal parameters (seconds, minutes, hours) that may have exceeded their ranges
+ * @private
+ * 
+ * @param {Date} date - Input date
+ */
+CronDate.prototype.apply = function () {
+	const newDate = new Date(this.years, this.months, this.days, this.hours, this.minutes, this.seconds, this.milliseconds);
+	
+	this.milliseconds = newDate.getMilliseconds();
+	this.seconds = newDate.getSeconds();
+	this.minutes = newDate.getMinutes();
+	this.hours = newDate.getHours();
+	this.days = newDate.getDate();
+	this.months  = newDate.getMonth();
+	this.years = newDate.getFullYear();
+};
+
+/**
+ * Sets internals by parsing a string
+ * @private
+ * 
+ * @param {Date} date - Input date
+ */
+CronDate.prototype.fromString = function (str) {
+
+	const parsedDate = this.parseISOLocal(str);
+
+	// Throw if we did get an invalid date
+	if( isNaN(parsedDate) ) {
+		throw new TypeError("CronDate: Provided string value for CronDate could not be parsed as date.");
+	}
+	
+	this.fromDate(parsedDate);
+};
+
+/**
+ * Increment to next run time
+ * @public
+ * 
+ * @param {string} pattern - The pattern used to increment current state
+ * @param {boolean} [rerun=false] - If this is an internal incremental run
+ * @return {CronDate|null} - Returns itself for chaining, or null if increment wasnt possible
+ */
+CronDate.prototype.increment = function (pattern, rerun) {
+
+	if (!rerun) {
+		this.seconds += 1;
+	}
+
+	this.milliseconds = 0;
+
+	const 
+		origTime = this.getTime(),
+		
+		/**
+		 * Find next
+		 * 
+		 * @param {string} target
+		 * @param {string} pattern
+		 * @param {string} offset
+		 * @param {string} override
+		 * 
+		 * @returns {boolean}
+		 * 
+		 */
+		findNext = (target, pattern, offset, override) => {
+			
+			const startPos = (override === void 0) ? this[target] + offset : 0 + offset;
+
+			for( let i = startPos; i < pattern[target].length; i++ ) {
+
+				// If pattern matches and, in case of days, weekday matches, go on
+				if( pattern[target][i] ) {
+					
+					// Special handling for L (last day of month), when we are searching for days
+					if (target === "days" && pattern.lastDayOfMonth) {
+						let baseDate = this.getDate(true);
+
+						// Set days to one day after today, if month changes, then we are at the last day of the month
+						baseDate.setDate(i-offset+1);
+						if (baseDate.getMonth() !== this["months"]) {
+							this[target] = i-offset;
+							return true;
+						}
+					
+					// Normal handling
+					} else {
+						this[target] = i-offset;
+						return true;
+					}
+
+				}
+			}
+			return false;
+
+		},
+		
+		resetPrevious = (offset) => {
+			// Now when we have gone to next minute, we have to set seconds to the first match
+			// Now we are at 00:01:05 following the same example.
+			// 
+			// This goes all the way back to seconds, hence the reverse loop.
+			while(doing + offset >= 0) {
+
+				// Ok, reset current member(e.g. seconds) to first match in pattern, using 
+				// the same method as aerlier
+				// 
+				// Note the fourth parameter, stating that we should start matching the pattern
+				// from zero, instead of current time.
+				findNext(toDo[doing + offset][0], pattern, toDo[doing + offset][2], 0);
+
+				// Go back up, days -> hours -> minutes -> seconds
+				doing--;
+			}
+		};
+
+	// Array of work to be done, consisting of subarrays described below:
+	// [
+	//   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 pattern. Offset should be -1
+	// ]
+	const toDo = [
+		["seconds", "minutes", 0],
+		["minutes", "hours", 0],
+		["hours", "days", 0],
+		["days", "months", -1],
+		["months", "years", 0]
+	];
+
+	// Ok, we're working our way trough the toDo array, top to bottom
+	// If we reach 5, work is done
+	let doing = 0;
+	while(doing < 5) {
+
+		// findNext sets the current member to next match in pattern
+		// If time is 00:00:01 and pattern says *:*:05, seconds will
+		// be set to 5
+
+		// Store current value at current level
+		let currentValue = this[toDo[doing][0]];
+		
+		// If pattern didn't provide a match, increment next value (e.g. minues)
+		if(!findNext(toDo[doing][0], pattern, toDo[doing][2])) {
+			this[toDo[doing][1]]++;
+
+			// Reset current level and previous levels
+			resetPrevious(0);
+
+		// If pattern provided a match, but changed current value ...
+		} else if (currentValue !== this[toDo[doing][0]]) {
+			// Reset previous levels
+			resetPrevious(-1);
+
+		}
+
+		// Bail out if an impossible pattern is used
+		if (this.years >= 4000) {
+			return null;
+		}
+
+		// Gp down, seconds -> minutes -> hours -> days -> months -> year
+		doing++;
+	}
+	
+	// This is a special case for weekday, as the user isn't able to combine date/month patterns 
+	// with weekday patterns, it's just to increment days until we get a match.
+	while (!pattern.daysOfWeek[this.getDate(true).getDay()]) {
+		this.days += 1;
+
+		// Reset everything before days
+		doing = 2;
+		resetPrevious();
+	}
+
+	// If anything changed, recreate this CronDate and run again without incrementing
+	if (origTime != this.getTime()) {
+		this.apply();
+		return this.increment(pattern, true);
+	} else {
+		return this;
+	}
+
+};
+
+/**
+ * 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) {
+	const targetDate = new Date(this.years, this.months, this.days, this.hours, this.minutes, this.seconds, this.milliseconds);
+	if (internal || !this.timezone) {
+		return targetDate;
+	} else {
+		const offset = convertTZ(targetDate, this.timezone).getTime()-targetDate.getTime();
+		return new Date(targetDate.getTime()-offset);
+	}
+};
+
+/**
+ * Convert current state back to a javascript Date() and return UTC milliseconds
+ * @public
+ * 
+ * @param {boolean} internal - If this is an internal call
+ * @returns {Date}
+ */
+CronDate.prototype.getTime = function (internal) {
+	return this.getDate(internal).getTime();
+};
+
+/**
+ * Takes a iso 8001 local date time string and creates a Date object
+ * @private
+ * 
+ * @param {string} dateTimeString - an ISO 8001 format date and time string
+ *                      with all components, e.g. 2015-11-24T19:40:00
+ * @returns {Date|number} - Date instance from parsing the string. May be NaN.
+ */
+CronDate.prototype.parseISOLocal = function (dateTimeString) {
+	const dateTimeStringSplit = dateTimeString.split(/\D/);
+
+	// Check for completeness
+	if (dateTimeStringSplit.length < 6) {
+		return NaN;
+	}
+
+	const
+		year = parseInt(dateTimeStringSplit[0], 10),
+		month = parseInt(dateTimeStringSplit[1], 10),
+		day = parseInt(dateTimeStringSplit[2], 10),
+		hour = parseInt(dateTimeStringSplit[3], 10),
+		minute = parseInt(dateTimeStringSplit[4], 10),
+		second = parseInt(dateTimeStringSplit[5], 10);
+
+	// Check parts for numeric
+	if( isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hour) || isNaN(minute) || isNaN(second) ) {
+		return NaN;
+	} else {
+		let generatedDate;
+
+		// Check for UTC flag
+		if ((dateTimeString.indexOf("Z") > 0)) {
+
+			// Handle date as UTC
+			generatedDate = new Date(Date.UTC(year, month-1, day, hour, minute, second));
+
+			// Check generated date
+			if (year == generatedDate.getUTCFullYear()
+				&& month == generatedDate.getUTCMonth()+1
+				&& day == generatedDate.getUTCDate()
+				&& hour == generatedDate.getUTCHours()
+				&& minute == generatedDate.getUTCMinutes()
+				&& second == generatedDate.getUTCSeconds()) {
+				return generatedDate;
+			} else {
+				return NaN;
+			}
+		} else {
+
+			// Handle date as local time
+			generatedDate = new Date(year, month-1, day, hour, minute, second);
+
+			// Check generated date
+			if (year == generatedDate.getFullYear()
+				&& month == generatedDate.getMonth()+1
+				&& day == generatedDate.getDate()
+				&& hour == generatedDate.getHours()
+				&& minute == generatedDate.getMinutes()
+				&& second == generatedDate.getSeconds()) {
+				return generatedDate;
+			} else {
+				return NaN;
+			}
+		}
+	}
+};
+
+export { CronDate };

api.hyungi.net/node_modules/croner/src/pattern.js

@@ -0,0 +1,336 @@
+import { CronDate } from "./date.js";
+
+/**
+ * Name for each part of the cron pattern
+ * @typedef {("seconds" | "minutes" | "hours" | "days" | "months" | "daysOfWeek")} CronPatternPart
+ */
+
+/**
+ * Offset, 0 or -1. 
+ * 
+ * 0 for seconds,minutes and hours as they start on 1. 
+ * -1 on days and months, as the 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.seconds        = Array(60).fill(0); // 0-59
+	this.minutes        = Array(60).fill(0); // 0-59
+	this.hours          = Array(24).fill(0); // 0-23
+	this.days           = Array(31).fill(0); // 0-30 in array, 1-31 in config
+	this.months         = Array(12).fill(0); // 0-11 in array, 1-12 in config
+	this.daysOfWeek     = Array(8).fill(0);  // 0-7 Where 0 = Sunday and 7=Sunday;
+
+	this.lastDayOfMonth = false;
+
+	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.");
+	}
+
+	// Split configuration on whitespace
+	const parts = this.pattern.trim().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 '*' and add lastDayOfMonth flag,
+	// and set days to 28,29,30,31 as those are the only days that can be the last day of month
+	if(parts[3].toUpperCase() == "L") {
+		parts[3] = "28,29,30,31";
+		this.lastDayOfMonth = true;
+	}
+
+	// Replace alpha representations
+	parts[4] = this.replaceAlphaMonths(parts[4]);
+	parts[5] = this.replaceAlphaDays(parts[5]);
+
+	// Implement '?' in the simplest possible way - replace ? with current value, before further processing
+	let 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());
+	parts[3] = parts[3].replace("?", initDate.getDate());
+	parts[4] = parts[4].replace("?", initDate.getMonth()+1); // getMonth is zero indexed while pattern starts from 1
+	parts[5] = parts[5].replace("?", initDate.getDay());
+
+	// Check part content
+	this.throwAtIllegalCharacters(parts);
+
+	// Parse parts into arrays, validates as we go
+	this.partToArray("seconds",    parts[0], 0);
+	this.partToArray("minutes",    parts[1], 0);
+	this.partToArray("hours",      parts[2], 0);
+	this.partToArray("days",       parts[3], -1);
+	this.partToArray("months",     parts[4], -1);
+	this.partToArray("daysOfWeek", parts[5], 0);
+
+	// 0 = Sunday, 7 = Sunday
+	if( this.daysOfWeek[7] ) {
+		this.daysOfWeek[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, recursed) {
+
+	const arr = this[type];
+
+	// First off, handle wildcard
+	if( conf === "*" ) {
+		for( let i = 0; i < arr.length; i++ ) {
+			arr[i] = 1;
+		}
+		return;
+	}
+
+	// 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, true);
+		}
+
+	// Handle range with stepping (x-y/z)
+	} else if( conf.indexOf("-") !== -1 && conf.indexOf("/") !== -1 ) {
+		if (recursed) throw new Error("CronPattern: Range with stepping cannot coexist with ,");
+
+		this.handleRangeWithStepping(conf, type, valueIndexOffset);
+	
+	// Handle range
+	} else if( conf.indexOf("-") !== -1 ) {
+		if (recursed) throw new Error("CronPattern: Range with stepping cannot coexist with ,");
+
+		this.handleRange(conf, type, valueIndexOffset);
+
+	// Handle stepping
+	} else if( conf.indexOf("/") !== -1 ) {
+		if (recursed) throw new Error("CronPattern: Range with stepping cannot coexist with ,");
+
+		this.handleStepping(conf, type, valueIndexOffset);
+
+	} else {
+		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( 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, steps cannot be greater than maximum value of part ("+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, "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");
+};
+
+export { CronPattern };

api.hyungi.net/node_modules/croner/src/timezone.js

@@ -0,0 +1,21 @@
+/**
+ * "Converts" a date to a specific time zone
+ * 
+ * Note: This is only for specific and controlled usage, 
+ * as the internal UTC time of the resulting object will be off.
+ * 
+ * Example:
+ *   let normalDate = new Date(); // d is a normal Date instance, with local timezone and correct utc representation
+ *       tzDate = convertTZ(d, 'America/New_York') // d is a tainted Date instance, where getHours() 
+ *                                                 (for example) will return local time in new york, but getUTCHours()
+ *                                                 will return something irrelevant.
+ * 
+ * @param {Date} date - Input date
+ * @param {string} tzString - Timezone string in Europe/Stockholm format
+ * @returns {Date}
+ */
+function convertTZ(date, tzString) {
+	return new Date(date.toLocaleString("en-US", {timeZone: tzString}));   
+}   
+
+export default convertTZ;

api.hyungi.net/node_modules/croner/types/croner.d.ts

@@ -0,0 +1,136 @@
+export default Cron;
+/**
+ * - Cron scheduler options
+ */
+export type CronOptions = {
+    /**
+     * - Job is paused
+     */
+    paused?: boolean;
+    /**
+     * - Job is about to be killed or killed
+     */
+    kill?: boolean;
+    /**
+     * - Continue exection even if a unhandled error is thrown by triggered function
+     */
+    catch?: boolean;
+    /**
+     * - Maximum nuber of executions
+     */
+    maxRuns?: number;
+    /**
+     * - When to start running
+     */
+    startAt?: string | Date;
+    /**
+     * - When to stop running
+     */
+    stopAt?: string | Date;
+    /**
+     * - Time zone in Europe/Stockholm format
+     */
+    timezone?: string;
+    /**
+     * - Used to pass any object to scheduled function
+     */
+    context?: unknown;
+};
+/**
+ * Cron entrypoint
+ *
+ * @constructor
+ * @param {string|Date} pattern - Input pattern, input date, or input ISO 8601 time string
+ * @param {CronOptions|Function} [options] - Options
+ * @param {Function} [func] - Function to be run each iteration of pattern
+ * @returns {Cron}
+ */
+export function Cron(pattern: string | Date, options?: CronOptions | Function, func?: Function): Cron;
+export class Cron {
+    /**
+     * Cron entrypoint
+     *
+     * @constructor
+     * @param {string|Date} pattern - Input pattern, input date, or input ISO 8601 time string
+     * @param {CronOptions|Function} [options] - Options
+     * @param {Function} [func] - Function to be run each iteration of pattern
+     * @returns {Cron}
+     */
+    constructor(pattern: string | Date, options?: CronOptions | Function, func?: Function);
+    /** @type {CronOptions} */
+    options: CronOptions;
+    once: CronDate;
+    /** @type {CronPattern} */
+    pattern: CronPattern;
+    fn: Function;
+    private processOptions;
+    /**
+     * Find next runtime, based on supplied date. Strips milliseconds.
+     *
+     * @param {Date|string} [prev] - Date to start from
+     * @returns {Date | null} - Next run time
+     */
+    next(prev?: Date | string): Date | 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
+     */
+    enumerate(n: number, previous?: Date | string): Date[];
+    /**
+     * Is running?
+     * @public
+     *
+     * @returns {boolean} - Running or not
+     */
+    public running(): boolean;
+    /**
+     * Return previous run time
+     * @public
+     *
+     * @returns {Date | null} - Previous run time
+     */
+    public previous(): Date | null;
+    private _next;
+    /**
+     * Returns number of milliseconds to next run
+     * @public
+     *
+     * @param {Date} [prev] - Starting date, defaults to now
+     * @returns {number | null}
+     */
+    public msToNext(prev?: Date): number | null;
+    /**
+     * Stop execution
+     * @public
+     */
+    public stop(): void;
+    /**
+     * Pause executionR
+     * @public
+     *
+     * @returns {boolean} - Wether pause was successful
+     */
+    public pause(): boolean;
+    /**
+     * Pause execution
+     * @public
+     *
+     * @returns {boolean} - Wether resume was successful
+     */
+    public resume(): boolean;
+    /**
+     * Schedule a new job
+     * @public
+     *
+     * @param {Function} func - Function to be run each iteration of pattern
+     * @returns {Cron}
+     */
+    public schedule(func: Function): Cron;
+    currentTimeout: number;
+    previousrun: CronDate;
+}
+import { CronDate } from "./date.js";
+import { CronPattern } from "./pattern.js";

api.hyungi.net/node_modules/croner/types/croner.single.d.ts

@@ -0,0 +1,2 @@
+export default Cron;
+import Cron from "./croner.js";

api.hyungi.net/node_modules/croner/types/date.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Converts date to CronDate
+ * @constructor
+ *
+ * @param {CronDate|date|string} [date] - Input date, if using string representation ISO 8001 (2015-11-24T19:40:00) local timezone is expected
+ * @param {string} [timezone] - String representation of target timezone in Europe/Stockholm format.
+ */
+export function CronDate(date?: any, timezone?: string): void;
+export class CronDate {
+    /**
+     * Converts date to CronDate
+     * @constructor
+     *
+     * @param {CronDate|date|string} [date] - Input date, if using string representation ISO 8001 (2015-11-24T19:40:00) local timezone is expected
+     * @param {string} [timezone] - String representation of target timezone in Europe/Stockholm format.
+     */
+    constructor(date?: any, timezone?: string);
+    timezone: string;
+    private fromDate;
+    milliseconds: any;
+    seconds: any;
+    minutes: any;
+    hours: any;
+    days: any;
+    months: any;
+    years: any;
+    private fromCronDate;
+    private apply;
+    private fromString;
+    /**
+     * Increment to next run time
+     * @public
+     *
+     * @param {string} pattern - The pattern used to increment current state
+     * @param {boolean} [rerun=false] - If this is an internal incremental run
+     * @return {CronDate|null} - Returns itself for chaining, or null if increment wasnt possible
+     */
+    public increment(pattern: string, rerun?: boolean): CronDate | null;
+    /**
+     * Convert current state back to a javascript Date()
+     * @public
+     *
+     * @param {boolean} internal - If this is an internal call
+     * @returns {Date}
+     */
+    public getDate(internal: boolean): Date;
+    /**
+     * Convert current state back to a javascript Date() and return UTC milliseconds
+     * @public
+     *
+     * @param {boolean} internal - If this is an internal call
+     * @returns {Date}
+     */
+    public getTime(internal: boolean): Date;
+    private parseISOLocal;
+}

api.hyungi.net/node_modules/croner/types/pattern.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Name for each part of the cron pattern
+ */
+export type CronPatternPart = ("seconds" | "minutes" | "hours" | "days" | "months" | "daysOfWeek");
+/**
+ * Offset, 0 or -1.
+ *
+ * 0 for seconds,minutes and hours as they start on 1.
+ * -1 on days and months, as the start on 0
+ */
+export type CronIndexOffset = number;
+/**
+ * Name for each part of the cron pattern
+ * @typedef {("seconds" | "minutes" | "hours" | "days" | "months" | "daysOfWeek")} CronPatternPart
+ */
+/**
+ * Offset, 0 or -1.
+ *
+ * 0 for seconds,minutes and hours as they start on 1.
+ * -1 on days and months, as the 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
+ */
+export function CronPattern(pattern: string, timezone: string): void;
+export class CronPattern {
+    /**
+     * Name for each part of the cron pattern
+     * @typedef {("seconds" | "minutes" | "hours" | "days" | "months" | "daysOfWeek")} CronPatternPart
+     */
+    /**
+     * Offset, 0 or -1.
+     *
+     * 0 for seconds,minutes and hours as they start on 1.
+     * -1 on days and months, as the 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
+     */
+    constructor(pattern: string, timezone: string);
+    pattern: string;
+    timezone: string;
+    seconds: any;
+    minutes: any;
+    hours: any;
+    days: any;
+    months: any;
+    daysOfWeek: any;
+    lastDayOfMonth: boolean;
+    private parse;
+    private partToArray;
+    private throwAtIllegalCharacters;
+    private handleNumber;
+    private handleRangeWithStepping;
+    private handleRange;
+    private handleStepping;
+    private replaceAlphaDays;
+    private replaceAlphaMonths;
+}

api.hyungi.net/node_modules/croner/types/timezone.d.ts

@@ -0,0 +1,18 @@
+export default convertTZ;
+/**
+ * "Converts" a date to a specific time zone
+ *
+ * Note: This is only for specific and controlled usage,
+ * as the internal UTC time of the resulting object will be off.
+ *
+ * Example:
+ *   let normalDate = new Date(); // d is a normal Date instance, with local timezone and correct utc representation
+ *       tzDate = convertTZ(d, 'America/New_York') // d is a tainted Date instance, where getHours()
+ *                                                 (for example) will return local time in new york, but getUTCHours()
+ *                                                 will return something irrelevant.
+ *
+ * @param {Date} date - Input date
+ * @param {string} tzString - Timezone string in Europe/Stockholm format
+ * @returns {Date}
+ */
+declare function convertTZ(date: Date, tzString: string): Date;