Added node-cron and pm2. The bot will now use pm2 start bot.js and will restart every day at midnight, EST.

2024-05-09 19:45:20 -04:00 · 2024-05-09 19:45:20 -04:00 · 96b98a2a80
parent 154945b5b4
commit 96b98a2a80
115 changed files with 4990 additions and 2 deletions
--- a/node_modules/.bin/uuid
+++ b/node_modules/.bin/uuid
@ -0,0 +1 @@
+../uuid/dist/bin/uuid
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
@ -1,5 +1,5 @@
 {
-  "name": "discord-bot",
+  "name": "classicfm-discord-bot",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
@ -661,6 +661,17 @@
      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA=="
    },
+    "node_modules/node-cron": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-3.0.3.tgz",
+      "integrity": "sha512-dOal67//nohNgYWb+nWmg5dkFdIwDm8EpeGYMekPMrngV3637lqnX0lbUcCtgibHTz6SEz7DAIjKvKDFYCnO1A==",
+      "dependencies": {
+        "uuid": "8.3.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
    "node_modules/node-domexception": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
@ -932,6 +943,14 @@
      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
    },
+    "node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
    "node_modules/web-streams-polyfill": {
      "version": "3.3.3",
      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
--- a/node_modules/node-cron/.circleci/config.yml
+++ b/node_modules/node-cron/.circleci/config.yml
@ -0,0 +1,17 @@
+version: 2.1
+
+jobs:
+  test:
+    docker:
+      - image: cimg/node:17.4
+        environment:
+          TZ: "America/Sao_Paulo"
+    steps:
+      - checkout
+      - run: npm install
+      - run: COVERALLS_GIT_BRANCH=$CIRCLE_BRANCH npm run check
+
+workflows:
+  build:
+    jobs:
+      - test
--- a/node_modules/node-cron/.covignore
+++ b/node_modules/node-cron/.covignore
@ -0,0 +1 @@
+/node_modules/
--- a/node_modules/node-cron/.eslintrc.yml
+++ b/node_modules/node-cron/.eslintrc.yml
@ -0,0 +1,20 @@
+env:
+  es6: true
+  node: true
+  mocha: true
+extends: 'eslint:recommended'
+parserOptions:
+  ecmaVersion: 2018
+rules:
+  indent:
+    - error
+    - 4
+  linebreak-style:
+    - error
+    - unix
+  quotes:
+    - error
+    - single
+  semi:
+    - error
+    - always
--- a/node_modules/node-cron/.github/stale.yml
+++ b/node_modules/node-cron/.github/stale.yml
@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
--- a/node_modules/node-cron/LICENSE.md
+++ b/node_modules/node-cron/LICENSE.md
@ -0,0 +1,7 @@
+## ISC License
+
+Copyright (c) 2016, Lucas Merencia \<lucas.merencia@gmail.com\>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--- a/node_modules/node-cron/README.md
+++ b/node_modules/node-cron/README.md
@ -0,0 +1,247 @@
+# Node Cron
+
+[![npm](https://img.shields.io/npm/l/node-cron.svg)](https://github.com/merencia/node-cron/blob/master/LICENSE.md)
+[![npm](https://img.shields.io/npm/v/node-cron.svg)](https://img.shields.io/npm/v/node-cron.svg)
+[![Coverage Status](https://coveralls.io/repos/github/node-cron/node-cron/badge.svg?branch=master)](https://coveralls.io/github/node-cron/node-cron?branch=master)
+[![Code Climate](https://codeclimate.com/github/node-cron/node-cron/badges/gpa.svg)](https://codeclimate.com/github/merencia/node-cron)
+[![Build Status](https://travis-ci.org/node-cron/node-cron.svg?branch=master)](https://travis-ci.org/merencia/node-cron)
+[![Dependency Status](https://david-dm.org/node-cron/node-cron.svg)](https://david-dm.org/merencia/node-cron)
+[![devDependency Status](https://david-dm.org/node-cron/node-cron/dev-status.svg)](https://david-dm.org/merencia/node-cron#info=devDependencies)
+[![Backers on Open Collective](https://opencollective.com/node-cron/backers/badge.svg)](#backers) 
+[![Sponsors on Open Collective](https://opencollective.com/node-cron/sponsors/badge.svg)](#sponsors) 
+
+The node-cron module is tiny task scheduler in pure JavaScript for node.js based on [GNU crontab](https://www.gnu.org/software/mcron/manual/html_node/Crontab-file.html). This module allows you to schedule task in node.js using full crontab syntax.
+
+**Need a job scheduler with support for worker threads and cron syntax?** Try out the [Bree](https://github.com/breejs/bree) job scheduler!
+
+[![NPM](https://nodei.co/npm/node-cron.png?downloads=true&downloadRank=true&stars=false)](https://nodei.co/npm/node-cron/)
+
+
+## Getting Started
+
+Install node-cron using npm:
+
+```console
+npm install --save node-cron
+```
+
+Import node-cron and schedule a task:
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('* * * * *', () => {
+  console.log('running a task every minute');
+});
+```
+
+## Cron Syntax
+
+This is a quick reference to cron syntax and also shows the options supported by node-cron.
+
+### Allowed fields
+
+```
+ # ┌────────────── second (optional)
+ # │ ┌──────────── minute
+ # │ │ ┌────────── hour
+ # │ │ │ ┌──────── day of month
+ # │ │ │ │ ┌────── month
+ # │ │ │ │ │ ┌──── day of week
+ # │ │ │ │ │ │
+ # │ │ │ │ │ │
+ # * * * * * *
+```
+
+### Allowed values
+
+|     field    |        value        |
+|--------------|---------------------|
+|    second    |         0-59        |
+|    minute    |         0-59        |
+|     hour     |         0-23        |
+| day of month |         1-31        |
+|     month    |     1-12 (or names) |
+|  day of week |     0-7 (or names, 0 or 7 are sunday)  |
+
+
+#### Using multiples values
+
+You may use multiples values separated by comma:
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('1,2,4,5 * * * *', () => {
+  console.log('running every minute 1, 2, 4 and 5');
+});
+```
+
+#### Using ranges
+
+You may also define a range of values:
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('1-5 * * * *', () => {
+  console.log('running every minute to 1 from 5');
+});
+```
+
+#### Using step values
+
+Step values can be used in conjunction with ranges, following a range with '/' and a number. e.g: `1-10/2` that is the same as `2,4,6,8,10`. Steps are also permitted after an asterisk, so if you want to say “every two minutes”, just use `*/2`.
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('*/2 * * * *', () => {
+  console.log('running a task every two minutes');
+});
+```
+
+#### Using names
+
+For month and week day you also may use names or short names. e.g:
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('* * * January,September Sunday', () => {
+  console.log('running on Sundays of January and September');
+});
+```
+
+Or with short names:
+
+```javascript
+var cron = require('node-cron');
+
+cron.schedule('* * * Jan,Sep Sun', () => {
+  console.log('running on Sundays of January and September');
+});
+```
+
+## Cron methods
+
+### Schedule
+
+Schedules given task to be executed whenever the cron expression ticks.
+
+Arguments:
+
+- **expression** `string`: Cron expression
+- **function** `Function`: Task to be executed
+- **options** `Object`: Optional configuration for job scheduling.
+
+#### Options
+
+ - **scheduled**: A `boolean` to set if the created task is scheduled. Default `true`;
+ - **timezone**: The timezone that is used for job scheduling. See [IANA time zone database](https://www.iana.org/time-zones) for valid values, such as `Asia/Shanghai`, `Asia/Kolkata`, `America/Sao_Paulo`.
+
+ **Example**:
+
+ ```js
+  var cron = require('node-cron');
+
+  cron.schedule('0 1 * * *', () => {
+    console.log('Running a job at 01:00 at America/Sao_Paulo timezone');
+  }, {
+    scheduled: true,
+    timezone: "America/Sao_Paulo"
+  });
+ ```
+
+## ScheduledTask methods
+
+### Start
+
+Starts the scheduled task.
+
+```javascript
+var cron = require('node-cron');
+
+var task = cron.schedule('* * * * *', () =>  {
+  console.log('stopped task');
+}, {
+  scheduled: false
+});
+
+task.start();
+```
+
+### Stop
+
+The task won't be executed unless re-started.
+
+```javascript
+var cron = require('node-cron');
+
+var task = cron.schedule('* * * * *', () =>  {
+  console.log('will execute every minute until stopped');
+});
+
+task.stop();
+```
+
+### Validate
+
+Validate that the given string is a valid cron expression.
+
+```javascript
+var cron = require('node-cron');
+
+var valid = cron.validate('59 * * * *');
+var invalid = cron.validate('60 * * * *');
+```
+
+## Issues
+
+Feel free to submit issues and enhancement requests [here](https://github.com/merencia/node-cron/issues).
+
+## Contributing
+
+In general, we follow the "fork-and-pull" Git workflow.
+
+ - Fork the repo on GitHub;
+ - Commit changes to a branch in your fork;
+ - Pull request "upstream" with your changes;
+
+NOTE: Be sure to merge the latest from "upstream" before making a pull request!
+
+Please do not contribute code you did not write yourself, unless you are certain you have the legal ability to do so. Also ensure all contributed code can be distributed under the ISC License.
+
+## Contributors
+
+This project exists thanks to all the people who contribute. 
+<a href="https://github.com/node-cron/node-cron/graphs/contributors"><img src="https://opencollective.com/node-cron/contributors.svg?width=890&button=false" /></a>
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/node-cron#backer)]
+
+<a href="https://opencollective.com/node-cron#backers" target="_blank"><img src="https://opencollective.com/node-cron/backers.svg?width=890"></a>
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/node-cron#sponsor)]
+
+<a href="https://opencollective.com/node-cron/sponsor/0/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/1/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/2/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/3/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/4/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/5/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/6/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/7/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/8/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/node-cron/sponsor/9/website" target="_blank"><img src="https://opencollective.com/node-cron/sponsor/9/avatar.svg"></a>
+
+
+
+## License
+
+node-cron is under [ISC License](https://github.com/merencia/node-cron/blob/master/LICENSE.md).
--- a/node_modules/node-cron/package.json
+++ b/node_modules/node-cron/package.json
@ -0,0 +1,43 @@
+{
+  "name": "node-cron",
+  "version": "3.0.3",
+  "description": "A simple cron-like task scheduler for Node.js",
+  "author": "Lucas Merencia",
+  "license": "ISC",
+  "homepage": "https://github.com/merencia/node-cron",
+  "main": "src/node-cron.js",
+  "scripts": {
+    "test": "nyc --reporter=html --reporter=text mocha --recursive",
+    "lint": "./node_modules/.bin/eslint ./src ./test",
+    "check": "npm run lint && npm test"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/merencia/node-cron.git"
+  },
+  "keywords": [
+    "cron",
+    "scheduler",
+    "schedule",
+    "task",
+    "job"
+  ],
+  "bugs": {
+    "url": "https://github.com/merencia/node-cron/issues"
+  },
+  "dependencies": {
+    "uuid": "8.3.2"
+  },
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "^5.7.0",
+    "istanbul": "^0.4.2",
+    "mocha": "^6.1.4",
+    "moment-timezone": "^0.5.33",
+    "nyc": "^14.0.0",
+    "sinon": "^7.3.2"
+  }
+}
--- a/node_modules/node-cron/src/background-scheduled-task/daemon.js
+++ b/node_modules/node-cron/src/background-scheduled-task/daemon.js
@ -0,0 +1,19 @@
+const ScheduledTask = require('../scheduled-task');
+
+let scheduledTask;
+
+function register(message){
+    const script = require(message.path);
+    scheduledTask = new ScheduledTask(message.cron, script.task, message.options);
+    scheduledTask.on('task-done', (result) => {
+        process.send({ type: 'task-done', result});
+    });
+    process.send({ type: 'registred' });
+}
+
+process.on('message', (message) => {
+    switch(message.type){
+    case 'register':
+        return register(message);
+    }
+});
--- a/node_modules/node-cron/src/background-scheduled-task/index.js
+++ b/node_modules/node-cron/src/background-scheduled-task/index.js
@ -0,0 +1,67 @@
+const EventEmitter = require('events');
+const path = require('path');
+const { fork } = require('child_process');
+const uuid = require('uuid');
+
+const daemonPath = `${__dirname}/daemon.js`;
+
+class BackgroundScheduledTask extends EventEmitter {
+    constructor(cronExpression, taskPath, options){
+        super();
+        if(!options){
+            options = {
+                scheduled: true,
+                recoverMissedExecutions: false,
+            };
+        }
+        this.cronExpression = cronExpression;
+        this.taskPath = taskPath;
+        this.options = options;
+        this.options.name = this.options.name || uuid.v4();
+
+        if(options.scheduled){
+            this.start();
+        }
+    }
+
+    start() {
+        this.stop();
+        this.forkProcess = fork(daemonPath);
+
+        this.forkProcess.on('message', (message) => {
+            switch(message.type){
+            case 'task-done':
+                this.emit('task-done', message.result);
+                break;
+            }
+        });
+
+        let options = this.options;
+        options.scheduled = true;
+        
+        this.forkProcess.send({
+            type: 'register',
+            path: path.resolve(this.taskPath),
+            cron: this.cronExpression,
+            options: options
+        });
+    }
+    
+    stop(){
+        if(this.forkProcess){
+            this.forkProcess.kill();
+        }
+    }
+
+    pid() {
+        if(this.forkProcess){
+            return this.forkProcess.pid;
+        }
+    }
+
+    isRunning(){
+        return !this.forkProcess.killed;
+    }
+}
+
+module.exports = BackgroundScheduledTask;
--- a/node_modules/node-cron/src/convert-expression/asterisk-to-range-conversion.js
+++ b/node_modules/node-cron/src/convert-expression/asterisk-to-range-conversion.js
@ -0,0 +1,21 @@
+'use strict';
+module.exports = (() => {
+    function convertAsterisk(expression, replecement){
+        if(expression.indexOf('*') !== -1){
+            return expression.replace('*', replecement);
+        }
+        return expression;
+    }
+
+    function convertAsterisksToRanges(expressions){
+        expressions[0] = convertAsterisk(expressions[0], '0-59');
+        expressions[1] = convertAsterisk(expressions[1], '0-59');
+        expressions[2] = convertAsterisk(expressions[2], '0-23');
+        expressions[3] = convertAsterisk(expressions[3], '1-31');
+        expressions[4] = convertAsterisk(expressions[4], '1-12');
+        expressions[5] = convertAsterisk(expressions[5], '0-6');
+        return expressions;
+    }
+
+    return convertAsterisksToRanges;
+})();
--- a/node_modules/node-cron/src/convert-expression/index.js
+++ b/node_modules/node-cron/src/convert-expression/index.js
@ -0,0 +1,66 @@
+'use strict';
+
+const monthNamesConversion = require('./month-names-conversion');
+const weekDayNamesConversion = require('./week-day-names-conversion');
+const convertAsterisksToRanges = require('./asterisk-to-range-conversion');
+const convertRanges = require('./range-conversion');
+const convertSteps = require('./step-values-conversion');
+
+module.exports = (() => {
+
+    function appendSeccondExpression(expressions){
+        if(expressions.length === 5){
+            return ['0'].concat(expressions);
+        }
+        return expressions;
+    }
+
+    function removeSpaces(str) {
+        return str.replace(/\s{2,}/g, ' ').trim();
+    }
+
+    // Function that takes care of normalization.
+    function normalizeIntegers(expressions) {
+        for (let i=0; i < expressions.length; i++){
+            const numbers = expressions[i].split(',');
+            for (let j=0; j<numbers.length; j++){
+                numbers[j] = parseInt(numbers[j]);
+            }
+            expressions[i] = numbers;
+        }
+        return expressions;
+    }
+
+    /*
+   * The node-cron core allows only numbers (including multiple numbers e.g 1,2).
+   * This module is going to translate the month names, week day names and ranges
+   * to integers relatives.
+   *
+   * Month names example:
+   *  - expression 0 1 1 January,Sep *
+   *  - Will be translated to 0 1 1 1,9 *
+   *
+   * Week day names example:
+   *  - expression 0 1 1 2 Monday,Sat
+   *  - Will be translated to 0 1 1 1,5 *
+   *
+   * Ranges example:
+   *  - expression 1-5 * * * *
+   *  - Will be translated to 1,2,3,4,5 * * * *
+   */
+    function interprete(expression){
+        let expressions = removeSpaces(expression).split(' ');
+        expressions = appendSeccondExpression(expressions);
+        expressions[4] = monthNamesConversion(expressions[4]);
+        expressions[5] = weekDayNamesConversion(expressions[5]);
+        expressions = convertAsterisksToRanges(expressions);
+        expressions = convertRanges(expressions);
+        expressions = convertSteps(expressions);
+
+        expressions = normalizeIntegers(expressions);
+
+        return expressions.join(' ');
+    }
+
+    return interprete;
+})();
--- a/node_modules/node-cron/src/convert-expression/month-names-conversion.js
+++ b/node_modules/node-cron/src/convert-expression/month-names-conversion.js
@ -0,0 +1,22 @@
+'use strict';
+module.exports = (() => {
+    const months = ['january','february','march','april','may','june','july',
+        'august','september','october','november','december'];
+    const shortMonths = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
+        'sep', 'oct', 'nov', 'dec'];
+
+    function convertMonthName(expression, items){
+        for(let i = 0; i < items.length; i++){
+            expression = expression.replace(new RegExp(items[i], 'gi'), parseInt(i, 10) + 1);
+        }
+        return expression;
+    }
+
+    function interprete(monthExpression){
+        monthExpression = convertMonthName(monthExpression, months);
+        monthExpression = convertMonthName(monthExpression, shortMonths);
+        return monthExpression;
+    }
+
+    return interprete;
+})();
--- a/node_modules/node-cron/src/convert-expression/range-conversion.js
+++ b/node_modules/node-cron/src/convert-expression/range-conversion.js
@ -0,0 +1,39 @@
+'use strict';
+module.exports = ( () => {
+    function replaceWithRange(expression, text, init, end) {
+
+        const numbers = [];
+        let last = parseInt(end);
+        let first = parseInt(init);
+
+        if(first > last){
+            last = parseInt(init);
+            first = parseInt(end);
+        }
+
+        for(let i = first; i <= last; i++) {
+            numbers.push(i);
+        }
+
+        return expression.replace(new RegExp(text, 'i'), numbers.join());
+    }
+
+    function convertRange(expression){
+        const rangeRegEx = /(\d+)-(\d+)/;
+        let match = rangeRegEx.exec(expression);
+        while(match !== null && match.length > 0){
+            expression = replaceWithRange(expression, match[0], match[1], match[2]);
+            match = rangeRegEx.exec(expression);
+        }
+        return expression;
+    }
+
+    function convertAllRanges(expressions){
+        for(let i = 0; i < expressions.length; i++){
+            expressions[i] = convertRange(expressions[i]);
+        }
+        return expressions;
+    }
+
+    return convertAllRanges;
+})();
--- a/node_modules/node-cron/src/convert-expression/step-values-conversion.js
+++ b/node_modules/node-cron/src/convert-expression/step-values-conversion.js
@ -0,0 +1,30 @@
+'use strict';
+
+module.exports = (() => {
+    function convertSteps(expressions){
+        var stepValuePattern = /^(.+)\/(\w+)$/;
+        for(var i = 0; i < expressions.length; i++){
+            var match = stepValuePattern.exec(expressions[i]);
+            var isStepValue = match !== null && match.length > 0;
+            if(isStepValue){
+                var baseDivider = match[2];
+                if(isNaN(baseDivider)){
+                    throw baseDivider + ' is not a valid step value';
+                }
+                var values = match[1].split(',');
+                var stepValues = [];
+                var divider = parseInt(baseDivider, 10);
+                for(var j = 0; j <= values.length; j++){
+                    var value = parseInt(values[j], 10);
+                    if(value % divider === 0){
+                        stepValues.push(value);
+                    }
+                }
+                expressions[i] = stepValues.join(',');
+            }
+        }
+        return expressions;
+    }
+
+    return convertSteps;
+})();
--- a/node_modules/node-cron/src/convert-expression/week-day-names-conversion.js
+++ b/node_modules/node-cron/src/convert-expression/week-day-names-conversion.js
@ -0,0 +1,21 @@
+'use strict';
+module.exports = (() => {
+    const weekDays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
+        'friday', 'saturday'];
+    const shortWeekDays = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+    function convertWeekDayName(expression, items){
+        for(let i = 0; i < items.length; i++){
+            expression = expression.replace(new RegExp(items[i], 'gi'), parseInt(i, 10));
+        }
+        return expression;
+    }
+  
+    function convertWeekDays(expression){
+        expression = expression.replace('7', '0');
+        expression = convertWeekDayName(expression, weekDays);
+        return convertWeekDayName(expression, shortWeekDays);
+    }
+
+    return convertWeekDays;
+})();
--- a/node_modules/node-cron/src/node-cron.js
+++ b/node_modules/node-cron/src/node-cron.js
@ -0,0 +1,64 @@
+'use strict';
+
+const ScheduledTask = require('./scheduled-task');
+const BackgroundScheduledTask = require('./background-scheduled-task');
+const validation = require('./pattern-validation');
+const storage = require('./storage');
+
+/**
+ * @typedef {Object} CronScheduleOptions
+ * @prop {boolean} [scheduled] if a scheduled task is ready and running to be
+ *  performed when the time matches the cron expression.
+ * @prop {string} [timezone] the timezone to execute the task in.
+ */
+
+/**
+ * Creates a new task to execute the given function when the cron
+ *  expression ticks.
+ *
+ * @param {string} expression The cron expression.
+ * @param {Function} func The task to be executed.
+ * @param {CronScheduleOptions} [options] A set of options for the scheduled task.
+ * @returns {ScheduledTask} The scheduled task.
+ */
+function schedule(expression, func, options) {
+    const task = createTask(expression, func, options);
+
+    storage.save(task);
+
+    return task;
+}
+
+function createTask(expression, func, options) {
+    if (typeof func === 'string')
+        return new BackgroundScheduledTask(expression, func, options);
+
+    return new ScheduledTask(expression, func, options);
+}
+
+/**
+ * Check if a cron expression is valid.
+ *
+ * @param {string} expression The cron expression.
+ * @returns {boolean} Whether the expression is valid or not.
+ */
+function validate(expression) {
+    try {
+        validation(expression);
+
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+/**
+ * Gets the scheduled tasks.
+ *
+ * @returns {ScheduledTask[]} The scheduled tasks.
+ */
+function getTasks() {
+    return storage.getTasks();
+}
+
+module.exports = { schedule, validate, getTasks };
--- a/node_modules/node-cron/src/pattern-validation.js
+++ b/node_modules/node-cron/src/pattern-validation.js
@ -0,0 +1,124 @@
+'use strict';
+
+const convertExpression = require('./convert-expression');
+
+const validationRegex = /^(?:\d+|\*|\*\/\d+)$/;
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @param {number} min The minimum value.
+ * @param {number} max The maximum value.
+ * @returns {boolean}
+ */
+function isValidExpression(expression, min, max) {
+    const options = expression.split(',');
+
+    for (const option of options) {
+        const optionAsInt = parseInt(option, 10);
+
+        if (
+            (!Number.isNaN(optionAsInt) &&
+                (optionAsInt < min || optionAsInt > max)) ||
+            !validationRegex.test(option)
+        )
+            return false;
+    }
+
+    return true;
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidSecond(expression) {
+    return !isValidExpression(expression, 0, 59);
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidMinute(expression) {
+    return !isValidExpression(expression, 0, 59);
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidHour(expression) {
+    return !isValidExpression(expression, 0, 23);
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidDayOfMonth(expression) {
+    return !isValidExpression(expression, 1, 31);
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidMonth(expression) {
+    return !isValidExpression(expression, 1, 12);
+}
+
+/**
+ * @param {string} expression The Cron-Job expression.
+ * @returns {boolean}
+ */
+function isInvalidWeekDay(expression) {
+    return !isValidExpression(expression, 0, 7);
+}
+
+/**
+ * @param {string[]} patterns The Cron-Job expression patterns.
+ * @param {string[]} executablePatterns The executable Cron-Job expression
+ * patterns.
+ * @returns {void}
+ */
+function validateFields(patterns, executablePatterns) {
+    if (isInvalidSecond(executablePatterns[0]))
+        throw new Error(`${patterns[0]} is a invalid expression for second`);
+
+    if (isInvalidMinute(executablePatterns[1]))
+        throw new Error(`${patterns[1]} is a invalid expression for minute`);
+
+    if (isInvalidHour(executablePatterns[2]))
+        throw new Error(`${patterns[2]} is a invalid expression for hour`);
+
+    if (isInvalidDayOfMonth(executablePatterns[3]))
+        throw new Error(
+            `${patterns[3]} is a invalid expression for day of month`
+        );
+
+    if (isInvalidMonth(executablePatterns[4]))
+        throw new Error(`${patterns[4]} is a invalid expression for month`);
+
+    if (isInvalidWeekDay(executablePatterns[5]))
+        throw new Error(`${patterns[5]} is a invalid expression for week day`);
+}
+
+/**
+ * Validates a Cron-Job expression pattern.
+ *
+ * @param {string} pattern The Cron-Job expression pattern.
+ * @returns {void}
+ */
+function validate(pattern) {
+    if (typeof pattern !== 'string')
+        throw new TypeError('pattern must be a string!');
+
+    const patterns = pattern.split(' ');
+    const executablePatterns = convertExpression(pattern).split(' ');
+
+    if (patterns.length === 5) patterns.unshift('0');
+
+    validateFields(patterns, executablePatterns);
+}
+
+module.exports = validate;
--- a/node_modules/node-cron/src/scheduled-task.js
+++ b/node_modules/node-cron/src/scheduled-task.js
@ -0,0 +1,51 @@
+'use strict';
+
+const EventEmitter = require('events');
+const Task = require('./task');
+const Scheduler = require('./scheduler');
+const uuid = require('uuid');
+
+class ScheduledTask extends EventEmitter {
+    constructor(cronExpression, func, options) {
+        super();
+        if(!options){
+            options = {
+                scheduled: true,
+                recoverMissedExecutions: false
+            };
+        }
+      
+        this.options = options;
+        this.options.name = this.options.name || uuid.v4();
+
+        this._task = new Task(func);
+        this._scheduler = new Scheduler(cronExpression, options.timezone, options.recoverMissedExecutions);
+
+        this._scheduler.on('scheduled-time-matched', (now) => {
+            this.now(now);
+        });
+
+        if(options.scheduled !== false){
+            this._scheduler.start();
+        }
+        
+        if(options.runOnInit === true){
+            this.now('init');
+        }
+    }
+    
+    now(now = 'manual') {
+        let result = this._task.execute(now);
+        this.emit('task-done', result);
+    }
+    
+    start() {
+        this._scheduler.start();  
+    }
+    
+    stop() {
+        this._scheduler.stop();
+    }
+}
+
+module.exports = ScheduledTask;
--- a/node_modules/node-cron/src/scheduler.js
+++ b/node_modules/node-cron/src/scheduler.js
@ -0,0 +1,49 @@
+'use strict';
+
+const EventEmitter = require('events');
+const TimeMatcher = require('./time-matcher');
+
+class Scheduler extends EventEmitter{
+    constructor(pattern, timezone, autorecover){
+        super();
+        this.timeMatcher = new TimeMatcher(pattern, timezone);
+        this.autorecover = autorecover;
+    }
+
+    start(){
+        // clear timeout if exists
+        this.stop();
+
+        let lastCheck = process.hrtime();
+        let lastExecution = this.timeMatcher.apply(new Date());
+
+        const matchTime = () => {
+            const delay = 1000;
+            const elapsedTime = process.hrtime(lastCheck);
+            const elapsedMs = (elapsedTime[0] * 1e9 + elapsedTime[1]) / 1e6;
+            const missedExecutions = Math.floor(elapsedMs / 1000);
+            
+            for(let i = missedExecutions; i >= 0; i--){
+                const date = new Date(new Date().getTime() - i * 1000);
+                let date_tmp = this.timeMatcher.apply(date);
+                if(lastExecution.getTime() < date_tmp.getTime() && (i === 0 || this.autorecover) && this.timeMatcher.match(date)){
+                    this.emit('scheduled-time-matched', date_tmp);
+                    date_tmp.setMilliseconds(0);
+                    lastExecution = date_tmp;
+                }
+            }
+            lastCheck = process.hrtime();
+            this.timeout = setTimeout(matchTime, delay);
+        };
+        matchTime();
+    }
+
+    stop(){
+        if(this.timeout){
+            clearTimeout(this.timeout);
+        }
+        this.timeout = null;
+    }
+}
+
+module.exports = Scheduler;
--- a/node_modules/node-cron/src/storage.js
+++ b/node_modules/node-cron/src/storage.js
@ -0,0 +1,19 @@
+module.exports = (() => {
+    if(!global.scheduledTasks){
+        global.scheduledTasks = new Map();
+    }
+    
+    return {
+        save: (task) => {
+            if(!task.options){
+                const uuid = require('uuid');
+                task.options = {};
+                task.options.name = uuid.v4();
+            }
+            global.scheduledTasks.set(task.options.name, task);
+        },
+        getTasks: () => {
+            return global.scheduledTasks;
+        }
+    };
+})();
--- a/node_modules/node-cron/src/task.js
+++ b/node_modules/node-cron/src/task.js
@ -0,0 +1,34 @@
+'use strict';
+
+const EventEmitter = require('events');
+
+class Task extends EventEmitter{
+    constructor(execution){
+        super();
+        if(typeof execution !== 'function') {
+            throw 'execution must be a function';
+        }
+        this._execution = execution;
+    }
+
+    execute(now) {
+        let exec;
+        try {
+            exec = this._execution(now);
+        } catch (error) {
+            return this.emit('task-failed', error);
+        }
+        
+        if (exec instanceof Promise) {
+            return exec
+                .then(() => this.emit('task-finished'))
+                .catch((error) => this.emit('task-failed', error));
+        } else {
+            this.emit('task-finished');
+            return exec;
+        }
+    }
+}
+
+module.exports = Task;
+
--- a/node_modules/node-cron/src/time-matcher.js
+++ b/node_modules/node-cron/src/time-matcher.js
@ -0,0 +1,54 @@
+const validatePattern = require('./pattern-validation');
+const convertExpression = require('./convert-expression');
+
+function matchPattern(pattern, value){
+    if( pattern.indexOf(',') !== -1 ){
+        const patterns = pattern.split(',');
+        return patterns.indexOf(value.toString()) !== -1;
+    }
+    return pattern === value.toString();
+}
+
+class TimeMatcher{
+    constructor(pattern, timezone){
+        validatePattern(pattern);
+        this.pattern = convertExpression(pattern);
+        this.timezone = timezone;
+        this.expressions = this.pattern.split(' ');
+        this.dtf = this.timezone
+            ? new Intl.DateTimeFormat('en-US', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                hourCycle: 'h23',
+                fractionalSecondDigits: 3,
+                timeZone: this.timezone
+            }) : null;
+    }
+
+    match(date){
+        date = this.apply(date);
+
+        const runOnSecond = matchPattern(this.expressions[0], date.getSeconds());
+        const runOnMinute = matchPattern(this.expressions[1], date.getMinutes());
+        const runOnHour = matchPattern(this.expressions[2], date.getHours());
+        const runOnDay = matchPattern(this.expressions[3], date.getDate());
+        const runOnMonth = matchPattern(this.expressions[4], date.getMonth() + 1);
+        const runOnWeekDay = matchPattern(this.expressions[5], date.getDay());
+
+        return runOnSecond && runOnMinute && runOnHour && runOnDay && runOnMonth && runOnWeekDay;
+    }
+
+    apply(date){
+        if(this.dtf){
+            return new Date(this.dtf.format(date));
+        }
+
+        return date;
+    }
+}
+
+module.exports = TimeMatcher;
--- a/node_modules/node-cron/test/assets/dummy-task.js
+++ b/node_modules/node-cron/test/assets/dummy-task.js
@ -0,0 +1,3 @@
+exports.task = () => {
+    return 'dummy task';
+};
--- a/node_modules/node-cron/test/background-scheduled-task-test.js
+++ b/node_modules/node-cron/test/background-scheduled-task-test.js
@ -0,0 +1,47 @@
+const { assert } = require('chai');
+const BackgroundScheduledTask = require('../src/background-scheduled-task');
+
+describe('BackgroundScheduledTask', () => {
+    it('should start a task by default', (done) => {
+        let task = new BackgroundScheduledTask('* * * * * *', './test/assets/dummy-task.js');
+        task.on('task-done', (result) => {
+            assert.equal('dummy task', result);
+            task.stop();
+            done();
+        });
+    });
+    it('should create a task stoped', () => {
+        let task = new BackgroundScheduledTask('* * * * * *', './test/assets/dummy-task.js', {
+            scheduled: false
+        });
+
+        assert.isUndefined(task.pid());
+    });
+
+    it('should start a task', (done) => {
+        let task = new BackgroundScheduledTask('* * * * * *', './test/assets/dummy-task.js', {
+            scheduled: false
+        });
+
+        assert.isUndefined(task.pid());
+
+        task.on('task-done', (result) => {
+            assert.equal('dummy task', result);
+            task.stop();
+            done();
+        });
+
+        task.start();
+        assert.isNotNull(task.pid());
+    });
+    
+    it('should stop a task', () => {
+        let task = new BackgroundScheduledTask('* * * * * *', './test/assets/dummy-task.js', {
+            scheduled: true
+        });
+        assert.isNotNull(task.pid());
+        assert.isTrue(task.isRunning());
+        task.stop();
+        assert.isFalse(task.isRunning());
+    });
+});
--- a/node_modules/node-cron/test/convert-expression/asterisk-to-range-conversion-test.js
+++ b/node_modules/node-cron/test/convert-expression/asterisk-to-range-conversion-test.js
@ -0,0 +1,12 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression/asterisk-to-range-conversion');
+
+describe('asterisk-to-range-conversion.js', () => {
+    it('shuld convert * to ranges', () => {
+        const expressions = '* * * * * *'.split(' ');
+        const expression = conversion(expressions).join(' ');
+        expect(expression).to.equal('0-59 0-59 0-23 1-31 1-12 0-6');
+    });
+});
--- a/node_modules/node-cron/test/convert-expression/convert-expression-test.js
+++ b/node_modules/node-cron/test/convert-expression/convert-expression-test.js
@ -0,0 +1,18 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression');
+
+describe('month-names-conversion.js', () => {
+    it('shuld convert month names', () => {
+        const expression = conversion('* * * * January,February *');
+        const expressions = expression.split(' ');
+        expect(expressions[4]).to.equal('1,2');
+    });
+
+    it('shuld convert week day names', () => {
+        const expression = conversion('* * * * * Mon,Sun');
+        const expressions = expression.split(' ');
+        expect(expressions[5]).to.equal('1,0');
+    });
+});
--- a/node_modules/node-cron/test/convert-expression/month-names-conversion-test.js
+++ b/node_modules/node-cron/test/convert-expression/month-names-conversion-test.js
@ -0,0 +1,16 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression/month-names-conversion');
+
+describe('month-names-conversion.js', () => {
+    it('shuld convert month names', () => {
+        const months = conversion('January,February,March,April,May,June,July,August,September,October,November,December');
+        expect(months).to.equal('1,2,3,4,5,6,7,8,9,10,11,12');
+    });
+
+    it('shuld convert month names', () => {
+        const months = conversion('Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec');
+        expect(months).to.equal('1,2,3,4,5,6,7,8,9,10,11,12');
+    });
+});
--- a/node_modules/node-cron/test/convert-expression/range-conversion-test.js
+++ b/node_modules/node-cron/test/convert-expression/range-conversion-test.js
@ -0,0 +1,24 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression/range-conversion');
+
+describe('range-conversion.js', () => {
+    it('shuld convert ranges to numbers', () => {
+        const expressions = '0-3 0-3 0-2 1-3 1-2 0-3'.split(' ');
+        const expression = conversion(expressions).join(' ');
+        expect(expression).to.equal('0,1,2,3 0,1,2,3 0,1,2 1,2,3 1,2 0,1,2,3');
+    });
+
+    it('shuld convert ranges to numbers', () => {
+        const expressions = '0-3 0-3 8-10 1-3 1-2 0-3'.split(' ');
+        const expression = conversion(expressions).join(' ');
+        expect(expression).to.equal('0,1,2,3 0,1,2,3 8,9,10 1,2,3 1,2 0,1,2,3');
+    });
+
+    it('should convert comma delimited ranges to numbers', () => {
+        var expressions = '0-2,10-23'.split(' ');
+        var expression = conversion(expressions).join(' ');
+        expect(expression).to.equal('0,1,2,10,11,12,13,14,15,16,17,18,19,20,21,22,23');
+    });
+});
--- a/node_modules/node-cron/test/convert-expression/step-values-conversion-test.js
+++ b/node_modules/node-cron/test/convert-expression/step-values-conversion-test.js
@ -0,0 +1,19 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression/step-values-conversion');
+
+describe('step-values-conversion.js', () => {
+    it('should convert step values', () => {
+        var expressions = '1,2,3,4,5,6,7,8,9,10/2 0,1,2,3,4,5,6,7,8,9/5 * * * *'.split(' ');
+        expressions = conversion(expressions);
+        expect(expressions[0]).to.equal('2,4,6,8,10');
+        expect(expressions[1]).to.equal('0,5');
+    });
+
+    it('should throw an error if step value is not a number', () => {
+        var expressions = '1,2,3,4,5,6,7,8,9,10/someString 0,1,2,3,4,5,6,7,8,9/5 * * * *'.split(' ');
+        expect(() => conversion(expressions)).to.throw('someString is not a valid step value');
+    });
+
+});
--- a/node_modules/node-cron/test/convert-expression/week-day-names-conversion-test.js
+++ b/node_modules/node-cron/test/convert-expression/week-day-names-conversion-test.js
@ -0,0 +1,21 @@
+'use strict';
+
+const { expect } = require('chai');
+const conversion = require('../../src/convert-expression/week-day-names-conversion');
+
+describe('week-day-names-conversion.js', () => {
+    it('shuld convert week day names names', () => {
+        const weekDays = conversion('Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday');
+        expect(weekDays).to.equal('1,2,3,4,5,6,0');
+    });
+
+    it('shuld convert short week day names names', () => {
+        const weekDays = conversion('Mon,Tue,Wed,Thu,Fri,Sat,Sun');
+        expect(weekDays).to.equal('1,2,3,4,5,6,0');
+    });
+
+    it('shuld convert 7 to 0', () => {
+        const weekDays = conversion('7');
+        expect(weekDays).to.equal('0');
+    });
+});
--- a/node_modules/node-cron/test/node-cron-test.js
+++ b/node_modules/node-cron/test/node-cron-test.js
@ -0,0 +1,138 @@
+const { assert } = require('chai');
+const sinon = require('sinon');
+const cron = require('../src/node-cron');
+
+describe('node-cron', () => {
+    beforeEach(() => {
+        this.clock = sinon.useFakeTimers(new Date(2018, 0, 1, 0, 0, 0, 0));
+    });
+    
+    afterEach(() => {
+        this.clock.restore();
+    });
+    
+    describe('schedule', () => {
+        it('should schedule a task', () => {
+            let executed = 0;
+            cron.schedule('* * * * * *', () => {
+                executed += 1;
+            });
+            
+            this.clock.tick(2000);
+            
+            assert.equal(2, executed);
+        });
+        
+        it('should schedule a task with America/Sao_Paulo timezone', (done) => {
+            let startDate = new Date('Thu, 20 Sep 2018 00:00:00.000Z');
+            this.clock.restore();
+            this.clock = sinon.useFakeTimers(startDate);
+            cron.schedule('* * * * * *', (date) => {
+                assert.equal(19, date.getDate());
+                assert.equal(8, date.getMonth());
+                assert.equal(2018, date.getFullYear());
+                assert.equal(21, date.getHours());
+                assert.equal(0, date.getMinutes());
+                assert.equal(1, date.getSeconds());
+                done();
+            }, {
+                timezone: 'America/Sao_Paulo'
+            });
+            this.clock.tick(1000);
+        });
+        
+        it('should schedule a task with Europe/Rome timezone', (done) => {
+            let startDate = new Date('Thu, 20 Sep 2018 00:00:00.000Z');
+            this.clock.restore();
+            this.clock = sinon.useFakeTimers(startDate);
+            cron.schedule('* * * * * *', (date) => {
+                assert.equal(20, date.getDate());
+                assert.equal(8, date.getMonth());
+                assert.equal(2018, date.getFullYear());
+                assert.equal(2, date.getHours());
+                assert.equal(0, date.getMinutes());
+                assert.equal(1, date.getSeconds());
+                done();
+            }, {
+                timezone: 'Europe/Rome'
+            });
+            this.clock.tick(1000);
+        });
+        
+        it('should schedule a task stoped', () => {
+            let executed = 0;
+            cron.schedule('* * * * * *', () => {
+                executed += 1;
+            }, { scheduled: false });
+            
+            this.clock.tick(2000);
+            
+            assert.equal(0, executed);
+        });
+        
+        it('should start a stoped task', () => {
+            let executed = 0;
+            let scheduledTask = cron.schedule('* * * * * *', () => {
+                executed += 1;
+            }, { scheduled: false });
+            
+            this.clock.tick(2000);
+            assert.equal(0, executed);
+            scheduledTask.start();
+            this.clock.tick(2000);
+            assert.equal(2, executed);
+        });
+        
+        it('should recover missed executions', (done) => {
+            let executed = 0;
+            this.clock.restore();
+            let scheduledTask = cron.schedule('* * * * * *', () => {
+                executed += 1;
+            }, { recoverMissedExecutions: true });
+            
+            let wait = true;
+            let startedAt = new Date();
+            
+            while(wait){
+                if((new Date().getTime() - startedAt.getTime()) > 1000){
+                    wait = false;
+                }
+            }
+            
+            setTimeout(() => {
+                scheduledTask.stop();
+                assert.equal(2, executed);
+                done();
+            }, 1000);
+        }).timeout(4000);
+
+        it('should schedule a background task', () => {
+            let task = cron.schedule('* * * * * *', './test/assets/dummy-task.js');
+            assert.isNotNull(task);
+            assert.isDefined(task);
+            assert.isTrue(task.isRunning());
+            task.stop();
+        });
+    });
+    
+    describe('validate', () => {
+        it('should validate a pattern', () => {
+            assert.isTrue(cron.validate('* * * * * *')); 
+        });
+        
+        it('should fail with a invalid pattern', () => {
+            assert.isFalse(cron.validate('62 * * * * *')); 
+        });
+    });
+
+    describe('getTasks', () => {
+        beforeEach(() => {
+            global.scheduledTasks = new Map();
+        });
+
+        it('should store a task', () => {
+            cron.schedule('* * * * *', () => {});
+            assert.lengthOf(cron.getTasks(), 1);
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-day-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-day-test.js
@ -0,0 +1,32 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js', () => {
+    describe('validate day of month', () => {
+        it('should fail with invalid day of month', () => {
+            expect(() => {
+                validate('* * 32 * *');
+            }).to.throw('32 is a invalid expression for day of month');
+        });
+
+        it('should not fail with valid day of month', () => {
+            expect(() => {
+                validate('0 * * 15 * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with * for day of month', () => {
+            expect(() => {
+                validate('* * * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2 for day of month', () => {
+            expect(() => {
+                validate('* * */2 * *');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-hours-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-hours-test.js
@ -0,0 +1,38 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js', () => {
+    describe('validate hour', () => {
+        it('should fail with invalid hour', () => {
+            expect(() => {
+                validate('* 25 * * *');
+            }).to.throw('25 is a invalid expression for hour');
+        });
+
+        it('should not fail with valid hour', () => {
+            expect(() => {
+                validate('* 12 * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with * for hour', () => {
+            expect(() => {
+                validate('* * * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2 for hour', () => {
+            expect(() => {
+                validate('* */2 * * *');
+            }).to.not.throw();
+        });
+
+        it('should accept range for hours', () => {
+            expect(() => {
+                validate('* 3-20 * * *');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-minute-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-minute-test.js
@ -0,0 +1,32 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js', () => {
+    describe('validate minutes', () => {
+        it('should fail with invalid minute', () => {
+            expect(() => {
+                validate('63 * * * *');
+            }).to.throw('63 is a invalid expression for minute');
+        });
+
+        it('should not fail with valid minute', () => {
+            expect(() => {
+                validate('30 * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with *', () => {
+            expect(() => {
+                validate('* * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2', () => {
+            expect(() => {
+                validate('*/2 * * * *');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-month-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-month-test.js
@ -0,0 +1,44 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js',  () => {
+    describe('validate month',  () => {
+        it('should fail with invalid month',  () => {
+            expect( () => {
+                validate('* * * 13 *');
+            }).to.throw('13 is a invalid expression for month');
+        });
+
+        it('should fail with invalid month name',  () => {
+            expect( () => {
+                validate('* * * foo *');
+            }).to.throw('foo is a invalid expression for month');
+        });
+
+        it('should not fail with valid month',  () => {
+            expect( () => {
+                validate('* * * 10 *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with valid month name',  () => {
+            expect( () => {
+                validate('* * * September *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with * for month',  () => {
+            expect( () => {
+                validate('* * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2 for month',  () => {
+            expect( () => {
+                validate('* * * */2 *');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-pattern-type.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-pattern-type.js
@ -0,0 +1,19 @@
+'use strict';
+
+const { expect } = require('chai');
+const Task = require('../../src/task');
+
+describe('Task', () => {
+    it('should accept a function', () => {
+        expect(() => {
+            new Task(() => {});
+        }).to.not.throw();
+    });
+
+    it('should fail without a function', () => {
+        expect(() => {
+            new Task([]);
+        }).to.throw('execution must be a function');
+    });
+
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-second-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-second-test.js
@ -0,0 +1,32 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js', () => {
+    describe('validate seconds', () => {
+        it('should fail with invalid second', () => {
+            expect(() => {
+                validate('63 * * * * *');
+            }).to.throw('63 is a invalid expression for second');
+        });
+
+        it('should not fail with valid second', () => {
+            expect(() => {
+                validate('30 * * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with * for second', () => {
+            expect(() => {
+                validate('* * * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2 for second', () => {
+            expect(() => {
+                validate('*/2 * * * * *');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-test.js
@ -0,0 +1,24 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation', () => {
+    it('should succeed with a valid expression', () =>  {
+        expect(() => {
+            validate('59 * * * *');
+        }).to.not.throw();
+    });
+
+    it('should fail with an invalid expression', () =>  {
+        expect(() => {
+            validate('60 * * * *');
+        }).to.throw('60 is a invalid expression for minute');
+    });
+
+    it('should fail without a string', () =>  {
+        expect(() => {
+            validate(50);
+        }).to.throw('pattern must be a string!');
+    });
+});
--- a/node_modules/node-cron/test/pattern-validation/validate-week-day-test.js
+++ b/node_modules/node-cron/test/pattern-validation/validate-week-day-test.js
@ -0,0 +1,56 @@
+'use strict';
+
+const { expect } = require('chai');
+const validate = require('../../src/pattern-validation');
+
+describe('pattern-validation.js', () => {
+    describe('validate week day', () => {
+        it('should fail with invalid week day', () => {
+            expect(() => {
+                validate('* * * * 9');
+            }).to.throw('9 is a invalid expression for week day');
+        });
+
+        it('should fail with invalid week day name', () => {
+            expect(() => {
+                validate('* * * * foo');
+            }).to.throw('foo is a invalid expression for week day');
+        });
+
+        it('should not fail with valid week day', () => {
+            expect(() => {
+                validate('* * * * 5');
+            }).to.not.throw();
+        });
+
+        it('should not fail with valid week day name', () => {
+            expect(() => {
+                validate('* * * * Friday');
+            }).to.not.throw();
+        });
+
+        it('should not fail with * for week day', () => {
+            expect(() => {
+                validate('* * * * *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with */2 for week day', () => {
+            expect(() => {
+                validate('* * * */2 *');
+            }).to.not.throw();
+        });
+
+        it('should not fail with Monday-Sunday for week day', () => {
+            expect(() => {
+                validate('* * * * Monday-Sunday');
+            }).to.not.throw();
+        });
+
+        it('should not fail with 1-7 for week day', () => {
+            expect(() => {
+                validate('0 0 1 1 1-7');
+            }).to.not.throw();
+        });
+    });
+});
--- a/node_modules/node-cron/test/scheduled-task-test.js
+++ b/node_modules/node-cron/test/scheduled-task-test.js
@ -0,0 +1,91 @@
+const { assert } = require('chai');
+const sinon = require('sinon');
+const ScheduledTask = require('../src/scheduled-task');
+
+describe('ScheduledTask', () => {
+    beforeEach(() => {
+        this.clock = sinon.useFakeTimers(new Date(2018, 0, 1, 0, 0, 0, 0));
+    });
+
+    afterEach(() => {
+        this.clock.restore();
+    });
+
+    it('should start a task by default', (done) => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        });
+        this.clock.tick(3000);
+        assert.equal(3, executed);
+        scheduledTask.stop();
+        done();
+    });
+
+    it('should create a task stoped', (done) => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        }, { scheduled: false });
+        this.clock.tick(3000);
+        assert.equal(0, executed);
+        scheduledTask.stop();
+        done();
+    });
+
+    it('should start a task', (done) => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        }, { scheduled: false });
+        this.clock.tick(3000);
+        assert.equal(0, executed);
+        scheduledTask.start();
+        this.clock.tick(3000);
+        assert.equal(3, executed);
+        scheduledTask.stop();
+        done();
+    });
+
+    it('should stop a task', () => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        }, { scheduled: true });
+        this.clock.tick(3000);
+        assert.equal(3, executed);
+        scheduledTask.stop();
+        this.clock.tick(3000);
+        assert.equal(3, executed);
+    });
+    
+    it('should create a task stopped and run it once created', () => {
+        let executed = 0;
+        new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        }, { scheduled: false, runOnInit: true });
+        this.clock.tick(3000);
+        assert.equal(1, executed);
+    });
+    
+    it('should create a task stopped and run it once manually', () => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('* * * * * *', () => {
+            executed += 1;
+        }, { scheduled: false });
+        this.clock.tick(3000);
+        assert.equal(0, executed);
+        scheduledTask.now();
+        assert.equal(1, executed);
+    });
+
+    it('should emit event every minute', () => {
+        let executed = 0;
+        let scheduledTask = new ScheduledTask('0 * * * * *', () => {
+            executed += 1;
+        }, { scheduled: true });
+        this.clock.tick(60000 * 3);
+        assert.equal(3, executed);
+        scheduledTask.stop();
+    });
+});
--- a/node_modules/node-cron/test/scheduler-test.js
+++ b/node_modules/node-cron/test/scheduler-test.js
@ -0,0 +1,91 @@
+const { assert } = require('chai');
+const sinon = require('sinon');
+const Scheduler = require('../src/scheduler');
+
+describe('Scheduler', () => {
+    beforeEach(() => {
+        this.clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+        this.clock.restore();
+    });
+
+    it('should emit an event on matched time', (done) => {
+        let scheduler = new Scheduler('* * * * * *');
+
+        scheduler.on('scheduled-time-matched', (date) => {
+            assert.isNotNull(date);
+            assert.instanceOf(date, Date);
+            scheduler.stop();
+            done();
+        });
+
+        scheduler.start();
+        this.clock.tick(1000);
+    });
+
+    it('should emit an event every second', (done) => {
+        let scheduler = new Scheduler('* * * * * *');
+        let emited = 0;
+        scheduler.on('scheduled-time-matched', (date) => {
+            emited += 1;
+            assert.isNotNull(date);
+            assert.instanceOf(date, Date);
+            if(emited === 5){
+                scheduler.stop();
+                done();
+            }
+        });
+        scheduler.start();
+        this.clock.tick(5000);
+    });
+
+    it('should recover missed executions', (done) => {
+        this.clock.restore();
+        let scheduler = new Scheduler('* * * * * *', null, true);
+        let emited = 0;
+        scheduler.on('scheduled-time-matched', () => {
+            emited += 1;
+        });
+        scheduler.start();
+        let wait = true;
+        let startedAt = new Date();
+        
+        while(wait){
+            if((new Date().getTime() - startedAt.getTime()) > 1000){
+                wait = false;
+            }
+        }
+
+        setTimeout(() => {
+            scheduler.stop();
+            assert.equal(2, emited);
+            done();
+        }, 1000);
+    }).timeout(3000);
+
+    it('should ignore missed executions', (done) => {
+        this.clock.restore();
+        let scheduler = new Scheduler('* * * * * *', null, false);
+        let emited = 0;
+        scheduler.on('scheduled-time-matched', () => {
+            emited += 1;
+        });
+        scheduler.start();
+        let wait = true;
+        let startedAt = new Date();
+        
+        while(wait){
+            if((new Date().getTime() - startedAt.getTime()) > 1000){
+                wait = false;
+            }
+        }
+
+        setTimeout(() => {
+            scheduler.stop();
+            assert.equal(1, emited);
+            done();
+        }, 1000);
+    }).timeout(3000);
+});
--- a/node_modules/node-cron/test/storage-test.js
+++ b/node_modules/node-cron/test/storage-test.js
@ -0,0 +1,26 @@
+const { assert } = require('chai');
+const storage = require('../src/storage');
+
+describe('storage', () => {
+    it('should store a task', () => {
+        global.scheduledTasks = new Map();
+        storage.save({});
+        assert.lengthOf(global.scheduledTasks, 1);
+    });
+
+    it('should get all tasks', () => {
+        global.scheduledTasks = new Map();
+        global.scheduledTasks.set(0, {});
+        assert.lengthOf(storage.getTasks(), 1);
+    });
+
+    describe('on import', () => {
+        it('should keep stored items across imports', () => {
+            delete require.cache[require.resolve('../src/storage')];
+            global.scheduledTasks = new Map();
+            storage.save({});
+            let storage2 = require('../src/storage');
+            assert.lengthOf(storage2.getTasks(), 1);
+        });
+    });
+});
--- a/node_modules/node-cron/test/task-test.js
+++ b/node_modules/node-cron/test/task-test.js
@ -0,0 +1,49 @@
+const { assert } = require('chai');
+const sinon = require('sinon');
+const Task = require('../src/task');
+
+describe('Task', () => {
+    beforeEach(() => {
+        this.clock = sinon.useFakeTimers(new Date(2018, 0, 1, 0, 0, 0, 0));
+    });
+
+    afterEach(() => {
+        this.clock.restore();
+    });
+
+    it('should emit event on finish a task', async () => {
+        let finished = false;
+        let task = new Task(() => 'ok');
+        task.on('task-finished', () => finished = true);
+        await task.execute();
+        assert.equal(true, finished);
+    });
+
+    it('should emit event on error a task', async () => {
+        let error;
+        let task = new Task(() => {
+            throw Error('execution error');
+        });
+        task.on('task-failed', (err) => error = err.message);
+        await task.execute();
+        assert.equal('execution error', error);
+    });
+
+    it('should emit event on finish a promise task', async () => {
+        let finished = false;
+        const promise = () => new Promise((resolve) => resolve('ok'));
+        let task = new Task(promise);
+        task.on('task-finished', () => finished = true);
+        await task.execute();
+        assert.equal(true, finished);
+    });
+
+    it('should emit event on error a promise task', async () => {
+        let failed = false;
+        const promise = () => new Promise((resolve, reject) => reject('errou'));
+        const task = new Task(promise);
+        task.on('task-failed', (error) => failed = error);
+        await task.execute();
+        assert.equal('errou', failed);
+    });
+});
--- a/node_modules/node-cron/test/time-matcher-test.js
+++ b/node_modules/node-cron/test/time-matcher-test.js
@ -0,0 +1,244 @@
+const { assert } = require('chai');
+const TimeMatcher = require('../src/time-matcher');
+const moment = require('moment-timezone');
+
+describe('TimeMatcher', () => {
+    describe('wildcard', () => {
+        it('should accept wildcard for second', () => {
+            let matcher = new TimeMatcher('* * * * * *');
+            assert.isTrue(matcher.match(new Date()));
+        });
+
+        it('should accept wildcard for minute', () => {
+            let matcher = new TimeMatcher('0 * * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 10, 20, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 10, 20, 1)));
+        });
+
+        it('should accept wildcard for hour', () => {
+            let matcher = new TimeMatcher('0 0 * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 10, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 10, 1, 0)));
+        });
+
+        it('should accept wildcard for day', () => {
+            let matcher = new TimeMatcher('0 0 0 * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 1, 0, 0)));
+        });
+
+        it('should accept wildcard for month', () => {
+            let matcher = new TimeMatcher('0 0 0 1 * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 2, 0, 0, 0)));
+        });
+
+        it('should accept wildcard for week day', () => {
+            let matcher = new TimeMatcher('0 0 0 1 4 *');
+            assert.isTrue(matcher.match(new Date(2018, 3, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 3, 2, 0, 0, 0)));
+        });
+    });
+
+    describe('single value', () => {
+        it('should accept single value for second', () => {
+            let matcher = new TimeMatcher('5 * * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 5)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 0, 6)));
+        });
+
+        it('should accept single value for minute', () => {
+            let matcher = new TimeMatcher('0 5 * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 5, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 6, 0)));
+        });
+
+        it('should accept single value for hour', () => {
+            let matcher = new TimeMatcher('0 0 5 * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 5, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 6, 0, 0)));
+        });
+
+        it('should accept single value for day', () => {
+            let matcher = new TimeMatcher('0 0 0 5 * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 5, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 6, 0, 0, 0)));
+        });
+
+        it('should accept single value for month', () => {
+            let matcher = new TimeMatcher('0 0 0 1 5 *');
+            assert.isTrue(matcher.match(new Date(2018, 4, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 5, 1, 0, 0, 0)));
+        });
+
+        it('should accept single value for week day', () => {
+            let matcher = new TimeMatcher('0 0 0 * * monday');
+            assert.isTrue(matcher.match(new Date(2018, 4, 7, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 4, 8, 0, 0, 0)));
+        });
+    });
+
+    describe('multiple values', () => {
+        it('should accept multiple values for second', () => {
+            let matcher = new TimeMatcher('5,6 * * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 5)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 6)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 0, 7)));
+        });
+
+        it('should accept multiple values for minute', () => {
+            let matcher = new TimeMatcher('0 5,6 * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 5, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 6, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 7, 0)));
+        });
+        
+        it('should accept multiple values for hour', () => {
+            let matcher = new TimeMatcher('0 0 5,6 * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 5, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 6, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 7, 0, 0)));
+        });
+
+        it('should accept multiple values for day', () => {
+            let matcher = new TimeMatcher('0 0 0 5,6 * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 5, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 6, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 7, 0, 0, 0)));
+        });
+
+        it('should accept multiple values for month', () => {
+            let matcher = new TimeMatcher('0 0 0 1 may,june *');
+            assert.isTrue(matcher.match(new Date(2018, 4, 1, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 5, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 6, 1, 0, 0, 0)));
+        });
+
+        it('should accept multiple values for week day', () => {
+            let matcher = new TimeMatcher('0 0 0 * * monday,tue');
+            assert.isTrue(matcher.match(new Date(2018, 4, 7, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 4, 8, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 4, 9, 0, 0, 0)));
+        });
+    });
+
+    describe('range', () => {
+        it('should accept range for second', () => {
+            let matcher = new TimeMatcher('5-7 * * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 5)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 6)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 7)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 0, 8)));
+        });
+
+        it('should accept range for minute', () => {
+            let matcher = new TimeMatcher('0 5-7 * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 5, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 6, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 7, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 8, 0)));
+        });
+
+        it('should accept range for hour', () => {
+            let matcher = new TimeMatcher('0 0 5-7 * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 5, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 6, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 7, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 8, 0, 0)));
+        });
+
+        it('should accept range for day', () => {
+            let matcher = new TimeMatcher('0 0 0 5-7 * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 5, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 6, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 7, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 8, 0, 0, 0)));
+        });
+
+        it('should accept range for month', () => {
+            let matcher = new TimeMatcher('0 0 0 1 may-july *');
+            assert.isTrue(matcher.match(new Date(2018, 4, 1, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 5, 1, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 6, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 7, 1, 0, 0, 0)));
+        });
+
+        it('should accept range for week day', () => {
+            let matcher = new TimeMatcher('0 0 0 * * monday-wed');
+            assert.isTrue(matcher.match(new Date(2018, 4, 7, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 4, 8, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 4, 9, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 4, 10, 0, 0, 0)));
+        });
+    });
+
+    describe('step values', () => {
+        it('should accept step values for second', () => {
+            let matcher = new TimeMatcher('*/2 * * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 2)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 0, 6)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 0, 7)));
+        });
+
+        it('should accept step values for minute', () => {
+            let matcher = new TimeMatcher('0 */2 * * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 2, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 0, 6, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 0, 7, 0)));
+        });
+        
+        it('should accept step values for hour', () => {
+            let matcher = new TimeMatcher('0 0 */2 * * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 2, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 1, 6, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 1, 7, 0, 0)));
+        });
+
+        it('should accept step values for day', () => {
+            let matcher = new TimeMatcher('0 0 0 */2 * *');
+            assert.isTrue(matcher.match(new Date(2018, 0, 2, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 0, 6, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 0, 7, 0, 0, 0)));
+        });
+
+        it('should accept step values for month', () => {
+            let matcher = new TimeMatcher('0 0 0 1 */2 *');
+            assert.isTrue(matcher.match(new Date(2018, 1, 1, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 5, 1, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 6, 1, 0, 0, 0)));
+        });
+
+        it('should accept step values for week day', () => {
+            let matcher = new TimeMatcher('0 0 0 * * */2');
+            assert.isTrue(matcher.match(new Date(2018, 4, 6, 0, 0, 0)));
+            assert.isTrue(matcher.match(new Date(2018, 4, 8, 0, 0, 0)));
+            assert.isFalse(matcher.match(new Date(2018, 4, 9, 0, 0, 0)));
+        });
+    });
+
+    describe('timezone', ()=>{
+        it('should match with timezone America/Sao_Paulo', () => {
+            let matcher = new TimeMatcher('0 0 0 * * *', 'America/Sao_Paulo');
+            let utcTime = new Date('Thu Oct 11 2018 03:00:00Z');
+            assert.isTrue(matcher.match(utcTime));
+        });
+
+        it('should match with timezone Europe/Rome', () => {
+            let matcher = new TimeMatcher('0 0 0 * * *', 'Europe/Rome');
+            let utcTime = new Date('Thu Oct 11 2018 22:00:00Z');
+            assert.isTrue(matcher.match(utcTime));
+        });
+
+        it('should match with all available timezone of moment-timezone', () => {
+            const allTimeZone = moment.tz.names();
+            for (let zone in allTimeZone) {
+                const tmp = moment();
+                const expected = moment.tz(tmp,allTimeZone[zone]);
+                const pattern = expected.second() + ' ' + expected.minute() + ' ' + expected.hour() + ' ' + expected.date() + ' ' + (expected.month()+1) + ' ' + expected.day();
+                const matcher = new TimeMatcher(pattern, allTimeZone[zone]);
+                const utcTime = new Date(tmp.year(), tmp.month(), tmp.date(), tmp.hour(), tmp.minute(), tmp.second(), tmp.millisecond());
+                assert.isTrue(matcher.match(utcTime));
+            }
+        });
+    });
+});
--- a/node_modules/uuid/CHANGELOG.md
+++ b/node_modules/uuid/CHANGELOG.md
@ -0,0 +1,229 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [8.3.2](https://github.com/uuidjs/uuid/compare/v8.3.1...v8.3.2) (2020-12-08)
+
+### Bug Fixes
+
+- lazy load getRandomValues ([#537](https://github.com/uuidjs/uuid/issues/537)) ([16c8f6d](https://github.com/uuidjs/uuid/commit/16c8f6df2f6b09b4d6235602d6a591188320a82e)), closes [#536](https://github.com/uuidjs/uuid/issues/536)
+
+### [8.3.1](https://github.com/uuidjs/uuid/compare/v8.3.0...v8.3.1) (2020-10-04)
+
+### Bug Fixes
+
+- support expo>=39.0.0 ([#515](https://github.com/uuidjs/uuid/issues/515)) ([c65a0f3](https://github.com/uuidjs/uuid/commit/c65a0f3fa73b901959d638d1e3591dfacdbed867)), closes [#375](https://github.com/uuidjs/uuid/issues/375)
+
+## [8.3.0](https://github.com/uuidjs/uuid/compare/v8.2.0...v8.3.0) (2020-07-27)
+
+### Features
+
+- add parse/stringify/validate/version/NIL APIs ([#479](https://github.com/uuidjs/uuid/issues/479)) ([0e6c10b](https://github.com/uuidjs/uuid/commit/0e6c10ba1bf9517796ff23c052fc0468eedfd5f4)), closes [#475](https://github.com/uuidjs/uuid/issues/475) [#478](https://github.com/uuidjs/uuid/issues/478) [#480](https://github.com/uuidjs/uuid/issues/480) [#481](https://github.com/uuidjs/uuid/issues/481) [#180](https://github.com/uuidjs/uuid/issues/180)
+
+## [8.2.0](https://github.com/uuidjs/uuid/compare/v8.1.0...v8.2.0) (2020-06-23)
+
+### Features
+
+- improve performance of v1 string representation ([#453](https://github.com/uuidjs/uuid/issues/453)) ([0ee0b67](https://github.com/uuidjs/uuid/commit/0ee0b67c37846529c66089880414d29f3ae132d5))
+- remove deprecated v4 string parameter ([#454](https://github.com/uuidjs/uuid/issues/454)) ([88ce3ca](https://github.com/uuidjs/uuid/commit/88ce3ca0ba046f60856de62c7ce03f7ba98ba46c)), closes [#437](https://github.com/uuidjs/uuid/issues/437)
+- support jspm ([#473](https://github.com/uuidjs/uuid/issues/473)) ([e9f2587](https://github.com/uuidjs/uuid/commit/e9f2587a92575cac31bc1d4ae944e17c09756659))
+
+### Bug Fixes
+
+- prepare package exports for webpack 5 ([#468](https://github.com/uuidjs/uuid/issues/468)) ([8d6e6a5](https://github.com/uuidjs/uuid/commit/8d6e6a5f8965ca9575eb4d92e99a43435f4a58a8))
+
+## [8.1.0](https://github.com/uuidjs/uuid/compare/v8.0.0...v8.1.0) (2020-05-20)
+
+### Features
+
+- improve v4 performance by reusing random number array ([#435](https://github.com/uuidjs/uuid/issues/435)) ([bf4af0d](https://github.com/uuidjs/uuid/commit/bf4af0d711b4d2ed03d1f74fd12ad0baa87dc79d))
+- optimize V8 performance of bytesToUuid ([#434](https://github.com/uuidjs/uuid/issues/434)) ([e156415](https://github.com/uuidjs/uuid/commit/e156415448ec1af2351fa0b6660cfb22581971f2))
+
+### Bug Fixes
+
+- export package.json required by react-native and bundlers ([#449](https://github.com/uuidjs/uuid/issues/449)) ([be1c8fe](https://github.com/uuidjs/uuid/commit/be1c8fe9a3206c358e0059b52fafd7213aa48a52)), closes [ai/nanoevents#44](https://github.com/ai/nanoevents/issues/44#issuecomment-602010343) [#444](https://github.com/uuidjs/uuid/issues/444)
+
+## [8.0.0](https://github.com/uuidjs/uuid/compare/v7.0.3...v8.0.0) (2020-04-29)
+
+### ⚠ BREAKING CHANGES
+
+- For native ECMAScript Module (ESM) usage in Node.js only named exports are exposed, there is no more default export.
+
+  ```diff
+  -import uuid from 'uuid';
+  -console.log(uuid.v4()); // -> 'cd6c3b08-0adc-4f4b-a6ef-36087a1c9869'
+  +import { v4 as uuidv4 } from 'uuid';
+  +uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
+  ```
+
+- Deep requiring specific algorithms of this library like `require('uuid/v4')`, which has been deprecated in `uuid@7`, is no longer supported.
+
+  Instead use the named exports that this module exports.
+
+  For ECMAScript Modules (ESM):
+
+  ```diff
+  -import uuidv4 from 'uuid/v4';
+  +import { v4 as uuidv4 } from 'uuid';
+  uuidv4();
+  ```
+
+  For CommonJS:
+
+  ```diff
+  -const uuidv4 = require('uuid/v4');
+  +const { v4: uuidv4 } = require('uuid');
+  uuidv4();
+  ```
+
+### Features
+
+- native Node.js ES Modules (wrapper approach) ([#423](https://github.com/uuidjs/uuid/issues/423)) ([2d9f590](https://github.com/uuidjs/uuid/commit/2d9f590ad9701d692625c07ed62f0a0f91227991)), closes [#245](https://github.com/uuidjs/uuid/issues/245) [#419](https://github.com/uuidjs/uuid/issues/419) [#342](https://github.com/uuidjs/uuid/issues/342)
+- remove deep requires ([#426](https://github.com/uuidjs/uuid/issues/426)) ([daf72b8](https://github.com/uuidjs/uuid/commit/daf72b84ceb20272a81bb5fbddb05dd95922cbba))
+
+### Bug Fixes
+
+- add CommonJS syntax example to README quickstart section ([#417](https://github.com/uuidjs/uuid/issues/417)) ([e0ec840](https://github.com/uuidjs/uuid/commit/e0ec8402c7ad44b7ef0453036c612f5db513fda0))
+
+### [7.0.3](https://github.com/uuidjs/uuid/compare/v7.0.2...v7.0.3) (2020-03-31)
+
+### Bug Fixes
+
+- make deep require deprecation warning work in browsers ([#409](https://github.com/uuidjs/uuid/issues/409)) ([4b71107](https://github.com/uuidjs/uuid/commit/4b71107d8c0d2ef56861ede6403fc9dc35a1e6bf)), closes [#408](https://github.com/uuidjs/uuid/issues/408)
+
+### [7.0.2](https://github.com/uuidjs/uuid/compare/v7.0.1...v7.0.2) (2020-03-04)
+
+### Bug Fixes
+
+- make access to msCrypto consistent ([#393](https://github.com/uuidjs/uuid/issues/393)) ([8bf2a20](https://github.com/uuidjs/uuid/commit/8bf2a20f3565df743da7215eebdbada9d2df118c))
+- simplify link in deprecation warning ([#391](https://github.com/uuidjs/uuid/issues/391)) ([bb2c8e4](https://github.com/uuidjs/uuid/commit/bb2c8e4e9f4c5f9c1eaaf3ea59710c633cd90cb7))
+- update links to match content in readme ([#386](https://github.com/uuidjs/uuid/issues/386)) ([44f2f86](https://github.com/uuidjs/uuid/commit/44f2f86e9d2bbf14ee5f0f00f72a3db1292666d4))
+
+### [7.0.1](https://github.com/uuidjs/uuid/compare/v7.0.0...v7.0.1) (2020-02-25)
+
+### Bug Fixes
+
+- clean up esm builds for node and browser ([#383](https://github.com/uuidjs/uuid/issues/383)) ([59e6a49](https://github.com/uuidjs/uuid/commit/59e6a49e7ce7b3e8fb0f3ee52b9daae72af467dc))
+- provide browser versions independent from module system ([#380](https://github.com/uuidjs/uuid/issues/380)) ([4344a22](https://github.com/uuidjs/uuid/commit/4344a22e7aed33be8627eeaaf05360f256a21753)), closes [#378](https://github.com/uuidjs/uuid/issues/378)
+
+## [7.0.0](https://github.com/uuidjs/uuid/compare/v3.4.0...v7.0.0) (2020-02-24)
+
+### ⚠ BREAKING CHANGES
+
+- The default export, which used to be the v4() method but which was already discouraged in v3.x of this library, has been removed.
+- Explicitly note that deep imports of the different uuid version functions are deprecated and no longer encouraged and that ECMAScript module named imports should be used instead. Emit a deprecation warning for people who deep-require the different algorithm variants.
+- Remove builtin support for insecure random number generators in the browser. Users who want that will have to supply their own random number generator function.
+- Remove support for generating v3 and v5 UUIDs in Node.js<4.x
+- Convert code base to ECMAScript Modules (ESM) and release CommonJS build for node and ESM build for browser bundlers.
+
+### Features
+
+- add UMD build to npm package ([#357](https://github.com/uuidjs/uuid/issues/357)) ([4e75adf](https://github.com/uuidjs/uuid/commit/4e75adf435196f28e3fbbe0185d654b5ded7ca2c)), closes [#345](https://github.com/uuidjs/uuid/issues/345)
+- add various es module and CommonJS examples ([b238510](https://github.com/uuidjs/uuid/commit/b238510bf352463521f74bab175a3af9b7a42555))
+- ensure that docs are up-to-date in CI ([ee5e77d](https://github.com/uuidjs/uuid/commit/ee5e77db547474f5a8f23d6c857a6d399209986b))
+- hybrid CommonJS & ECMAScript modules build ([a3f078f](https://github.com/uuidjs/uuid/commit/a3f078faa0baff69ab41aed08e041f8f9c8993d0))
+- remove insecure fallback random number generator ([3a5842b](https://github.com/uuidjs/uuid/commit/3a5842b141a6e5de0ae338f391661e6b84b167c9)), closes [#173](https://github.com/uuidjs/uuid/issues/173)
+- remove support for pre Node.js v4 Buffer API ([#356](https://github.com/uuidjs/uuid/issues/356)) ([b59b5c5](https://github.com/uuidjs/uuid/commit/b59b5c5ecad271c5453f1a156f011671f6d35627))
+- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([c37a518](https://github.com/uuidjs/uuid/commit/c37a518e367ac4b6d0aa62dba1bc6ce9e85020f7)), closes [#338](https://github.com/uuidjs/uuid/issues/338)
+
+### Bug Fixes
+
+- add deep-require proxies for local testing and adjust tests ([#365](https://github.com/uuidjs/uuid/issues/365)) ([7fedc79](https://github.com/uuidjs/uuid/commit/7fedc79ac8fda4bfd1c566c7f05ef4ac13b2db48))
+- add note about removal of default export ([#372](https://github.com/uuidjs/uuid/issues/372)) ([12749b7](https://github.com/uuidjs/uuid/commit/12749b700eb49db8a9759fd306d8be05dbfbd58c)), closes [#370](https://github.com/uuidjs/uuid/issues/370)
+- deprecated deep requiring of the different algorithm versions ([#361](https://github.com/uuidjs/uuid/issues/361)) ([c0bdf15](https://github.com/uuidjs/uuid/commit/c0bdf15e417639b1aeb0b247b2fb11f7a0a26b23))
+
+## [3.4.0](https://github.com/uuidjs/uuid/compare/v3.3.3...v3.4.0) (2020-01-16)
+
+### Features
+
+- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([e2d7314](https://github.com/uuidjs/uuid/commit/e2d7314)), closes [#338](https://github.com/uuidjs/uuid/issues/338)
+
+## [3.3.3](https://github.com/uuidjs/uuid/compare/v3.3.2...v3.3.3) (2019-08-19)
+
+### Bug Fixes
+
+- no longer run ci tests on node v4
+- upgrade dependencies
+
+## [3.3.2](https://github.com/uuidjs/uuid/compare/v3.3.1...v3.3.2) (2018-06-28)
+
+### Bug Fixes
+
+- typo ([305d877](https://github.com/uuidjs/uuid/commit/305d877))
+
+## [3.3.1](https://github.com/uuidjs/uuid/compare/v3.3.0...v3.3.1) (2018-06-28)
+
+### Bug Fixes
+
+- fix [#284](https://github.com/uuidjs/uuid/issues/284) by setting function name in try-catch ([f2a60f2](https://github.com/uuidjs/uuid/commit/f2a60f2))
+
+# [3.3.0](https://github.com/uuidjs/uuid/compare/v3.2.1...v3.3.0) (2018-06-22)
+
+### Bug Fixes
+
+- assignment to readonly property to allow running in strict mode ([#270](https://github.com/uuidjs/uuid/issues/270)) ([d062fdc](https://github.com/uuidjs/uuid/commit/d062fdc))
+- fix [#229](https://github.com/uuidjs/uuid/issues/229) ([c9684d4](https://github.com/uuidjs/uuid/commit/c9684d4))
+- Get correct version of IE11 crypto ([#274](https://github.com/uuidjs/uuid/issues/274)) ([153d331](https://github.com/uuidjs/uuid/commit/153d331))
+- mem issue when generating uuid ([#267](https://github.com/uuidjs/uuid/issues/267)) ([c47702c](https://github.com/uuidjs/uuid/commit/c47702c))
+
+### Features
+
+- enforce Conventional Commit style commit messages ([#282](https://github.com/uuidjs/uuid/issues/282)) ([cc9a182](https://github.com/uuidjs/uuid/commit/cc9a182))
+
+## [3.2.1](https://github.com/uuidjs/uuid/compare/v3.2.0...v3.2.1) (2018-01-16)
+
+### Bug Fixes
+
+- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b))
+
+# [3.2.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.2.0) (2018-01-16)
+
+### Bug Fixes
+
+- remove mistakenly added typescript dependency, rollback version (standard-version will auto-increment) ([09fa824](https://github.com/uuidjs/uuid/commit/09fa824))
+- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b))
+
+### Features
+
+- Add v3 Support ([#217](https://github.com/uuidjs/uuid/issues/217)) ([d94f726](https://github.com/uuidjs/uuid/commit/d94f726))
+
+# [3.1.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.0.1) (2017-06-17)
+
+### Bug Fixes
+
+- (fix) Add .npmignore file to exclude test/ and other non-essential files from packing. (#183)
+- Fix typo (#178)
+- Simple typo fix (#165)
+
+### Features
+
+- v5 support in CLI (#197)
+- V5 support (#188)
+
+# 3.0.1 (2016-11-28)
+
+- split uuid versions into separate files
+
+# 3.0.0 (2016-11-17)
+
+- remove .parse and .unparse
+
+# 2.0.0
+
+- Removed uuid.BufferClass
+
+# 1.4.0
+
+- Improved module context detection
+- Removed public RNG functions
+
+# 1.3.2
+
+- Improve tests and handling of v1() options (Issue #24)
+- Expose RNG option to allow for perf testing with different generators
+
+# 1.3.0
+
+- Support for version 1 ids, thanks to [@ctavan](https://github.com/ctavan)!
+- Support for node.js crypto API
+- De-emphasizing performance in favor of a) cryptographic quality PRNGs where available and b) more manageable code
--- a/node_modules/uuid/CONTRIBUTING.md
+++ b/node_modules/uuid/CONTRIBUTING.md
@ -0,0 +1,18 @@
+# Contributing
+
+Please feel free to file GitHub Issues or propose Pull Requests. We're always happy to discuss improvements to this library!
+
+## Testing
+
+```shell
+npm test
+```
+
+## Releasing
+
+Releases are supposed to be done from master, version bumping is automated through [`standard-version`](https://github.com/conventional-changelog/standard-version):
+
+```shell
+npm run release -- --dry-run  # verify output manually
+npm run release               # follow the instructions from the output of this command
+```
--- a/node_modules/uuid/LICENSE.md
+++ b/node_modules/uuid/LICENSE.md
@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2010-2020 Robert Kieffer and other contributors
+
+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.
--- a/node_modules/uuid/README.md
+++ b/node_modules/uuid/README.md
@ -0,0 +1,505 @@
+<!--
+  -- This file is auto-generated from README_js.md. Changes should be made there.
+  -->
+
+# uuid [![CI](https://github.com/uuidjs/uuid/workflows/CI/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ACI) [![Browser](https://github.com/uuidjs/uuid/workflows/Browser/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ABrowser)
+
+For the creation of [RFC4122](http://www.ietf.org/rfc/rfc4122.txt) UUIDs
+
+- **Complete** - Support for RFC4122 version 1, 3, 4, and 5 UUIDs
+- **Cross-platform** - Support for ...
+  - CommonJS, [ECMAScript Modules](#ecmascript-modules) and [CDN builds](#cdn-builds)
+  - Node 8, 10, 12, 14
+  - Chrome, Safari, Firefox, Edge, IE 11 browsers
+  - Webpack and rollup.js module bundlers
+  - [React Native / Expo](#react-native--expo)
+- **Secure** - Cryptographically-strong random values
+- **Small** - Zero-dependency, small footprint, plays nice with "tree shaking" packagers
+- **CLI** - Includes the [`uuid` command line](#command-line) utility
+
+**Upgrading from `uuid@3.x`?** Your code is probably okay, but check out [Upgrading From `uuid@3.x`](#upgrading-from-uuid3x) for details.
+
+## Quickstart
+
+To create a random UUID...
+
+**1. Install**
+
+```shell
+npm install uuid
+```
+
+**2. Create a UUID** (ES6 module syntax)
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
+```
+
+... or using CommonJS syntax:
+
+```javascript
+const { v4: uuidv4 } = require('uuid');
+uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+```
+
+For timestamp UUIDs, namespace UUIDs, and other options read on ...
+
+## API Summary
+
+|  |  |  |
+| --- | --- | --- |
+| [`uuid.NIL`](#uuidnil) | The nil UUID string (all zeros) | New in `uuid@8.3` |
+| [`uuid.parse()`](#uuidparsestr) | Convert UUID string to array of bytes | New in `uuid@8.3` |
+| [`uuid.stringify()`](#uuidstringifyarr-offset) | Convert array of bytes to UUID string | New in `uuid@8.3` |
+| [`uuid.v1()`](#uuidv1options-buffer-offset) | Create a version 1 (timestamp) UUID |  |
+| [`uuid.v3()`](#uuidv3name-namespace-buffer-offset) | Create a version 3 (namespace w/ MD5) UUID |  |
+| [`uuid.v4()`](#uuidv4options-buffer-offset) | Create a version 4 (random) UUID |  |
+| [`uuid.v5()`](#uuidv5name-namespace-buffer-offset) | Create a version 5 (namespace w/ SHA-1) UUID |  |
+| [`uuid.validate()`](#uuidvalidatestr) | Test a string to see if it is a valid UUID | New in `uuid@8.3` |
+| [`uuid.version()`](#uuidversionstr) | Detect RFC version of a UUID | New in `uuid@8.3` |
+
+## API
+
+### uuid.NIL
+
+The nil UUID string (all zeros).
+
+Example:
+
+```javascript
+import { NIL as NIL_UUID } from 'uuid';
+
+NIL_UUID; // ⇨ '00000000-0000-0000-0000-000000000000'
+```
+
+### uuid.parse(str)
+
+Convert UUID string to array of bytes
+
+|           |                                          |
+| --------- | ---------------------------------------- |
+| `str`     | A valid UUID `String`                    |
+| _returns_ | `Uint8Array[16]`                         |
+| _throws_  | `TypeError` if `str` is not a valid UUID |
+
+Note: Ordering of values in the byte arrays used by `parse()` and `stringify()` follows the left &Rarr; right order of hex-pairs in UUID strings. As shown in the example below.
+
+Example:
+
+```javascript
+import { parse as uuidParse } from 'uuid';
+
+// Parse a UUID
+const bytes = uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b');
+
+// Convert to hex strings to show byte order (for documentation purposes)
+[...bytes].map((v) => v.toString(16).padStart(2, '0')); // ⇨ 
+  // [
+  //   '6e', 'c0', 'bd', '7f',
+  //   '11', 'c0', '43', 'da',
+  //   '97', '5e', '2a', '8a',
+  //   'd9', 'eb', 'ae', '0b'
+  // ]
+```
+
+### uuid.stringify(arr[, offset])
+
+Convert array of bytes to UUID string
+
+|                |                                                                              |
+| -------------- | ---------------------------------------------------------------------------- |
+| `arr`          | `Array`-like collection of 16 values (starting from `offset`) between 0-255. |
+| [`offset` = 0] | `Number` Starting index in the Array                                         |
+| _returns_      | `String`                                                                     |
+| _throws_       | `TypeError` if a valid UUID string cannot be generated                       |
+
+Note: Ordering of values in the byte arrays used by `parse()` and `stringify()` follows the left &Rarr; right order of hex-pairs in UUID strings. As shown in the example below.
+
+Example:
+
+```javascript
+import { stringify as uuidStringify } from 'uuid';
+
+const uuidBytes = [
+  0x6e,
+  0xc0,
+  0xbd,
+  0x7f,
+  0x11,
+  0xc0,
+  0x43,
+  0xda,
+  0x97,
+  0x5e,
+  0x2a,
+  0x8a,
+  0xd9,
+  0xeb,
+  0xae,
+  0x0b,
+];
+
+uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'
+```
+
+### uuid.v1([options[, buffer[, offset]]])
+
+Create an RFC version 1 (timestamp) UUID
+
+|  |  |
+| --- | --- |
+| [`options`] | `Object` with one or more of the following properties: |
+| [`options.node` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6) |
+| [`options.clockseq`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff |
+| [`options.msecs`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) |
+| [`options.nsecs`] | RFC "timestamp" field (`Number` of nanseconds to add to `msecs`, should be 0-10,000) |
+| [`options.random`] | `Array` of 16 random bytes (0-255) |
+| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
+| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+| _throws_ | `Error` if more than 10M UUIDs/sec are requested |
+
+Note: The default [node id](https://tools.ietf.org/html/rfc4122#section-4.1.6) (the last 12 digits in the UUID) is generated once, randomly, on process startup, and then remains unchanged for the duration of the process.
+
+Note: `options.random` and `options.rng` are only meaningful on the very first call to `v1()`, where they may be passed to initialize the internal `node` and `clockseq` fields.
+
+Example:
+
+```javascript
+import { v1 as uuidv1 } from 'uuid';
+
+uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-8bad-9b1deb4d3b7d'
+```
+
+Example using `options`:
+
+```javascript
+import { v1 as uuidv1 } from 'uuid';
+
+const v1options = {
+  node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
+  clockseq: 0x1234,
+  msecs: new Date('2011-11-01').getTime(),
+  nsecs: 5678,
+};
+uuidv1(v1options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'
+```
+
+### uuid.v3(name, namespace[, buffer[, offset]])
+
+Create an RFC version 3 (namespace w/ MD5) UUID
+
+API is identical to `v5()`, but uses "v3" instead.
+
+&#x26a0;&#xfe0f; Note: Per the RFC, "_If backward compatibility is not an issue, SHA-1 [Version 5] is preferred_."
+
+### uuid.v4([options[, buffer[, offset]]])
+
+Create an RFC version 4 (random) UUID
+
+|  |  |
+| --- | --- |
+| [`options`] | `Object` with one or more of the following properties: |
+| [`options.random`] | `Array` of 16 random bytes (0-255) |
+| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
+| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+
+Example:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+
+uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+```
+
+Example using predefined `random` values:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+
+const v4options = {
+  random: [
+    0x10,
+    0x91,
+    0x56,
+    0xbe,
+    0xc4,
+    0xfb,
+    0xc1,
+    0xea,
+    0x71,
+    0xb4,
+    0xef,
+    0xe1,
+    0x67,
+    0x1c,
+    0x58,
+    0x36,
+  ],
+};
+uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'
+```
+
+### uuid.v5(name, namespace[, buffer[, offset]])
+
+Create an RFC version 5 (namespace w/ SHA-1) UUID
+
+|  |  |
+| --- | --- |
+| `name` | `String \| Array` |
+| `namespace` | `String \| Array[16]` Namespace UUID |
+| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+
+Note: The RFC `DNS` and `URL` namespaces are available as `v5.DNS` and `v5.URL`.
+
+Example with custom namespace:
+
+```javascript
+import { v5 as uuidv5 } from 'uuid';
+
+// Define a custom namespace.  Readers, create your own using something like
+// https://www.uuidgenerator.net/
+const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
+
+uuidv5('Hello, World!', MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'
+```
+
+Example with RFC `URL` namespace:
+
+```javascript
+import { v5 as uuidv5 } from 'uuid';
+
+uuidv5('https://www.w3.org/', uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'
+```
+
+### uuid.validate(str)
+
+Test a string to see if it is a valid UUID
+
+|           |                                                     |
+| --------- | --------------------------------------------------- |
+| `str`     | `String` to validate                                |
+| _returns_ | `true` if string is a valid UUID, `false` otherwise |
+
+Example:
+
+```javascript
+import { validate as uuidValidate } from 'uuid';
+
+uuidValidate('not a UUID'); // ⇨ false
+uuidValidate('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ true
+```
+
+Using `validate` and `version` together it is possible to do per-version validation, e.g. validate for only v4 UUIds.
+
+```javascript
+import { version as uuidVersion } from 'uuid';
+import { validate as uuidValidate } from 'uuid';
+
+function uuidValidateV4(uuid) {
+  return uuidValidate(uuid) && uuidVersion(uuid) === 4;
+}
+
+const v1Uuid = 'd9428888-122b-11e1-b85c-61cd3cbb3210';
+const v4Uuid = '109156be-c4fb-41ea-b1b4-efe1671c5836';
+
+uuidValidateV4(v4Uuid); // ⇨ true
+uuidValidateV4(v1Uuid); // ⇨ false
+```
+
+### uuid.version(str)
+
+Detect RFC version of a UUID
+
+|           |                                          |
+| --------- | ---------------------------------------- |
+| `str`     | A valid UUID `String`                    |
+| _returns_ | `Number` The RFC version of the UUID     |
+| _throws_  | `TypeError` if `str` is not a valid UUID |
+
+Example:
+
+```javascript
+import { version as uuidVersion } from 'uuid';
+
+uuidVersion('45637ec4-c85f-11ea-87d0-0242ac130003'); // ⇨ 1
+uuidVersion('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ 4
+```
+
+## Command Line
+
+UUIDs can be generated from the command line using `uuid`.
+
+```shell
+$ uuid
+ddeb27fb-d9a0-4624-be4d-4615062daed4
+```
+
+The default is to generate version 4 UUIDS, however the other versions are supported. Type `uuid --help` for details:
+
+```shell
+$ uuid --help
+
+Usage:
+  uuid
+  uuid v1
+  uuid v3 <name> <namespace uuid>
+  uuid v4
+  uuid v5 <name> <namespace uuid>
+  uuid --help
+
+Note: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs
+defined by RFC4122
+```
+
+## ECMAScript Modules
+
+This library comes with [ECMAScript Modules](https://www.ecma-international.org/ecma-262/6.0/#sec-modules) (ESM) support for Node.js versions that support it ([example](./examples/node-esmodules/)) as well as bundlers like [rollup.js](https://rollupjs.org/guide/en/#tree-shaking) ([example](./examples/browser-rollup/)) and [webpack](https://webpack.js.org/guides/tree-shaking/) ([example](./examples/browser-webpack/)) (targeting both, Node.js and browser environments).
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+```
+
+To run the examples you must first create a dist build of this library in the module root:
+
+```shell
+npm run build
+```
+
+## CDN Builds
+
+### ECMAScript Modules
+
+To load this module directly into modern browsers that [support loading ECMAScript Modules](https://caniuse.com/#feat=es6-module) you can make use of [jspm](https://jspm.org/):
+
+```html
+<script type="module">
+  import { v4 as uuidv4 } from 'https://jspm.dev/uuid';
+  console.log(uuidv4()); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+</script>
+```
+
+### UMD
+
+To load this module directly into older browsers you can use the [UMD (Universal Module Definition)](https://github.com/umdjs/umd) builds from any of the following CDNs:
+
+**Using [UNPKG](https://unpkg.com/uuid@latest/dist/umd/)**:
+
+```html
+<script src="https://unpkg.com/uuid@latest/dist/umd/uuidv4.min.js"></script>
+```
+
+**Using [jsDelivr](https://cdn.jsdelivr.net/npm/uuid@latest/dist/umd/)**:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/uuid@latest/dist/umd/uuidv4.min.js"></script>
+```
+
+**Using [cdnjs](https://cdnjs.com/libraries/uuid)**:
+
+```html
+<script src="https://cdnjs.cloudflare.com/ajax/libs/uuid/8.1.0/uuidv4.min.js"></script>
+```
+
+These CDNs all provide the same [`uuidv4()`](#uuidv4options-buffer-offset) method:
+
+```html
+<script>
+  uuidv4(); // ⇨ '55af1e37-0734-46d8-b070-a1e42e4fc392'
+</script>
+```
+
+Methods for the other algorithms ([`uuidv1()`](#uuidv1options-buffer-offset), [`uuidv3()`](#uuidv3name-namespace-buffer-offset) and [`uuidv5()`](#uuidv5name-namespace-buffer-offset)) are available from the files `uuidv1.min.js`, `uuidv3.min.js` and `uuidv5.min.js` respectively.
+
+## "getRandomValues() not supported"
+
+This error occurs in environments where the standard [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) API is not supported. This issue can be resolved by adding an appropriate polyfill:
+
+### React Native / Expo
+
+1. Install [`react-native-get-random-values`](https://github.com/LinusU/react-native-get-random-values#readme)
+1. Import it _before_ `uuid`. Since `uuid` might also appear as a transitive dependency of some other imports it's safest to just import `react-native-get-random-values` as the very first thing in your entry point:
+
+```javascript
+import 'react-native-get-random-values';
+import { v4 as uuidv4 } from 'uuid';
+```
+
+Note: If you are using Expo, you must be using at least `react-native-get-random-values@1.5.0` and `expo@39.0.0`.
+
+### Web Workers / Service Workers (Edge <= 18)
+
+[In Edge <= 18, Web Crypto is not supported in Web Workers or Service Workers](https://caniuse.com/#feat=cryptography) and we are not aware of a polyfill (let us know if you find one, please).
+
+## Upgrading From `uuid@7.x`
+
+### Only Named Exports Supported When Using with Node.js ESM
+
+`uuid@7.x` did not come with native ECMAScript Module (ESM) support for Node.js. Importing it in Node.js ESM consequently imported the CommonJS source with a default export. This library now comes with true Node.js ESM support and only provides named exports.
+
+Instead of doing:
+
+```javascript
+import uuid from 'uuid';
+uuid.v4();
+```
+
+you will now have to use the named exports:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+uuidv4();
+```
+
+### Deep Requires No Longer Supported
+
+Deep requires like `require('uuid/v4')` [which have been deprecated in `uuid@7.x`](#deep-requires-now-deprecated) are no longer supported.
+
+## Upgrading From `uuid@3.x`
+
+"_Wait... what happened to `uuid@4.x` - `uuid@6.x`?!?_"
+
+In order to avoid confusion with RFC [version 4](#uuidv4options-buffer-offset) and [version 5](#uuidv5name-namespace-buffer-offset) UUIDs, and a possible [version 6](http://gh.peabody.io/uuidv6/), releases 4 thru 6 of this module have been skipped.
+
+### Deep Requires Now Deprecated
+
+`uuid@3.x` encouraged the use of deep requires to minimize the bundle size of browser builds:
+
+```javascript
+const uuidv4 = require('uuid/v4'); // <== NOW DEPRECATED!
+uuidv4();
+```
+
+As of `uuid@7.x` this library now provides ECMAScript modules builds, which allow packagers like Webpack and Rollup to do "tree-shaking" to remove dead code. Instead, use the `import` syntax:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+uuidv4();
+```
+
+... or for CommonJS:
+
+```javascript
+const { v4: uuidv4 } = require('uuid');
+uuidv4();
+```
+
+### Default Export Removed
+
+`uuid@3.x` was exporting the Version 4 UUID method as a default export:
+
+```javascript
+const uuid = require('uuid'); // <== REMOVED!
+```
+
+This usage pattern was already discouraged in `uuid@3.x` and has been removed in `uuid@7.x`.
+
+----
+Markdown generated from [README_js.md](README_js.md) by [![RunMD Logo](http://i.imgur.com/h0FVyzU.png)](https://github.com/broofa/runmd)
--- a/node_modules/uuid/dist/bin/uuid
+++ b/node_modules/uuid/dist/bin/uuid
@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../uuid-bin');
--- a/node_modules/uuid/dist/esm-browser/index.js
+++ b/node_modules/uuid/dist/esm-browser/index.js
@ -0,0 +1,9 @@
+export { default as v1 } from './v1.js';
+export { default as v3 } from './v3.js';
+export { default as v4 } from './v4.js';
+export { default as v5 } from './v5.js';
+export { default as NIL } from './nil.js';
+export { default as version } from './version.js';
+export { default as validate } from './validate.js';
+export { default as stringify } from './stringify.js';
+export { default as parse } from './parse.js';
--- a/node_modules/uuid/dist/esm-browser/md5.js
+++ b/node_modules/uuid/dist/esm-browser/md5.js
@ -0,0 +1,215 @@
+/*
+ * Browser-compatible JavaScript MD5
+ *
+ * Modification of JavaScript MD5
+ * https://github.com/blueimp/JavaScript-MD5
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ *
+ * Based on
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+function md5(bytes) {
+  if (typeof bytes === 'string') {
+    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = new Uint8Array(msg.length);
+
+    for (var i = 0; i < msg.length; ++i) {
+      bytes[i] = msg.charCodeAt(i);
+    }
+  }
+
+  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+}
+/*
+ * Convert an array of little-endian words to an array of bytes
+ */
+
+
+function md5ToHexEncodedArray(input) {
+  var output = [];
+  var length32 = input.length * 32;
+  var hexTab = '0123456789abcdef';
+
+  for (var i = 0; i < length32; i += 8) {
+    var x = input[i >> 5] >>> i % 32 & 0xff;
+    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+    output.push(hex);
+  }
+
+  return output;
+}
+/**
+ * Calculate output length with padding and bit length
+ */
+
+
+function getOutputLength(inputLength8) {
+  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+}
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length.
+ */
+
+
+function wordsToMd5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[getOutputLength(len) - 1] = len;
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+
+  return [a, b, c, d];
+}
+/*
+ * Convert an array bytes to an array of little-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+
+
+function bytesToWords(input) {
+  if (input.length === 0) {
+    return [];
+  }
+
+  var length8 = input.length * 8;
+  var output = new Uint32Array(getOutputLength(length8));
+
+  for (var i = 0; i < length8; i += 8) {
+    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+  }
+
+  return output;
+}
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+
+
+function safeAdd(x, y) {
+  var lsw = (x & 0xffff) + (y & 0xffff);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xffff;
+}
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+export default md5;
--- a/node_modules/uuid/dist/esm-browser/nil.js
+++ b/node_modules/uuid/dist/esm-browser/nil.js
@ -0,0 +1 @@
+export default '00000000-0000-0000-0000-000000000000';
--- a/node_modules/uuid/dist/esm-browser/parse.js
+++ b/node_modules/uuid/dist/esm-browser/parse.js
@ -0,0 +1,35 @@
+import validate from './validate.js';
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  var v;
+  var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+export default parse;
--- a/node_modules/uuid/dist/esm-browser/regex.js
+++ b/node_modules/uuid/dist/esm-browser/regex.js
@ -0,0 +1 @@
+export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
--- a/node_modules/uuid/dist/esm-browser/rng.js
+++ b/node_modules/uuid/dist/esm-browser/rng.js
@ -0,0 +1,19 @@
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+export default function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
--- a/node_modules/uuid/dist/esm-browser/sha1.js
+++ b/node_modules/uuid/dist/esm-browser/sha1.js
@ -0,0 +1,96 @@
+// Adapted from Chris Veness' SHA1 code at
+// http://www.movable-type.co.uk/scripts/sha1.html
+function f(s, x, y, z) {
+  switch (s) {
+    case 0:
+      return x & y ^ ~x & z;
+
+    case 1:
+      return x ^ y ^ z;
+
+    case 2:
+      return x & y ^ x & z ^ y & z;
+
+    case 3:
+      return x ^ y ^ z;
+  }
+}
+
+function ROTL(x, n) {
+  return x << n | x >>> 32 - n;
+}
+
+function sha1(bytes) {
+  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+  if (typeof bytes === 'string') {
+    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = [];
+
+    for (var i = 0; i < msg.length; ++i) {
+      bytes.push(msg.charCodeAt(i));
+    }
+  } else if (!Array.isArray(bytes)) {
+    // Convert Array-like to Array
+    bytes = Array.prototype.slice.call(bytes);
+  }
+
+  bytes.push(0x80);
+  var l = bytes.length / 4 + 2;
+  var N = Math.ceil(l / 16);
+  var M = new Array(N);
+
+  for (var _i = 0; _i < N; ++_i) {
+    var arr = new Uint32Array(16);
+
+    for (var j = 0; j < 16; ++j) {
+      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
+    }
+
+    M[_i] = arr;
+  }
+
+  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+
+  for (var _i2 = 0; _i2 < N; ++_i2) {
+    var W = new Uint32Array(80);
+
+    for (var t = 0; t < 16; ++t) {
+      W[t] = M[_i2][t];
+    }
+
+    for (var _t = 16; _t < 80; ++_t) {
+      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
+    }
+
+    var a = H[0];
+    var b = H[1];
+    var c = H[2];
+    var d = H[3];
+    var e = H[4];
+
+    for (var _t2 = 0; _t2 < 80; ++_t2) {
+      var s = Math.floor(_t2 / 20);
+      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
+      e = d;
+      d = c;
+      c = ROTL(b, 30) >>> 0;
+      b = a;
+      a = T;
+    }
+
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+  }
+
+  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+}
+
+export default sha1;
--- a/node_modules/uuid/dist/esm-browser/stringify.js
+++ b/node_modules/uuid/dist/esm-browser/stringify.js
@ -0,0 +1,30 @@
+import validate from './validate.js';
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+var byteToHex = [];
+
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+export default stringify;
--- a/node_modules/uuid/dist/esm-browser/v1.js
+++ b/node_modules/uuid/dist/esm-browser/v1.js
@ -0,0 +1,95 @@
+import rng from './rng.js';
+import stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**
+//
+// Inspired by https://github.com/LiosK/UUID.js
+// and http://docs.python.org/library/uuid.html
+
+var _nodeId;
+
+var _clockseq; // Previous uuid creation time
+
+
+var _lastMSecs = 0;
+var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
+
+function v1(options, buf, offset) {
+  var i = buf && offset || 0;
+  var b = buf || new Array(16);
+  options = options || {};
+  var node = options.node || _nodeId;
+  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
+  // specified.  We do this lazily to minimize issues related to insufficient
+  // system entropy.  See #189
+
+  if (node == null || clockseq == null) {
+    var seedBytes = options.random || (options.rng || rng)();
+
+    if (node == null) {
+      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+    }
+
+    if (clockseq == null) {
+      // Per 4.2.2, randomize (14 bit) clockseq
+      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+    }
+  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+
+
+  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
+  // cycle to simulate higher resolution clock
+
+  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
+
+  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
+
+  if (dt < 0 && options.clockseq === undefined) {
+    clockseq = clockseq + 1 & 0x3fff;
+  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+  // time interval
+
+
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+    nsecs = 0;
+  } // Per 4.2.1.2 Throw error if too many uuids are requested
+
+
+  if (nsecs >= 10000) {
+    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+  }
+
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+
+  msecs += 12219292800000; // `time_low`
+
+  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+  b[i++] = tl >>> 24 & 0xff;
+  b[i++] = tl >>> 16 & 0xff;
+  b[i++] = tl >>> 8 & 0xff;
+  b[i++] = tl & 0xff; // `time_mid`
+
+  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
+  b[i++] = tmh >>> 8 & 0xff;
+  b[i++] = tmh & 0xff; // `time_high_and_version`
+
+  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+
+  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+
+  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
+
+  b[i++] = clockseq & 0xff; // `node`
+
+  for (var n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+
+  return buf || stringify(b);
+}
+
+export default v1;
--- a/node_modules/uuid/dist/esm-browser/v3.js
+++ b/node_modules/uuid/dist/esm-browser/v3.js
@ -0,0 +1,4 @@
+import v35 from './v35.js';
+import md5 from './md5.js';
+var v3 = v35('v3', 0x30, md5);
+export default v3;
--- a/node_modules/uuid/dist/esm-browser/v35.js
+++ b/node_modules/uuid/dist/esm-browser/v35.js
@ -0,0 +1,64 @@
+import stringify from './stringify.js';
+import parse from './parse.js';
+
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+  var bytes = [];
+
+  for (var i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+
+  return bytes;
+}
+
+export var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+export var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+export default function (name, version, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
+
+    if (typeof namespace === 'string') {
+      namespace = parse(namespace);
+    }
+
+    if (namespace.length !== 16) {
+      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    } // Compute hash of namespace and value, Per 4.3
+    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+    // hashfunc([...namespace, ... value])`
+
+
+    var bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 0x0f | version;
+    bytes[8] = bytes[8] & 0x3f | 0x80;
+
+    if (buf) {
+      offset = offset || 0;
+
+      for (var i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+
+      return buf;
+    }
+
+    return stringify(bytes);
+  } // Function#name is not settable on some platforms (#270)
+
+
+  try {
+    generateUUID.name = name; // eslint-disable-next-line no-empty
+  } catch (err) {} // For CommonJS default export support
+
+
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL;
+  return generateUUID;
+}
--- a/node_modules/uuid/dist/esm-browser/v4.js
+++ b/node_modules/uuid/dist/esm-browser/v4.js
@ -0,0 +1,24 @@
+import rng from './rng.js';
+import stringify from './stringify.js';
+
+function v4(options, buf, offset) {
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (var i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return stringify(rnds);
+}
+
+export default v4;
--- a/node_modules/uuid/dist/esm-browser/v5.js
+++ b/node_modules/uuid/dist/esm-browser/v5.js
@ -0,0 +1,4 @@
+import v35 from './v35.js';
+import sha1 from './sha1.js';
+var v5 = v35('v5', 0x50, sha1);
+export default v5;
--- a/node_modules/uuid/dist/esm-browser/validate.js
+++ b/node_modules/uuid/dist/esm-browser/validate.js
@ -0,0 +1,7 @@
+import REGEX from './regex.js';
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+export default validate;
--- a/node_modules/uuid/dist/esm-browser/version.js
+++ b/node_modules/uuid/dist/esm-browser/version.js
@ -0,0 +1,11 @@
+import validate from './validate.js';
+
+function version(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  return parseInt(uuid.substr(14, 1), 16);
+}
+
+export default version;
--- a/node_modules/uuid/dist/esm-node/index.js
+++ b/node_modules/uuid/dist/esm-node/index.js
@ -0,0 +1,9 @@
+export { default as v1 } from './v1.js';
+export { default as v3 } from './v3.js';
+export { default as v4 } from './v4.js';
+export { default as v5 } from './v5.js';
+export { default as NIL } from './nil.js';
+export { default as version } from './version.js';
+export { default as validate } from './validate.js';
+export { default as stringify } from './stringify.js';
+export { default as parse } from './parse.js';
--- a/node_modules/uuid/dist/esm-node/md5.js
+++ b/node_modules/uuid/dist/esm-node/md5.js
@ -0,0 +1,13 @@
+import crypto from 'crypto';
+
+function md5(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
+
+  return crypto.createHash('md5').update(bytes).digest();
+}
+
+export default md5;
--- a/node_modules/uuid/dist/esm-node/nil.js
+++ b/node_modules/uuid/dist/esm-node/nil.js
@ -0,0 +1 @@
+export default '00000000-0000-0000-0000-000000000000';
--- a/node_modules/uuid/dist/esm-node/parse.js
+++ b/node_modules/uuid/dist/esm-node/parse.js
@ -0,0 +1,35 @@
+import validate from './validate.js';
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  let v;
+  const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+export default parse;
--- a/node_modules/uuid/dist/esm-node/regex.js
+++ b/node_modules/uuid/dist/esm-node/regex.js
@ -0,0 +1 @@
+export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
--- a/node_modules/uuid/dist/esm-node/rng.js
+++ b/node_modules/uuid/dist/esm-node/rng.js
@ -0,0 +1,12 @@
+import crypto from 'crypto';
+const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
+
+let poolPtr = rnds8Pool.length;
+export default function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
--- a/node_modules/uuid/dist/esm-node/sha1.js
+++ b/node_modules/uuid/dist/esm-node/sha1.js
@ -0,0 +1,13 @@
+import crypto from 'crypto';
+
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
+
+  return crypto.createHash('sha1').update(bytes).digest();
+}
+
+export default sha1;
--- a/node_modules/uuid/dist/esm-node/stringify.js
+++ b/node_modules/uuid/dist/esm-node/stringify.js
@ -0,0 +1,29 @@
+import validate from './validate.js';
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+export default stringify;
--- a/node_modules/uuid/dist/esm-node/v1.js
+++ b/node_modules/uuid/dist/esm-node/v1.js
@ -0,0 +1,95 @@
+import rng from './rng.js';
+import stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**
+//
+// Inspired by https://github.com/LiosK/UUID.js
+// and http://docs.python.org/library/uuid.html
+
+let _nodeId;
+
+let _clockseq; // Previous uuid creation time
+
+
+let _lastMSecs = 0;
+let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
+
+function v1(options, buf, offset) {
+  let i = buf && offset || 0;
+  const b = buf || new Array(16);
+  options = options || {};
+  let node = options.node || _nodeId;
+  let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
+  // specified.  We do this lazily to minimize issues related to insufficient
+  // system entropy.  See #189
+
+  if (node == null || clockseq == null) {
+    const seedBytes = options.random || (options.rng || rng)();
+
+    if (node == null) {
+      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+    }
+
+    if (clockseq == null) {
+      // Per 4.2.2, randomize (14 bit) clockseq
+      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+    }
+  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+
+
+  let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
+  // cycle to simulate higher resolution clock
+
+  let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
+
+  const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
+
+  if (dt < 0 && options.clockseq === undefined) {
+    clockseq = clockseq + 1 & 0x3fff;
+  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+  // time interval
+
+
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+    nsecs = 0;
+  } // Per 4.2.1.2 Throw error if too many uuids are requested
+
+
+  if (nsecs >= 10000) {
+    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+  }
+
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+
+  msecs += 12219292800000; // `time_low`
+
+  const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+  b[i++] = tl >>> 24 & 0xff;
+  b[i++] = tl >>> 16 & 0xff;
+  b[i++] = tl >>> 8 & 0xff;
+  b[i++] = tl & 0xff; // `time_mid`
+
+  const tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
+  b[i++] = tmh >>> 8 & 0xff;
+  b[i++] = tmh & 0xff; // `time_high_and_version`
+
+  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+
+  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+
+  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
+
+  b[i++] = clockseq & 0xff; // `node`
+
+  for (let n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+
+  return buf || stringify(b);
+}
+
+export default v1;
--- a/node_modules/uuid/dist/esm-node/v3.js
+++ b/node_modules/uuid/dist/esm-node/v3.js
@ -0,0 +1,4 @@
+import v35 from './v35.js';
+import md5 from './md5.js';
+const v3 = v35('v3', 0x30, md5);
+export default v3;
--- a/node_modules/uuid/dist/esm-node/v35.js
+++ b/node_modules/uuid/dist/esm-node/v35.js
@ -0,0 +1,64 @@
+import stringify from './stringify.js';
+import parse from './parse.js';
+
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+  const bytes = [];
+
+  for (let i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+
+  return bytes;
+}
+
+export const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+export default function (name, version, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
+
+    if (typeof namespace === 'string') {
+      namespace = parse(namespace);
+    }
+
+    if (namespace.length !== 16) {
+      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    } // Compute hash of namespace and value, Per 4.3
+    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+    // hashfunc([...namespace, ... value])`
+
+
+    let bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 0x0f | version;
+    bytes[8] = bytes[8] & 0x3f | 0x80;
+
+    if (buf) {
+      offset = offset || 0;
+
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+
+      return buf;
+    }
+
+    return stringify(bytes);
+  } // Function#name is not settable on some platforms (#270)
+
+
+  try {
+    generateUUID.name = name; // eslint-disable-next-line no-empty
+  } catch (err) {} // For CommonJS default export support
+
+
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL;
+  return generateUUID;
+}
--- a/node_modules/uuid/dist/esm-node/v4.js
+++ b/node_modules/uuid/dist/esm-node/v4.js
@ -0,0 +1,24 @@
+import rng from './rng.js';
+import stringify from './stringify.js';
+
+function v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return stringify(rnds);
+}
+
+export default v4;
--- a/node_modules/uuid/dist/esm-node/v5.js
+++ b/node_modules/uuid/dist/esm-node/v5.js
@ -0,0 +1,4 @@
+import v35 from './v35.js';
+import sha1 from './sha1.js';
+const v5 = v35('v5', 0x50, sha1);
+export default v5;
--- a/node_modules/uuid/dist/esm-node/validate.js
+++ b/node_modules/uuid/dist/esm-node/validate.js
@ -0,0 +1,7 @@
+import REGEX from './regex.js';
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+export default validate;
--- a/node_modules/uuid/dist/esm-node/version.js
+++ b/node_modules/uuid/dist/esm-node/version.js
@ -0,0 +1,11 @@
+import validate from './validate.js';
+
+function version(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  return parseInt(uuid.substr(14, 1), 16);
+}
+
+export default version;
--- a/node_modules/uuid/dist/index.js
+++ b/node_modules/uuid/dist/index.js
@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "v1", {
+  enumerable: true,
+  get: function () {
+    return _v.default;
+  }
+});
+Object.defineProperty(exports, "v3", {
+  enumerable: true,
+  get: function () {
+    return _v2.default;
+  }
+});
+Object.defineProperty(exports, "v4", {
+  enumerable: true,
+  get: function () {
+    return _v3.default;
+  }
+});
+Object.defineProperty(exports, "v5", {
+  enumerable: true,
+  get: function () {
+    return _v4.default;
+  }
+});
+Object.defineProperty(exports, "NIL", {
+  enumerable: true,
+  get: function () {
+    return _nil.default;
+  }
+});
+Object.defineProperty(exports, "version", {
+  enumerable: true,
+  get: function () {
+    return _version.default;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _validate.default;
+  }
+});
+Object.defineProperty(exports, "stringify", {
+  enumerable: true,
+  get: function () {
+    return _stringify.default;
+  }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function () {
+    return _parse.default;
+  }
+});
+
+var _v = _interopRequireDefault(require("./v1.js"));
+
+var _v2 = _interopRequireDefault(require("./v3.js"));
+
+var _v3 = _interopRequireDefault(require("./v4.js"));
+
+var _v4 = _interopRequireDefault(require("./v5.js"));
+
+var _nil = _interopRequireDefault(require("./nil.js"));
+
+var _version = _interopRequireDefault(require("./version.js"));
+
+var _validate = _interopRequireDefault(require("./validate.js"));
+
+var _stringify = _interopRequireDefault(require("./stringify.js"));
+
+var _parse = _interopRequireDefault(require("./parse.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
--- a/node_modules/uuid/dist/md5-browser.js
+++ b/node_modules/uuid/dist/md5-browser.js
@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/*
+ * Browser-compatible JavaScript MD5
+ *
+ * Modification of JavaScript MD5
+ * https://github.com/blueimp/JavaScript-MD5
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ *
+ * Based on
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+function md5(bytes) {
+  if (typeof bytes === 'string') {
+    const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = new Uint8Array(msg.length);
+
+    for (let i = 0; i < msg.length; ++i) {
+      bytes[i] = msg.charCodeAt(i);
+    }
+  }
+
+  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+}
+/*
+ * Convert an array of little-endian words to an array of bytes
+ */
+
+
+function md5ToHexEncodedArray(input) {
+  const output = [];
+  const length32 = input.length * 32;
+  const hexTab = '0123456789abcdef';
+
+  for (let i = 0; i < length32; i += 8) {
+    const x = input[i >> 5] >>> i % 32 & 0xff;
+    const hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+    output.push(hex);
+  }
+
+  return output;
+}
+/**
+ * Calculate output length with padding and bit length
+ */
+
+
+function getOutputLength(inputLength8) {
+  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+}
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length.
+ */
+
+
+function wordsToMd5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[getOutputLength(len) - 1] = len;
+  let a = 1732584193;
+  let b = -271733879;
+  let c = -1732584194;
+  let d = 271733878;
+
+  for (let i = 0; i < x.length; i += 16) {
+    const olda = a;
+    const oldb = b;
+    const oldc = c;
+    const oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+
+  return [a, b, c, d];
+}
+/*
+ * Convert an array bytes to an array of little-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+
+
+function bytesToWords(input) {
+  if (input.length === 0) {
+    return [];
+  }
+
+  const length8 = input.length * 8;
+  const output = new Uint32Array(getOutputLength(length8));
+
+  for (let i = 0; i < length8; i += 8) {
+    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+  }
+
+  return output;
+}
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+
+
+function safeAdd(x, y) {
+  const lsw = (x & 0xffff) + (y & 0xffff);
+  const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xffff;
+}
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+var _default = md5;
+exports.default = _default;
--- a/node_modules/uuid/dist/md5.js
+++ b/node_modules/uuid/dist/md5.js
@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function md5(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
+
+  return _crypto.default.createHash('md5').update(bytes).digest();
+}
+
+var _default = md5;
+exports.default = _default;
--- a/node_modules/uuid/dist/nil.js
+++ b/node_modules/uuid/dist/nil.js
@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = '00000000-0000-0000-0000-000000000000';
+exports.default = _default;
--- a/node_modules/uuid/dist/parse.js
+++ b/node_modules/uuid/dist/parse.js
@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validate = _interopRequireDefault(require("./validate.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse(uuid) {
+  if (!(0, _validate.default)(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  let v;
+  const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+var _default = parse;
+exports.default = _default;
--- a/node_modules/uuid/dist/regex.js
+++ b/node_modules/uuid/dist/regex.js
@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+exports.default = _default;
--- a/node_modules/uuid/dist/rng-browser.js
+++ b/node_modules/uuid/dist/rng-browser.js
@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rng;
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
--- a/node_modules/uuid/dist/rng.js
+++ b/node_modules/uuid/dist/rng.js
@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rng;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
+
+let poolPtr = rnds8Pool.length;
+
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    _crypto.default.randomFillSync(rnds8Pool);
+
+    poolPtr = 0;
+  }
+
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
--- a/node_modules/uuid/dist/sha1-browser.js
+++ b/node_modules/uuid/dist/sha1-browser.js
@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+// Adapted from Chris Veness' SHA1 code at
+// http://www.movable-type.co.uk/scripts/sha1.html
+function f(s, x, y, z) {
+  switch (s) {
+    case 0:
+      return x & y ^ ~x & z;
+
+    case 1:
+      return x ^ y ^ z;
+
+    case 2:
+      return x & y ^ x & z ^ y & z;
+
+    case 3:
+      return x ^ y ^ z;
+  }
+}
+
+function ROTL(x, n) {
+  return x << n | x >>> 32 - n;
+}
+
+function sha1(bytes) {
+  const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+  const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+  if (typeof bytes === 'string') {
+    const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = [];
+
+    for (let i = 0; i < msg.length; ++i) {
+      bytes.push(msg.charCodeAt(i));
+    }
+  } else if (!Array.isArray(bytes)) {
+    // Convert Array-like to Array
+    bytes = Array.prototype.slice.call(bytes);
+  }
+
+  bytes.push(0x80);
+  const l = bytes.length / 4 + 2;
+  const N = Math.ceil(l / 16);
+  const M = new Array(N);
+
+  for (let i = 0; i < N; ++i) {
+    const arr = new Uint32Array(16);
+
+    for (let j = 0; j < 16; ++j) {
+      arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
+    }
+
+    M[i] = arr;
+  }
+
+  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+
+  for (let i = 0; i < N; ++i) {
+    const W = new Uint32Array(80);
+
+    for (let t = 0; t < 16; ++t) {
+      W[t] = M[i][t];
+    }
+
+    for (let t = 16; t < 80; ++t) {
+      W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+    }
+
+    let a = H[0];
+    let b = H[1];
+    let c = H[2];
+    let d = H[3];
+    let e = H[4];
+
+    for (let t = 0; t < 80; ++t) {
+      const s = Math.floor(t / 20);
+      const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
+      e = d;
+      d = c;
+      c = ROTL(b, 30) >>> 0;
+      b = a;
+      a = T;
+    }
+
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+  }
+
+  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+}
+
+var _default = sha1;
+exports.default = _default;
--- a/node_modules/uuid/dist/sha1.js
+++ b/node_modules/uuid/dist/sha1.js
@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
+
+  return _crypto.default.createHash('sha1').update(bytes).digest();
+}
+
+var _default = sha1;
+exports.default = _default;
--- a/node_modules/uuid/dist/stringify.js
+++ b/node_modules/uuid/dist/stringify.js
@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validate = _interopRequireDefault(require("./validate.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!(0, _validate.default)(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+var _default = stringify;
+exports.default = _default;
--- a/node_modules/uuid/dist/umd/uuid.min.js
+++ b/node_modules/uuid/dist/umd/uuid.min.js
--- a/node_modules/uuid/dist/umd/uuidNIL.min.js
+++ b/node_modules/uuid/dist/umd/uuidNIL.min.js
@ -0,0 +1 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidNIL=n()}(this,(function(){"use strict";return"00000000-0000-0000-0000-000000000000"}));
--- a/node_modules/uuid/dist/umd/uuidParse.min.js
+++ b/node_modules/uuid/dist/umd/uuidParse.min.js
@ -0,0 +1 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidParse=n()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;return function(n){if(!function(n){return"string"==typeof n&&e.test(n)}(n))throw TypeError("Invalid UUID");var t,i=new Uint8Array(16);return i[0]=(t=parseInt(n.slice(0,8),16))>>>24,i[1]=t>>>16&255,i[2]=t>>>8&255,i[3]=255&t,i[4]=(t=parseInt(n.slice(9,13),16))>>>8,i[5]=255&t,i[6]=(t=parseInt(n.slice(14,18),16))>>>8,i[7]=255&t,i[8]=(t=parseInt(n.slice(19,23),16))>>>8,i[9]=255&t,i[10]=(t=parseInt(n.slice(24,36),16))/1099511627776&255,i[11]=t/4294967296&255,i[12]=t>>>24&255,i[13]=t>>>16&255,i[14]=t>>>8&255,i[15]=255&t,i}}));
--- a/node_modules/uuid/dist/umd/uuidStringify.min.js
+++ b/node_modules/uuid/dist/umd/uuidStringify.min.js
@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidStringify=t()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;function t(t){return"string"==typeof t&&e.test(t)}for(var i=[],n=0;n<256;++n)i.push((n+256).toString(16).substr(1));return function(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,f=(i[e[n+0]]+i[e[n+1]]+i[e[n+2]]+i[e[n+3]]+"-"+i[e[n+4]]+i[e[n+5]]+"-"+i[e[n+6]]+i[e[n+7]]+"-"+i[e[n+8]]+i[e[n+9]]+"-"+i[e[n+10]]+i[e[n+11]]+i[e[n+12]]+i[e[n+13]]+i[e[n+14]]+i[e[n+15]]).toLowerCase();if(!t(f))throw TypeError("Stringified UUID is invalid");return f}}));
--- a/node_modules/uuid/dist/umd/uuidValidate.min.js
+++ b/node_modules/uuid/dist/umd/uuidValidate.min.js
@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidValidate=t()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;return function(t){return"string"==typeof t&&e.test(t)}}));
--- a/node_modules/uuid/dist/umd/uuidVersion.min.js
+++ b/node_modules/uuid/dist/umd/uuidVersion.min.js
@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidVersion=t()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;return function(t){if(!function(t){return"string"==typeof t&&e.test(t)}(t))throw TypeError("Invalid UUID");return parseInt(t.substr(14,1),16)}}));
--- a/node_modules/uuid/dist/umd/uuidv1.min.js
+++ b/node_modules/uuid/dist/umd/uuidv1.min.js
@ -0,0 +1 @@
+!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?module.exports=o():"function"==typeof define&&define.amd?define(o):(e="undefined"!=typeof globalThis?globalThis:e||self).uuidv1=o()}(this,(function(){"use strict";var e,o=new Uint8Array(16);function t(){if(!e&&!(e="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return e(o)}var n=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;function r(e){return"string"==typeof e&&n.test(e)}for(var i,u,s=[],a=0;a<256;++a)s.push((a+256).toString(16).substr(1));var d=0,f=0;return function(e,o,n){var a=o&&n||0,c=o||new Array(16),l=(e=e||{}).node||i,p=void 0!==e.clockseq?e.clockseq:u;if(null==l||null==p){var v=e.random||(e.rng||t)();null==l&&(l=i=[1|v[0],v[1],v[2],v[3],v[4],v[5]]),null==p&&(p=u=16383&(v[6]<<8|v[7]))}var y=void 0!==e.msecs?e.msecs:Date.now(),m=void 0!==e.nsecs?e.nsecs:f+1,g=y-d+(m-f)/1e4;if(g<0&&void 0===e.clockseq&&(p=p+1&16383),(g<0||y>d)&&void 0===e.nsecs&&(m=0),m>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");d=y,f=m,u=p;var h=(1e4*(268435455&(y+=122192928e5))+m)%4294967296;c[a++]=h>>>24&255,c[a++]=h>>>16&255,c[a++]=h>>>8&255,c[a++]=255&h;var w=y/4294967296*1e4&268435455;c[a++]=w>>>8&255,c[a++]=255&w,c[a++]=w>>>24&15|16,c[a++]=w>>>16&255,c[a++]=p>>>8|128,c[a++]=255&p;for(var b=0;b<6;++b)c[a+b]=l[b];return o||function(e){var o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,t=(s[e[o+0]]+s[e[o+1]]+s[e[o+2]]+s[e[o+3]]+"-"+s[e[o+4]]+s[e[o+5]]+"-"+s[e[o+6]]+s[e[o+7]]+"-"+s[e[o+8]]+s[e[o+9]]+"-"+s[e[o+10]]+s[e[o+11]]+s[e[o+12]]+s[e[o+13]]+s[e[o+14]]+s[e[o+15]]).toLowerCase();if(!r(t))throw TypeError("Stringified UUID is invalid");return t}(c)}}));
--- a/node_modules/uuid/dist/umd/uuidv3.min.js
+++ b/node_modules/uuid/dist/umd/uuidv3.min.js
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`export default '00000000-0000-0000-0000-000000000000';`
				`@ -0,0 +1 @@`
				`export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\|00000000-0000-0000-0000-000000000000)$/i;`
				`@ -0,0 +1 @@`
				`!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e="undefined"!=typeof globalThis?globalThis:e\|\|self).uuidNIL=n()}(this,(function(){"use strict";return"00000000-0000-0000-0000-000000000000"}));`
				`@ -0,0 +1 @@`
				!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e="undefined"!=typeof globalThis?globalThis:e\|\|self).uuidParse=n()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\|00000000-0000-0000-0000-000000000000)$/i;return function(n){if(!function(n){return"string"==typeof n&&e.test(n)}(n))throw TypeError("Invalid UUID");var t,i=new Uint8Array(16);return i[0]=(t=parseInt(n.slice(0,8),16))>>>24,i[1]=t>>>16&255,i[2]=t>>>8&255,i[3]=255&t,i[4]=(t=parseInt(n.slice(9,13),16))>>>8,i[5]=255&t,i[6]=(t=parseInt(n.slice(14,18),16))>>>8,i[7]=255&t,i[8]=(t=parseInt(n.slice(19,23),16))>>>8,i[9]=255&t,i[10]=(t=parseInt(n.slice(24,36),16))/1099511627776&255,i[11]=t/4294967296&255,i[12]=t>>>24&255,i[13]=t>>>16&255,i[14]=t>>>8&255,i[15]=255&t,i}}));
				`@ -0,0 +1 @@`
				!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e\|\|self).uuidStringify=t()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\|00000000-0000-0000-0000-000000000000)$/i;function t(t){return"string"==typeof t&&e.test(t)}for(var i=[],n=0;n<256;++n)i.push((n+256).toString(16).substr(1));return function(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,f=(i[e[n+0]]+i[e[n+1]]+i[e[n+2]]+i[e[n+3]]+"-"+i[e[n+4]]+i[e[n+5]]+"-"+i[e[n+6]]+i[e[n+7]]+"-"+i[e[n+8]]+i[e[n+9]]+"-"+i[e[n+10]]+i[e[n+11]]+i[e[n+12]]+i[e[n+13]]+i[e[n+14]]+i[e[n+15]]).toLowerCase();if(!t(f))throw TypeError("Stringified UUID is invalid");return f}}));
				`@ -0,0 +1 @@`
				`!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e\|\|self).uuidValidate=t()}(this,(function(){"use strict";var e=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\|00000000-0000-0000-0000-000000000000)$/i;return function(t){return"string"==typeof t&&e.test(t)}}));`
				`@ -0,0 +1 @@`
				!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?module.exports=o():"function"==typeof define&&define.amd?define(o):(e="undefined"!=typeof globalThis?globalThis:e\|\|self).uuidv1=o()}(this,(function(){"use strict";var e,o=new Uint8Array(16);function t(){if(!e&&!(e="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)\|\|"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return e(o)}var n=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\|00000000-0000-0000-0000-000000000000)$/i;function r(e){return"string"==typeof e&&n.test(e)}for(var i,u,s=[],a=0;a<256;++a)s.push((a+256).toString(16).substr(1));var d=0,f=0;return function(e,o,n){var a=o&&n\|\|0,c=o\|\|new Array(16),l=(e=e\|\|{}).node\|\|i,p=void 0!==e.clockseq?e.clockseq:u;if(null==l\|\|null==p){var v=e.random\|\|(e.rng\|\|t)();null==l&&(l=i=[1\|v[0],v[1],v[2],v[3],v[4],v[5]]),null==p&&(p=u=16383&(v[6]<<8\|v[7]))}var y=void 0!==e.msecs?e.msecs:Date.now(),m=void 0!==e.nsecs?e.nsecs:f+1,g=y-d+(m-f)/1e4;if(g<0&&void 0===e.clockseq&&(p=p+1&16383),(g<0\|\|y>d)&&void 0===e.nsecs&&(m=0),m>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");d=y,f=m,u=p;var h=(1e4(268435455&(y+=122192928e5))+m)%4294967296;c[a++]=h>>>24&255,c[a++]=h>>>16&255,c[a++]=h>>>8&255,c[a++]=255&h;var w=y/42949672961e4&268435455;c[a++]=w>>>8&255,c[a++]=255&w,c[a++]=w>>>24&15\|16,c[a++]=w>>>16&255,c[a++]=p>>>8\|128,c[a++]=255&p;for(var b=0;b<6;++b)c[a+b]=l[b];return o\|\|function(e){var o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,t=(s[e[o+0]]+s[e[o+1]]+s[e[o+2]]+s[e[o+3]]+"-"+s[e[o+4]]+s[e[o+5]]+"-"+s[e[o+6]]+s[e[o+7]]+"-"+s[e[o+8]]+s[e[o+9]]+"-"+s[e[o+10]]+s[e[o+11]]+s[e[o+12]]+s[e[o+13]]+s[e[o+14]]+s[e[o+15]]).toLowerCase();if(!r(t))throw TypeError("Stringified UUID is invalid");return t}(c)}}));