nodestatus-server 1.2.7-beta.4 → 1.2.8-beta

package/build/app.js

@@ -1,31 +1,31 @@
-'use strict';
-
-var require$$1$3 = require('path');
-var require$$0$5 = require('tty');
-var require$$1$2 = require('util');
-var require$$0$6 = require('os');
-var require$$2$3 = require('assert');
-var require$$0$7 = require('buffer');
-var require$$0$8 = require('fs');
-var Stream$7 = require('stream');
-var require$$0$9 = require('events');
-var require$$0$a = require('crypto');
-var require$$2$4 = require('http');
-var require$$0$b = require('url');
-var require$$1$4 = require('net');
-var require$$5$1 = require('querystring');
-var require$$17 = require('async_hooks');
-var require$$0$c = require('constants');
-var zlib$3 = require('zlib');
-var dotenv = require('dotenv');
-var require$$1$5 = require('child_process');
-var require$$4$3 = require('process');
-var require$$1$6 = require('string_decoder');
-var require$$0$d = require('domain');
-var client$1 = require('@prisma/client');
-var require$$2$5 = require('https');
-var require$$4$4 = require('tls');
-var require$$0$e = require('punycode');
+import require$$1$3, { resolve as resolve$3, dirname } from 'path';
+import require$$0$b, { fileURLToPath } from 'url';
+import require$$0$5 from 'tty';
+import require$$1$2 from 'util';
+import require$$0$6, { homedir, platform as platform$1 } from 'os';
+import require$$2$3 from 'assert';
+import require$$0$7 from 'buffer';
+import require$$0$8 from 'fs';
+import Stream$7, { Readable as Readable$1 } from 'stream';
+import require$$0$9 from 'events';
+import require$$0$a, { timingSafeEqual } from 'crypto';
+import require$$2$4, { Server } from 'http';
+import require$$1$4, { isIPv4 } from 'net';
+import require$$5$1 from 'querystring';
+import require$$17 from 'async_hooks';
+import require$$0$c from 'constants';
+import zlib$3 from 'zlib';
+import dotenv from 'dotenv';
+import require$$1$5 from 'child_process';
+import require$$4$3 from 'process';
+import require$$1$6 from 'string_decoder';
+import require$$0$d from 'domain';
+import { PrismaClient } from '@prisma/client';
+import { randomBytes as randomBytes$1 } from 'node:crypto';
+import timers from 'timers/promises';
+import require$$4$4 from 'tls';
+import require$$2$5 from 'https';
+import require$$0$e from 'punycode';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -20608,11 +20608,11 @@ var browser$1 = {
  */
 
 var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
+var m$1 = s * 60;
+var h = m$1 * 60;
+var d$1 = h * 24;
+var w$1 = d$1 * 7;
+var y = d$1 * 365.25;
 
 /**
  * Parse or format the given `val`.
@@ -20673,11 +20673,11 @@ function parse$j(str) {
     case 'weeks':
     case 'week':
     case 'w':
-      return n * w;
+      return n * w$1;
     case 'days':
     case 'day':
     case 'd':
-      return n * d;
+      return n * d$1;
     case 'hours':
     case 'hour':
     case 'hrs':
@@ -20689,7 +20689,7 @@ function parse$j(str) {
     case 'mins':
     case 'min':
     case 'm':
-      return n * m;
+      return n * m$1;
     case 'seconds':
     case 'second':
     case 'secs':
@@ -20717,14 +20717,14 @@ function parse$j(str) {
 
 function fmtShort(ms) {
   var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return Math.round(ms / d) + 'd';
+  if (msAbs >= d$1) {
+    return Math.round(ms / d$1) + 'd';
   }
   if (msAbs >= h) {
     return Math.round(ms / h) + 'h';
   }
-  if (msAbs >= m) {
-    return Math.round(ms / m) + 'm';
+  if (msAbs >= m$1) {
+    return Math.round(ms / m$1) + 'm';
   }
   if (msAbs >= s) {
     return Math.round(ms / s) + 's';
@@ -20742,14 +20742,14 @@ function fmtShort(ms) {
 
 function fmtLong(ms) {
   var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
+  if (msAbs >= d$1) {
+    return plural(ms, msAbs, d$1, 'day');
   }
   if (msAbs >= h) {
     return plural(ms, msAbs, h, 'hour');
   }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
+  if (msAbs >= m$1) {
+    return plural(ms, msAbs, m$1, 'minute');
   }
   if (msAbs >= s) {
     return plural(ms, msAbs, s, 'second');
@@ -23131,7 +23131,7 @@ var url$3 = require$$0$b;
 function historyApiFallback(options) {
     var _this = this;
     options = options || {};
-    var logger = getLogger$1(options);
+    var logger = getLogger$2(options);
     return function (ctx, next) { return __awaiter$2(_this, void 0, void 0, function () {
         var isFlag_1, parsedUrl, rewriteTarget, i, rewrite, match;
         return __generator$1(this, function (_a) {
@@ -23212,7 +23212,7 @@ function acceptsHtml(header, options) {
     }
     return false;
 }
-function getLogger$1(options) {
+function getLogger$2(options) {
     if (options && options.logger) {
         return options.logger;
     }
@@ -24289,7 +24289,7 @@ var appenders$2 = {
   set exports(v){ appendersExports = v; },
 };
 
-var cjs$1 = {};
+var cjs = {};
 
 /*! (c) 2020 Andrea Giammarchi */
 
@@ -24352,7 +24352,7 @@ const parse$h = (text, reviver) => {
               value;
   return $.call({'': tmp}, '', tmp);
 };
-cjs$1.parse = parse$h;
+cjs.parse = parse$h;
 
 const stringify$8 = (value, replacer, space) => {
   const $ = replacer && typeof replacer === object ?
@@ -24383,14 +24383,14 @@ const stringify$8 = (value, replacer, space) => {
     return after;
   }
 };
-cjs$1.stringify = stringify$8;
+cjs.stringify = stringify$8;
 
 const toJSON = any => $parse(stringify$8(any));
-cjs$1.toJSON = toJSON;
+cjs.toJSON = toJSON;
 const fromJSON = any => parse$h($stringify(any));
-cjs$1.fromJSON = fromJSON;
+cjs.fromJSON = fromJSON;
 
-const flatted = cjs$1;
+const flatted = cjs;
 const levels$4 = levels$5;
 
 /**
@@ -24839,7 +24839,7 @@ if (typeof process.chdir === 'function') {
   if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
 }
 
-var polyfills$1 = patch$3;
+var polyfills$2 = patch$3;
 
 function patch$3 (fs) {
   // (re-)implement some things that are known busted or missing.
@@ -25162,7 +25162,7 @@ function patch$3 (fs) {
 
 var Stream$4 = Stream$7.Stream;
 
-var legacyStreams = legacy$1;
+var legacyStreams$1 = legacy$1;
 
 function legacy$1 (fs) {
   return {
@@ -25279,7 +25279,7 @@ function legacy$1 (fs) {
   }
 }
 
-var clone_1 = clone$2;
+var clone_1$1 = clone$2;
 
 var getPrototypeOf = Object.getPrototypeOf || function (obj) {
   return obj.__proto__
@@ -25302,9 +25302,9 @@ function clone$2 (obj) {
 }
 
 var fs$o = require$$0$8;
-var polyfills = polyfills$1;
-var legacy = legacyStreams;
-var clone$1 = clone_1;
+var polyfills$1 = polyfills$2;
+var legacy = legacyStreams$1;
+var clone$1 = clone_1$1;
 
 var util$8 = require$$1$2;
 
@@ -25396,15 +25396,15 @@ if (!commonjsGlobal[gracefulQueue]) {
   publishQueue(commonjsGlobal, fs$o[gracefulQueue]);
 }
 
-var gracefulFs = patch$2(clone$1(fs$o));
+var gracefulFs$1 = patch$2(clone$1(fs$o));
 if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$o.__patched) {
-    gracefulFs = patch$2(fs$o);
+    gracefulFs$1 = patch$2(fs$o);
     fs$o.__patched = true;
 }
 
 function patch$2 (fs) {
   // Everything that references the open() function needs to be in here
-  polyfills(fs);
+  polyfills$1(fs);
   fs.gracefulify = patch$2;
 
   fs.createReadStream = createReadStream;
@@ -25735,7 +25735,7 @@ function retry () {
 	// This is adapted from https://github.com/normalize/mz
 	// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
 	const u = universalify$1.fromCallback;
-	const fs = gracefulFs;
+	const fs = gracefulFs$1;
 
 	const api = [
 	  'access',
@@ -25934,7 +25934,7 @@ var pathExists_1 = {
   pathExistsSync: fs$m.existsSync
 };
 
-const fs$l = gracefulFs;
+const fs$l = gracefulFs$1;
 
 function utimesMillis$1 (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
@@ -26112,7 +26112,7 @@ var stat$4 = {
   areIdentical: areIdentical$2
 };
 
-const fs$j = gracefulFs;
+const fs$j = gracefulFs$1;
 const path$i = require$$1$3;
 const mkdirs$1 = mkdirs$2.mkdirs;
 const pathExists$5 = pathExists_1.pathExists;
@@ -26346,7 +26346,7 @@ function copyLink$1 (resolvedSrc, dest, cb) {
 
 var copy_1 = copy$2;
 
-const fs$i = gracefulFs;
+const fs$i = gracefulFs$1;
 const path$h = require$$1$3;
 const mkdirsSync$1 = mkdirs$2.mkdirsSync;
 const utimesMillisSync = utimes.utimesMillisSync;
@@ -26520,7 +26520,7 @@ var copy$1 = {
   copySync: copySync_1
 };
 
-const fs$h = gracefulFs;
+const fs$h = gracefulFs$1;
 const path$g = require$$1$3;
 const assert = require$$2$3;
 
@@ -26821,7 +26821,7 @@ function rmkidsSync (p, options) {
 var rimraf_1 = rimraf$1;
 rimraf$1.sync = rimrafSync;
 
-const fs$g = gracefulFs;
+const fs$g = gracefulFs$1;
 const u$7 = universalify$1.fromCallback;
 const rimraf = rimraf_1;
 
@@ -26882,7 +26882,7 @@ var empty = {
 
 const u$5 = universalify$1.fromCallback;
 const path$e = require$$1$3;
-const fs$e = gracefulFs;
+const fs$e = gracefulFs$1;
 const mkdir$2 = mkdirs$2;
 
 function createFile$1 (file, callback) {
@@ -26950,7 +26950,7 @@ var file = {
 
 const u$4 = universalify$1.fromCallback;
 const path$d = require$$1$3;
-const fs$d = gracefulFs;
+const fs$d = gracefulFs$1;
 const mkdir$1 = mkdirs$2;
 const pathExists$4 = pathExists_1.pathExists;
 const { areIdentical: areIdentical$1 } = stat$4;
@@ -27012,7 +27012,7 @@ var link = {
 };
 
 const path$c = require$$1$3;
-const fs$c = gracefulFs;
+const fs$c = gracefulFs$1;
 const pathExists$3 = pathExists_1.pathExists;
 
 /**
@@ -27109,7 +27109,7 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$b = gracefulFs;
+const fs$b = gracefulFs$1;
 
 function symlinkType$1 (srcpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback;
@@ -27242,6 +27242,985 @@ var ensure = {
   ensureSymlinkSync: createSymlinkSync
 };
 
+var polyfills;
+var hasRequiredPolyfills;
+
+function requirePolyfills () {
+	if (hasRequiredPolyfills) return polyfills;
+	hasRequiredPolyfills = 1;
+	var constants = require$$0$c;
+
+	var origCwd = process.cwd;
+	var cwd = null;
+
+	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+
+	process.cwd = function() {
+	  if (!cwd)
+	    cwd = origCwd.call(process);
+	  return cwd
+	};
+	try {
+	  process.cwd();
+	} catch (er) {}
+
+	// This check is needed until node.js 12 is required
+	if (typeof process.chdir === 'function') {
+	  var chdir = process.chdir;
+	  process.chdir = function (d) {
+	    cwd = null;
+	    chdir.call(process, d);
+	  };
+	  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+
+	polyfills = patch;
+
+	function patch (fs) {
+	  // (re-)implement some things that are known busted or missing.
+
+	  // lchmod, broken prior to 0.6.2
+	  // back-port the fix here.
+	  if (constants.hasOwnProperty('O_SYMLINK') &&
+	      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+	    patchLchmod(fs);
+	  }
+
+	  // lutimes implementation, or no-op
+	  if (!fs.lutimes) {
+	    patchLutimes(fs);
+	  }
+
+	  // https://github.com/isaacs/node-graceful-fs/issues/4
+	  // Chown should not fail on einval or eperm if non-root.
+	  // It should not fail on enosys ever, as this just indicates
+	  // that a fs doesn't support the intended operation.
+
+	  fs.chown = chownFix(fs.chown);
+	  fs.fchown = chownFix(fs.fchown);
+	  fs.lchown = chownFix(fs.lchown);
+
+	  fs.chmod = chmodFix(fs.chmod);
+	  fs.fchmod = chmodFix(fs.fchmod);
+	  fs.lchmod = chmodFix(fs.lchmod);
+
+	  fs.chownSync = chownFixSync(fs.chownSync);
+	  fs.fchownSync = chownFixSync(fs.fchownSync);
+	  fs.lchownSync = chownFixSync(fs.lchownSync);
+
+	  fs.chmodSync = chmodFixSync(fs.chmodSync);
+	  fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+	  fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+
+	  fs.stat = statFix(fs.stat);
+	  fs.fstat = statFix(fs.fstat);
+	  fs.lstat = statFix(fs.lstat);
+
+	  fs.statSync = statFixSync(fs.statSync);
+	  fs.fstatSync = statFixSync(fs.fstatSync);
+	  fs.lstatSync = statFixSync(fs.lstatSync);
+
+	  // if lchmod/lchown do not exist, then make them no-ops
+	  if (fs.chmod && !fs.lchmod) {
+	    fs.lchmod = function (path, mode, cb) {
+	      if (cb) process.nextTick(cb);
+	    };
+	    fs.lchmodSync = function () {};
+	  }
+	  if (fs.chown && !fs.lchown) {
+	    fs.lchown = function (path, uid, gid, cb) {
+	      if (cb) process.nextTick(cb);
+	    };
+	    fs.lchownSync = function () {};
+	  }
+
+	  // on Windows, A/V software can lock the directory, causing this
+	  // to fail with an EACCES or EPERM if the directory contains newly
+	  // created files.  Try again on failure, for up to 60 seconds.
+
+	  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+	  // bit9, may lock files for up to a minute, causing npm package install
+	  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+	  // CPU to a busy looping process, which can cause the program causing the lock
+	  // contention to be starved of CPU by node, so the contention doesn't resolve.
+	  if (platform === "win32") {
+	    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+	    : (function (fs$rename) {
+	      function rename (from, to, cb) {
+	        var start = Date.now();
+	        var backoff = 0;
+	        fs$rename(from, to, function CB (er) {
+	          if (er
+	              && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY")
+	              && Date.now() - start < 60000) {
+	            setTimeout(function() {
+	              fs.stat(to, function (stater, st) {
+	                if (stater && stater.code === "ENOENT")
+	                  fs$rename(from, to, CB);
+	                else
+	                  cb(er);
+	              });
+	            }, backoff);
+	            if (backoff < 100)
+	              backoff += 10;
+	            return;
+	          }
+	          if (cb) cb(er);
+	        });
+	      }
+	      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+	      return rename
+	    })(fs.rename);
+	  }
+
+	  // if read() returns EAGAIN, then just try it again.
+	  fs.read = typeof fs.read !== 'function' ? fs.read
+	  : (function (fs$read) {
+	    function read (fd, buffer, offset, length, position, callback_) {
+	      var callback;
+	      if (callback_ && typeof callback_ === 'function') {
+	        var eagCounter = 0;
+	        callback = function (er, _, __) {
+	          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+	            eagCounter ++;
+	            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+	          }
+	          callback_.apply(this, arguments);
+	        };
+	      }
+	      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+	    }
+
+	    // This ensures `util.promisify` works as it does for native `fs.read`.
+	    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+	    return read
+	  })(fs.read);
+
+	  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+	  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+	    var eagCounter = 0;
+	    while (true) {
+	      try {
+	        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+	      } catch (er) {
+	        if (er.code === 'EAGAIN' && eagCounter < 10) {
+	          eagCounter ++;
+	          continue
+	        }
+	        throw er
+	      }
+	    }
+	  }})(fs.readSync);
+
+	  function patchLchmod (fs) {
+	    fs.lchmod = function (path, mode, callback) {
+	      fs.open( path
+	             , constants.O_WRONLY | constants.O_SYMLINK
+	             , mode
+	             , function (err, fd) {
+	        if (err) {
+	          if (callback) callback(err);
+	          return
+	        }
+	        // prefer to return the chmod error, if one occurs,
+	        // but still try to close, and report closing errors if they occur.
+	        fs.fchmod(fd, mode, function (err) {
+	          fs.close(fd, function(err2) {
+	            if (callback) callback(err || err2);
+	          });
+	        });
+	      });
+	    };
+
+	    fs.lchmodSync = function (path, mode) {
+	      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+
+	      // prefer to return the chmod error, if one occurs,
+	      // but still try to close, and report closing errors if they occur.
+	      var threw = true;
+	      var ret;
+	      try {
+	        ret = fs.fchmodSync(fd, mode);
+	        threw = false;
+	      } finally {
+	        if (threw) {
+	          try {
+	            fs.closeSync(fd);
+	          } catch (er) {}
+	        } else {
+	          fs.closeSync(fd);
+	        }
+	      }
+	      return ret
+	    };
+	  }
+
+	  function patchLutimes (fs) {
+	    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+	      fs.lutimes = function (path, at, mt, cb) {
+	        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+	          if (er) {
+	            if (cb) cb(er);
+	            return
+	          }
+	          fs.futimes(fd, at, mt, function (er) {
+	            fs.close(fd, function (er2) {
+	              if (cb) cb(er || er2);
+	            });
+	          });
+	        });
+	      };
+
+	      fs.lutimesSync = function (path, at, mt) {
+	        var fd = fs.openSync(path, constants.O_SYMLINK);
+	        var ret;
+	        var threw = true;
+	        try {
+	          ret = fs.futimesSync(fd, at, mt);
+	          threw = false;
+	        } finally {
+	          if (threw) {
+	            try {
+	              fs.closeSync(fd);
+	            } catch (er) {}
+	          } else {
+	            fs.closeSync(fd);
+	          }
+	        }
+	        return ret
+	      };
+
+	    } else if (fs.futimes) {
+	      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
+	      fs.lutimesSync = function () {};
+	    }
+	  }
+
+	  function chmodFix (orig) {
+	    if (!orig) return orig
+	    return function (target, mode, cb) {
+	      return orig.call(fs, target, mode, function (er) {
+	        if (chownErOk(er)) er = null;
+	        if (cb) cb.apply(this, arguments);
+	      })
+	    }
+	  }
+
+	  function chmodFixSync (orig) {
+	    if (!orig) return orig
+	    return function (target, mode) {
+	      try {
+	        return orig.call(fs, target, mode)
+	      } catch (er) {
+	        if (!chownErOk(er)) throw er
+	      }
+	    }
+	  }
+
+
+	  function chownFix (orig) {
+	    if (!orig) return orig
+	    return function (target, uid, gid, cb) {
+	      return orig.call(fs, target, uid, gid, function (er) {
+	        if (chownErOk(er)) er = null;
+	        if (cb) cb.apply(this, arguments);
+	      })
+	    }
+	  }
+
+	  function chownFixSync (orig) {
+	    if (!orig) return orig
+	    return function (target, uid, gid) {
+	      try {
+	        return orig.call(fs, target, uid, gid)
+	      } catch (er) {
+	        if (!chownErOk(er)) throw er
+	      }
+	    }
+	  }
+
+	  function statFix (orig) {
+	    if (!orig) return orig
+	    // Older versions of Node erroneously returned signed integers for
+	    // uid + gid.
+	    return function (target, options, cb) {
+	      if (typeof options === 'function') {
+	        cb = options;
+	        options = null;
+	      }
+	      function callback (er, stats) {
+	        if (stats) {
+	          if (stats.uid < 0) stats.uid += 0x100000000;
+	          if (stats.gid < 0) stats.gid += 0x100000000;
+	        }
+	        if (cb) cb.apply(this, arguments);
+	      }
+	      return options ? orig.call(fs, target, options, callback)
+	        : orig.call(fs, target, callback)
+	    }
+	  }
+
+	  function statFixSync (orig) {
+	    if (!orig) return orig
+	    // Older versions of Node erroneously returned signed integers for
+	    // uid + gid.
+	    return function (target, options) {
+	      var stats = options ? orig.call(fs, target, options)
+	        : orig.call(fs, target);
+	      if (stats) {
+	        if (stats.uid < 0) stats.uid += 0x100000000;
+	        if (stats.gid < 0) stats.gid += 0x100000000;
+	      }
+	      return stats;
+	    }
+	  }
+
+	  // ENOSYS means that the fs doesn't support the op. Just ignore
+	  // that, because it doesn't matter.
+	  //
+	  // if there's no getuid, or if getuid() is something other
+	  // than 0, and the error is EINVAL or EPERM, then just ignore
+	  // it.
+	  //
+	  // This specific case is a silent failure in cp, install, tar,
+	  // and most other unix tools that manage permissions.
+	  //
+	  // When running as root, or if other types of errors are
+	  // encountered, then it's strict.
+	  function chownErOk (er) {
+	    if (!er)
+	      return true
+
+	    if (er.code === "ENOSYS")
+	      return true
+
+	    var nonroot = !process.getuid || process.getuid() !== 0;
+	    if (nonroot) {
+	      if (er.code === "EINVAL" || er.code === "EPERM")
+	        return true
+	    }
+
+	    return false
+	  }
+	}
+	return polyfills;
+}
+
+var legacyStreams;
+var hasRequiredLegacyStreams;
+
+function requireLegacyStreams () {
+	if (hasRequiredLegacyStreams) return legacyStreams;
+	hasRequiredLegacyStreams = 1;
+	var Stream = Stream$7.Stream;
+
+	legacyStreams = legacy;
+
+	function legacy (fs) {
+	  return {
+	    ReadStream: ReadStream,
+	    WriteStream: WriteStream
+	  }
+
+	  function ReadStream (path, options) {
+	    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
+	    Stream.call(this);
+
+	    var self = this;
+
+	    this.path = path;
+	    this.fd = null;
+	    this.readable = true;
+	    this.paused = false;
+
+	    this.flags = 'r';
+	    this.mode = 438; /*=0666*/
+	    this.bufferSize = 64 * 1024;
+
+	    options = options || {};
+
+	    // Mixin options into this
+	    var keys = Object.keys(options);
+	    for (var index = 0, length = keys.length; index < length; index++) {
+	      var key = keys[index];
+	      this[key] = options[key];
+	    }
+
+	    if (this.encoding) this.setEncoding(this.encoding);
+
+	    if (this.start !== undefined) {
+	      if ('number' !== typeof this.start) {
+	        throw TypeError('start must be a Number');
+	      }
+	      if (this.end === undefined) {
+	        this.end = Infinity;
+	      } else if ('number' !== typeof this.end) {
+	        throw TypeError('end must be a Number');
+	      }
+
+	      if (this.start > this.end) {
+	        throw new Error('start must be <= end');
+	      }
+
+	      this.pos = this.start;
+	    }
+
+	    if (this.fd !== null) {
+	      process.nextTick(function() {
+	        self._read();
+	      });
+	      return;
+	    }
+
+	    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+	      if (err) {
+	        self.emit('error', err);
+	        self.readable = false;
+	        return;
+	      }
+
+	      self.fd = fd;
+	      self.emit('open', fd);
+	      self._read();
+	    });
+	  }
+
+	  function WriteStream (path, options) {
+	    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
+	    Stream.call(this);
+
+	    this.path = path;
+	    this.fd = null;
+	    this.writable = true;
+
+	    this.flags = 'w';
+	    this.encoding = 'binary';
+	    this.mode = 438; /*=0666*/
+	    this.bytesWritten = 0;
+
+	    options = options || {};
+
+	    // Mixin options into this
+	    var keys = Object.keys(options);
+	    for (var index = 0, length = keys.length; index < length; index++) {
+	      var key = keys[index];
+	      this[key] = options[key];
+	    }
+
+	    if (this.start !== undefined) {
+	      if ('number' !== typeof this.start) {
+	        throw TypeError('start must be a Number');
+	      }
+	      if (this.start < 0) {
+	        throw new Error('start must be >= zero');
+	      }
+
+	      this.pos = this.start;
+	    }
+
+	    this.busy = false;
+	    this._queue = [];
+
+	    if (this.fd === null) {
+	      this._open = fs.open;
+	      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+	      this.flush();
+	    }
+	  }
+	}
+	return legacyStreams;
+}
+
+var clone_1;
+var hasRequiredClone;
+
+function requireClone () {
+	if (hasRequiredClone) return clone_1;
+	hasRequiredClone = 1;
+
+	clone_1 = clone;
+
+	var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+	  return obj.__proto__
+	};
+
+	function clone (obj) {
+	  if (obj === null || typeof obj !== 'object')
+	    return obj
+
+	  if (obj instanceof Object)
+	    var copy = { __proto__: getPrototypeOf(obj) };
+	  else
+	    var copy = Object.create(null);
+
+	  Object.getOwnPropertyNames(obj).forEach(function (key) {
+	    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+	  });
+
+	  return copy
+	}
+	return clone_1;
+}
+
+var gracefulFs;
+var hasRequiredGracefulFs;
+
+function requireGracefulFs () {
+	if (hasRequiredGracefulFs) return gracefulFs;
+	hasRequiredGracefulFs = 1;
+	var fs = require$$0$8;
+	var polyfills = requirePolyfills();
+	var legacy = requireLegacyStreams();
+	var clone = requireClone();
+
+	var util = require$$1$2;
+
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+	  gracefulQueue = Symbol.for('graceful-fs.queue');
+	  // This is used in testing by future versions
+	  previousSymbol = Symbol.for('graceful-fs.previous');
+	} else {
+	  gracefulQueue = '___graceful-fs.queue';
+	  previousSymbol = '___graceful-fs.previous';
+	}
+
+	function noop () {}
+
+	function publishQueue(context, queue) {
+	  Object.defineProperty(context, gracefulQueue, {
+	    get: function() {
+	      return queue
+	    }
+	  });
+	}
+
+	var debug = noop;
+	if (util.debuglog)
+	  debug = util.debuglog('gfs4');
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+	  debug = function() {
+	    var m = util.format.apply(util, arguments);
+	    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
+	    console.error(m);
+	  };
+
+	// Once time initialization
+	if (!fs[gracefulQueue]) {
+	  // This queue can be shared by multiple loaded instances
+	  var queue = commonjsGlobal[gracefulQueue] || [];
+	  publishQueue(fs, queue);
+
+	  // Patch fs.close/closeSync to shared queue version, because we need
+	  // to retry() whenever a close happens *anywhere* in the program.
+	  // This is essential when multiple graceful-fs instances are
+	  // in play at the same time.
+	  fs.close = (function (fs$close) {
+	    function close (fd, cb) {
+	      return fs$close.call(fs, fd, function (err) {
+	        // This function uses the graceful-fs shared queue
+	        if (!err) {
+	          resetQueue();
+	        }
+
+	        if (typeof cb === 'function')
+	          cb.apply(this, arguments);
+	      })
+	    }
+
+	    Object.defineProperty(close, previousSymbol, {
+	      value: fs$close
+	    });
+	    return close
+	  })(fs.close);
+
+	  fs.closeSync = (function (fs$closeSync) {
+	    function closeSync (fd) {
+	      // This function uses the graceful-fs shared queue
+	      fs$closeSync.apply(fs, arguments);
+	      resetQueue();
+	    }
+
+	    Object.defineProperty(closeSync, previousSymbol, {
+	      value: fs$closeSync
+	    });
+	    return closeSync
+	  })(fs.closeSync);
+
+	  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+	    process.on('exit', function() {
+	      debug(fs[gracefulQueue]);
+	      require$$2$3.equal(fs[gracefulQueue].length, 0);
+	    });
+	  }
+	}
+
+	if (!commonjsGlobal[gracefulQueue]) {
+	  publishQueue(commonjsGlobal, fs[gracefulQueue]);
+	}
+
+	gracefulFs = patch(clone(fs));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+	    gracefulFs = patch(fs);
+	    fs.__patched = true;
+	}
+
+	function patch (fs) {
+	  // Everything that references the open() function needs to be in here
+	  polyfills(fs);
+	  fs.gracefulify = patch;
+
+	  fs.createReadStream = createReadStream;
+	  fs.createWriteStream = createWriteStream;
+	  var fs$readFile = fs.readFile;
+	  fs.readFile = readFile;
+	  function readFile (path, options, cb) {
+	    if (typeof options === 'function')
+	      cb = options, options = null;
+
+	    return go$readFile(path, options, cb)
+
+	    function go$readFile (path, options, cb, startTime) {
+	      return fs$readFile(path, options, function (err) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);
+	        else {
+	          if (typeof cb === 'function')
+	            cb.apply(this, arguments);
+	        }
+	      })
+	    }
+	  }
+
+	  var fs$writeFile = fs.writeFile;
+	  fs.writeFile = writeFile;
+	  function writeFile (path, data, options, cb) {
+	    if (typeof options === 'function')
+	      cb = options, options = null;
+
+	    return go$writeFile(path, data, options, cb)
+
+	    function go$writeFile (path, data, options, cb, startTime) {
+	      return fs$writeFile(path, data, options, function (err) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+	        else {
+	          if (typeof cb === 'function')
+	            cb.apply(this, arguments);
+	        }
+	      })
+	    }
+	  }
+
+	  var fs$appendFile = fs.appendFile;
+	  if (fs$appendFile)
+	    fs.appendFile = appendFile;
+	  function appendFile (path, data, options, cb) {
+	    if (typeof options === 'function')
+	      cb = options, options = null;
+
+	    return go$appendFile(path, data, options, cb)
+
+	    function go$appendFile (path, data, options, cb, startTime) {
+	      return fs$appendFile(path, data, options, function (err) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+	        else {
+	          if (typeof cb === 'function')
+	            cb.apply(this, arguments);
+	        }
+	      })
+	    }
+	  }
+
+	  var fs$copyFile = fs.copyFile;
+	  if (fs$copyFile)
+	    fs.copyFile = copyFile;
+	  function copyFile (src, dest, flags, cb) {
+	    if (typeof flags === 'function') {
+	      cb = flags;
+	      flags = 0;
+	    }
+	    return go$copyFile(src, dest, flags, cb)
+
+	    function go$copyFile (src, dest, flags, cb, startTime) {
+	      return fs$copyFile(src, dest, flags, function (err) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);
+	        else {
+	          if (typeof cb === 'function')
+	            cb.apply(this, arguments);
+	        }
+	      })
+	    }
+	  }
+
+	  var fs$readdir = fs.readdir;
+	  fs.readdir = readdir;
+	  var noReaddirOptionVersions = /^v[0-5]\./;
+	  function readdir (path, options, cb) {
+	    if (typeof options === 'function')
+	      cb = options, options = null;
+
+	    var go$readdir = noReaddirOptionVersions.test(process.version)
+	      ? function go$readdir (path, options, cb, startTime) {
+	        return fs$readdir(path, fs$readdirCallback(
+	          path, options, cb, startTime
+	        ))
+	      }
+	      : function go$readdir (path, options, cb, startTime) {
+	        return fs$readdir(path, options, fs$readdirCallback(
+	          path, options, cb, startTime
+	        ))
+	      };
+
+	    return go$readdir(path, options, cb)
+
+	    function fs$readdirCallback (path, options, cb, startTime) {
+	      return function (err, files) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([
+	            go$readdir,
+	            [path, options, cb],
+	            err,
+	            startTime || Date.now(),
+	            Date.now()
+	          ]);
+	        else {
+	          if (files && files.sort)
+	            files.sort();
+
+	          if (typeof cb === 'function')
+	            cb.call(this, err, files);
+	        }
+	      }
+	    }
+	  }
+
+	  if (process.version.substr(0, 4) === 'v0.8') {
+	    var legStreams = legacy(fs);
+	    ReadStream = legStreams.ReadStream;
+	    WriteStream = legStreams.WriteStream;
+	  }
+
+	  var fs$ReadStream = fs.ReadStream;
+	  if (fs$ReadStream) {
+	    ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+	    ReadStream.prototype.open = ReadStream$open;
+	  }
+
+	  var fs$WriteStream = fs.WriteStream;
+	  if (fs$WriteStream) {
+	    WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+	    WriteStream.prototype.open = WriteStream$open;
+	  }
+
+	  Object.defineProperty(fs, 'ReadStream', {
+	    get: function () {
+	      return ReadStream
+	    },
+	    set: function (val) {
+	      ReadStream = val;
+	    },
+	    enumerable: true,
+	    configurable: true
+	  });
+	  Object.defineProperty(fs, 'WriteStream', {
+	    get: function () {
+	      return WriteStream
+	    },
+	    set: function (val) {
+	      WriteStream = val;
+	    },
+	    enumerable: true,
+	    configurable: true
+	  });
+
+	  // legacy names
+	  var FileReadStream = ReadStream;
+	  Object.defineProperty(fs, 'FileReadStream', {
+	    get: function () {
+	      return FileReadStream
+	    },
+	    set: function (val) {
+	      FileReadStream = val;
+	    },
+	    enumerable: true,
+	    configurable: true
+	  });
+	  var FileWriteStream = WriteStream;
+	  Object.defineProperty(fs, 'FileWriteStream', {
+	    get: function () {
+	      return FileWriteStream
+	    },
+	    set: function (val) {
+	      FileWriteStream = val;
+	    },
+	    enumerable: true,
+	    configurable: true
+	  });
+
+	  function ReadStream (path, options) {
+	    if (this instanceof ReadStream)
+	      return fs$ReadStream.apply(this, arguments), this
+	    else
+	      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+	  }
+
+	  function ReadStream$open () {
+	    var that = this;
+	    open(that.path, that.flags, that.mode, function (err, fd) {
+	      if (err) {
+	        if (that.autoClose)
+	          that.destroy();
+
+	        that.emit('error', err);
+	      } else {
+	        that.fd = fd;
+	        that.emit('open', fd);
+	        that.read();
+	      }
+	    });
+	  }
+
+	  function WriteStream (path, options) {
+	    if (this instanceof WriteStream)
+	      return fs$WriteStream.apply(this, arguments), this
+	    else
+	      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+	  }
+
+	  function WriteStream$open () {
+	    var that = this;
+	    open(that.path, that.flags, that.mode, function (err, fd) {
+	      if (err) {
+	        that.destroy();
+	        that.emit('error', err);
+	      } else {
+	        that.fd = fd;
+	        that.emit('open', fd);
+	      }
+	    });
+	  }
+
+	  function createReadStream (path, options) {
+	    return new fs.ReadStream(path, options)
+	  }
+
+	  function createWriteStream (path, options) {
+	    return new fs.WriteStream(path, options)
+	  }
+
+	  var fs$open = fs.open;
+	  fs.open = open;
+	  function open (path, flags, mode, cb) {
+	    if (typeof mode === 'function')
+	      cb = mode, mode = null;
+
+	    return go$open(path, flags, mode, cb)
+
+	    function go$open (path, flags, mode, cb, startTime) {
+	      return fs$open(path, flags, mode, function (err, fd) {
+	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+	          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);
+	        else {
+	          if (typeof cb === 'function')
+	            cb.apply(this, arguments);
+	        }
+	      })
+	    }
+	  }
+
+	  return fs
+	}
+
+	function enqueue (elem) {
+	  debug('ENQUEUE', elem[0].name, elem[1]);
+	  fs[gracefulQueue].push(elem);
+	  retry();
+	}
+
+	// keep track of the timeout between retry() calls
+	var retryTimer;
+
+	// reset the startTime and lastTime to now
+	// this resets the start of the 60 second overall timeout as well as the
+	// delay between attempts so that we'll retry these jobs sooner
+	function resetQueue () {
+	  var now = Date.now();
+	  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+	    // entries that are only a length of 2 are from an older version, don't
+	    // bother modifying those since they'll be retried anyway.
+	    if (fs[gracefulQueue][i].length > 2) {
+	      fs[gracefulQueue][i][3] = now; // startTime
+	      fs[gracefulQueue][i][4] = now; // lastTime
+	    }
+	  }
+	  // call retry to make sure we're actively processing the queue
+	  retry();
+	}
+
+	function retry () {
+	  // clear the timer and remove it to help prevent unintended concurrency
+	  clearTimeout(retryTimer);
+	  retryTimer = undefined;
+
+	  if (fs[gracefulQueue].length === 0)
+	    return
+
+	  var elem = fs[gracefulQueue].shift();
+	  var fn = elem[0];
+	  var args = elem[1];
+	  // these items may be unset if they were added by an older graceful-fs
+	  var err = elem[2];
+	  var startTime = elem[3];
+	  var lastTime = elem[4];
+
+	  // if we don't have a startTime we have no way of knowing if we've waited
+	  // long enough, so go ahead and retry this item now
+	  if (startTime === undefined) {
+	    debug('RETRY', fn.name, args);
+	    fn.apply(null, args);
+	  } else if (Date.now() - startTime >= 60000) {
+	    // it's been more than 60 seconds total, bail now
+	    debug('TIMEOUT', fn.name, args);
+	    var cb = args.pop();
+	    if (typeof cb === 'function')
+	      cb.call(null, err);
+	  } else {
+	    // the amount of time between the last attempt and right now
+	    var sinceAttempt = Date.now() - lastTime;
+	    // the amount of time between when we first tried, and when we last tried
+	    // rounded up to at least 1
+	    var sinceStart = Math.max(lastTime - startTime, 1);
+	    // backoff. wait longer than the total time we've been retrying, but only
+	    // up to a maximum of 100ms
+	    var desiredDelay = Math.min(sinceStart * 1.2, 100);
+	    // it's been long enough since the last retry, do it again
+	    if (sinceAttempt >= desiredDelay) {
+	      debug('RETRY', fn.name, args);
+	      fn.apply(null, args.concat([startTime]));
+	    } else {
+	      // if we can't do this job yet, push it to the end of the queue
+	      // and let the next iteration check again
+	      fs[gracefulQueue].push(elem);
+	    }
+	  }
+
+	  // schedule our next run if one isn't already scheduled
+	  if (retryTimer === undefined) {
+	    retryTimer = setTimeout(retry, 0);
+	  }
+	}
+	return gracefulFs;
+}
+
 function stringify$7 (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
   const EOF = finalEOL ? EOL : '';
   const str = JSON.stringify(obj, replacer, spaces);
@@ -27259,7 +28238,7 @@ var utils$b = { stringify: stringify$7, stripBom: stripBom$1 };
 
 let _fs;
 try {
-  _fs = gracefulFs;
+  _fs = requireGracefulFs();
 } catch (_) {
   _fs = require$$0$8;
 }
@@ -27357,7 +28336,7 @@ var jsonfile = {
 };
 
 const u$2 = universalify$1.fromCallback;
-const fs$9 = gracefulFs;
+const fs$9 = gracefulFs$1;
 const path$a = require$$1$3;
 const mkdir = mkdirs$2;
 const pathExists$1 = pathExists_1.pathExists;
@@ -27432,7 +28411,7 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json$3 = jsonFile;
 
-const fs$8 = gracefulFs;
+const fs$8 = gracefulFs$1;
 const path$9 = require$$1$3;
 const copy = copy$1.copy;
 const remove = remove_1.remove;
@@ -27506,7 +28485,7 @@ function moveAcrossDevice$1 (src, dest, overwrite, cb) {
 
 var move_1 = move$1;
 
-const fs$7 = gracefulFs;
+const fs$7 = gracefulFs$1;
 const path$8 = require$$1$3;
 const copySync = copy$1.copySync;
 const removeSync = remove_1.removeSync;
@@ -29778,7 +30757,7 @@ function shutdown(cb) {
  * @param loggerCategoryName
  * @return {Logger} instance of logger for the category
  */
-function getLogger(category) {
+function getLogger$1(category) {
   if (!enabled) {
     configure(
       process.env.LOG4JS_CONFIG || {
@@ -29798,7 +30777,7 @@ function getLogger(category) {
  * @property shutdown
  */
 const log4js = {
-  getLogger,
+  getLogger: getLogger$1,
   configure,
   shutdown,
   connectLogger,
@@ -33177,17 +34156,17 @@ const {
 } = extraTypingsCommander;
 
 if (process.env.NODE_ENV !== "TEST") {
-  dotenv.config({ path: require$$1$3.resolve(require$$0$6.homedir(), ".nodestatus/.env.local") });
+  dotenv.config({ path: resolve$3(homedir(), ".nodestatus/.env.local") });
 } else {
-  process.env.DATABASE = process.env.DATABASE ? process.env.DATABASE : require$$1$3.resolve(__dirname, "../../db.test.sqlite");
+  process.env.DATABASE = process.env.DATABASE ? process.env.DATABASE : resolve$3(__dirname, "../../db.test.sqlite");
 }
-const program = new Command("NodeStatus").addOption(createOption("-p, --port <port>", "Web server listening port").env("PORT").default(35601).argParser((value) => parseInt(value, 10))).addOption(createOption("-i, --interval <interval>", "Update interval").env("INTERVAL").default(1500).argParser((value) => parseInt(value, 10))).addOption(createOption("-v, --verbose", "Verbose mode").env("VERBOSE").default(false)).addOption(createOption("-pi, --ping-interval <pingInterval>", "Ping interval").env("PING_INTERVAL").default(30).argParser((value) => parseInt(value, 10))).addOption(createOption("-ipc, --use-ipc", "Use IPC").env("USE_IPC").default(true)).addOption(createOption("-web, --use-web", "Use Web").env("USE_WEB").default(true)).addOption(createOption("-push, --use-push", "Use Push").env("USE_PUSH").default(true)).addOption(createOption("-wt, --web-theme <webTheme>", "Web theme").env("WEB_THEME").env("THEME").default("hotaru-theme")).addOption(createOption("-wmt, --web-title <webTitle>", "Web title").env("WEB_TITLE").default("Server Status")).addOption(createOption("-wst, --web-subtitle <webSubtitle>", "Web subtitle").env("WEB_SUBTITLE").default("Servers' Probes Set up with NodeStatus")).addOption(createOption("-wht, --web-headtitle <webHeadtitle>", "Web head title").env("WEB_HEADTITLE").default("NodeStatus")).addOption(createOption("-wu, --web-username <webUsername>", "Web username").env("WEB_USERNAME").default("admin")).addOption(createOption("-wp, --web-password <webPassword>", "Web password").env("WEB_PASSWORD").default("")).addOption(createOption("-ws, --web-secret <webSecret>", "Web jwt secret").env("WEB_SECRET").default("node-secret")).addOption(
+const program = new Command("NodeStatus").addOption(createOption("-p, --port <port>", "Web server listening port").env("PORT").default(35601).argParser((value) => parseInt(value, 10))).addOption(createOption("-i, --interval <interval>", "Update interval").env("INTERVAL").default(1500).argParser((value) => parseInt(value, 10))).addOption(createOption("-v, --verbose", "Verbose mode").env("VERBOSE").default(false)).addOption(createOption("-pi, --ping-interval <pingInterval>", "Ping interval").env("PING_INTERVAL").default(30).argParser((value) => parseInt(value, 10))).addOption(createOption("-ipc, --use-ipc", "Use IPC").env("USE_IPC").default(true)).addOption(createOption("-web, --use-web", "Use Web").env("USE_WEB").default(true)).addOption(createOption("-push, --use-push", "Use Push").env("USE_PUSH").default(true)).addOption(createOption("-wt, --web-theme <webTheme>", "Web theme").env("WEB_THEME").env("THEME").default("hotaru-theme")).addOption(createOption("-wmt, --web-title <webTitle>", "Web title").env("WEB_TITLE").default("Server Status")).addOption(createOption("-wst, --web-subtitle <webSubtitle>", "Web subtitle").env("WEB_SUBTITLE").default("Servers' Probes Set up with NodeStatus")).addOption(createOption("-wht, --web-headtitle <webHeadtitle>", "Web head title").env("WEB_HEADTITLE").default("NodeStatus")).addOption(createOption("-wu, --web-username <webUsername>", "Web username").env("WEB_USERNAME").default("admin")).addOption(createOption("-wp, --web-password <webPassword>", "Web password").env("WEB_PASSWORD").default("")).addOption(createOption("-ws, --web-secret <webSecret>", "Web jwt secret").env("WEB_SECRET").default("node-secret").argParser((val) => val || "node-secret")).addOption(
   createOption("-ia, --ipc-address <ipcAddress>", "IPC address").env("IPC_ADDRESS").default(
-    require$$0$6.platform() !== "win32" ? "/tmp/status_unix.sock" : "\\\\.\\pipe\\status_ipc"
+    platform$1() !== "win32" ? "/tmp/status_unix.sock" : "\\\\.\\pipe\\status_ipc"
   )
 ).addOption(createOption("-pt, --push-timeout <pushTimeout>", "Push timeout").env("PUSH_TIMEOUT").default(120).argParser((value) => parseInt(value, 10))).addOption(createOption("-pd, --push-delay <pushDelay>", "Push delay").env("PUSH_DELAY").default(15).argParser((value) => parseInt(value, 10))).addOption(createOption("-ti, --telegram-bot-token <telegramBotToken>", "Telegram bot token").env("TGBOT_TOKEN").default("")).addOption(createOption("-tc, --telegram-chat-id <telegramChatId>", "Telegram chat id").env("TGBOT_CHATID").default("")).addOption(createOption("-tp, --telegram-proxy <telegramProxy>", "Telegram proxy").env("TGBOT_PROXY")).addOption(createOption("-tw, --telegram-web-hook <telegramWebHook>", "Telegram web hook").env("TGBOT_WEBHOOK")).parse(process.argv);
 const options = program.opts();
-let database = process.env.DATABASE || (require$$0$6.platform() === "win32" ? `file:${require$$1$3.resolve(require$$0$6.homedir(), ".nodestatus/db.sqlite")}` : "file:/usr/local/NodeStatus/server/db.sqlite");
+let database = process.env.DATABASE || (platform$1() === "win32" ? `file:${resolve$3(homedir(), ".nodestatus/db.sqlite")}` : "file:/usr/local/NodeStatus/server/db.sqlite");
 if (!(database.includes("file:") || database.includes("mysql:") || database.includes("postgresql:"))) {
   database = `file:${database}`;
 }
@@ -81832,1429 +82811,9 @@ const verifySession = (ctx) => {
   ctx.body = createRes(1, "Verification failure");
 };
 
-var bcryptjsExports = {};
-var bcryptjs = {
-  get exports(){ return bcryptjsExports; },
-  set exports(v){ bcryptjsExports = v; },
-};
-
-var bcryptExports = {};
-var bcrypt = {
-  get exports(){ return bcryptExports; },
-  set exports(v){ bcryptExports = v; },
-};
-
-/*
- Copyright (c) 2012 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
- Copyright (c) 2012 Shane Girish <shaneGirish@gmail.com>
- Copyright (c) 2014 Daniel Wirtz <dcode@dcode.io>
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- 3. The name of the author may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-(function (module) {
-	/**
-	 * @license bcrypt.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
-	 * Released under the Apache License, Version 2.0
-	 * see: https://github.com/dcodeIO/bcrypt.js for details
-	 */
-	(function(global, factory) {
-
-	    /* AMD */ if (typeof commonjsRequire === 'function' && 'object' === "object" && module && module["exports"])
-	        module["exports"] = factory();
-	    /* Global */ else
-	        (global["dcodeIO"] = global["dcodeIO"] || {})["bcrypt"] = factory();
-
-	}(commonjsGlobal, function() {
-
-	    /**
-	     * bcrypt namespace.
-	     * @type {Object.<string,*>}
-	     */
-	    var bcrypt = {};
-
-	    /**
-	     * The random implementation to use as a fallback.
-	     * @type {?function(number):!Array.<number>}
-	     * @inner
-	     */
-	    var randomFallback = null;
-
-	    /**
-	     * Generates cryptographically secure random bytes.
-	     * @function
-	     * @param {number} len Bytes length
-	     * @returns {!Array.<number>} Random bytes
-	     * @throws {Error} If no random implementation is available
-	     * @inner
-	     */
-	    function random(len) {
-	        /* node */ if (module && module['exports'])
-	            try {
-	                return require("crypto")['randomBytes'](len);
-	            } catch (e) {}
-	        /* WCA */ try {
-	            var a; (self['crypto']||self['msCrypto'])['getRandomValues'](a = new Uint32Array(len));
-	            return Array.prototype.slice.call(a);
-	        } catch (e) {}
-	        /* fallback */ if (!randomFallback)
-	            throw Error("Neither WebCryptoAPI nor a crypto module is available. Use bcrypt.setRandomFallback to set an alternative");
-	        return randomFallback(len);
-	    }
-
-	    // Test if any secure randomness source is available
-	    var randomAvailable = false;
-	    try {
-	        random(1);
-	        randomAvailable = true;
-	    } catch (e) {}
-
-	    // Default fallback, if any
-	    randomFallback = null;
-	    /**
-	     * Sets the pseudo random number generator to use as a fallback if neither node's `crypto` module nor the Web Crypto
-	     *  API is available. Please note: It is highly important that the PRNG used is cryptographically secure and that it
-	     *  is seeded properly!
-	     * @param {?function(number):!Array.<number>} random Function taking the number of bytes to generate as its
-	     *  sole argument, returning the corresponding array of cryptographically secure random byte values.
-	     * @see http://nodejs.org/api/crypto.html
-	     * @see http://www.w3.org/TR/WebCryptoAPI/
-	     */
-	    bcrypt.setRandomFallback = function(random) {
-	        randomFallback = random;
-	    };
-
-	    /**
-	     * Synchronously generates a salt.
-	     * @param {number=} rounds Number of rounds to use, defaults to 10 if omitted
-	     * @param {number=} seed_length Not supported.
-	     * @returns {string} Resulting salt
-	     * @throws {Error} If a random fallback is required but not set
-	     * @expose
-	     */
-	    bcrypt.genSaltSync = function(rounds, seed_length) {
-	        rounds = rounds || GENSALT_DEFAULT_LOG2_ROUNDS;
-	        if (typeof rounds !== 'number')
-	            throw Error("Illegal arguments: "+(typeof rounds)+", "+(typeof seed_length));
-	        if (rounds < 4)
-	            rounds = 4;
-	        else if (rounds > 31)
-	            rounds = 31;
-	        var salt = [];
-	        salt.push("$2a$");
-	        if (rounds < 10)
-	            salt.push("0");
-	        salt.push(rounds.toString());
-	        salt.push('$');
-	        salt.push(base64_encode(random(BCRYPT_SALT_LEN), BCRYPT_SALT_LEN)); // May throw
-	        return salt.join('');
-	    };
-
-	    /**
-	     * Asynchronously generates a salt.
-	     * @param {(number|function(Error, string=))=} rounds Number of rounds to use, defaults to 10 if omitted
-	     * @param {(number|function(Error, string=))=} seed_length Not supported.
-	     * @param {function(Error, string=)=} callback Callback receiving the error, if any, and the resulting salt
-	     * @returns {!Promise} If `callback` has been omitted
-	     * @throws {Error} If `callback` is present but not a function
-	     * @expose
-	     */
-	    bcrypt.genSalt = function(rounds, seed_length, callback) {
-	        if (typeof seed_length === 'function')
-	            callback = seed_length,
-	            seed_length = undefined; // Not supported.
-	        if (typeof rounds === 'function')
-	            callback = rounds,
-	            rounds = undefined;
-	        if (typeof rounds === 'undefined')
-	            rounds = GENSALT_DEFAULT_LOG2_ROUNDS;
-	        else if (typeof rounds !== 'number')
-	            throw Error("illegal arguments: "+(typeof rounds));
-
-	        function _async(callback) {
-	            nextTick(function() { // Pretty thin, but salting is fast enough
-	                try {
-	                    callback(null, bcrypt.genSaltSync(rounds));
-	                } catch (err) {
-	                    callback(err);
-	                }
-	            });
-	        }
-
-	        if (callback) {
-	            if (typeof callback !== 'function')
-	                throw Error("Illegal callback: "+typeof(callback));
-	            _async(callback);
-	        } else
-	            return new Promise(function(resolve, reject) {
-	                _async(function(err, res) {
-	                    if (err) {
-	                        reject(err);
-	                        return;
-	                    }
-	                    resolve(res);
-	                });
-	            });
-	    };
-
-	    /**
-	     * Synchronously generates a hash for the given string.
-	     * @param {string} s String to hash
-	     * @param {(number|string)=} salt Salt length to generate or salt to use, default to 10
-	     * @returns {string} Resulting hash
-	     * @expose
-	     */
-	    bcrypt.hashSync = function(s, salt) {
-	        if (typeof salt === 'undefined')
-	            salt = GENSALT_DEFAULT_LOG2_ROUNDS;
-	        if (typeof salt === 'number')
-	            salt = bcrypt.genSaltSync(salt);
-	        if (typeof s !== 'string' || typeof salt !== 'string')
-	            throw Error("Illegal arguments: "+(typeof s)+', '+(typeof salt));
-	        return _hash(s, salt);
-	    };
-
-	    /**
-	     * Asynchronously generates a hash for the given string.
-	     * @param {string} s String to hash
-	     * @param {number|string} salt Salt length to generate or salt to use
-	     * @param {function(Error, string=)=} callback Callback receiving the error, if any, and the resulting hash
-	     * @param {function(number)=} progressCallback Callback successively called with the percentage of rounds completed
-	     *  (0.0 - 1.0), maximally once per `MAX_EXECUTION_TIME = 100` ms.
-	     * @returns {!Promise} If `callback` has been omitted
-	     * @throws {Error} If `callback` is present but not a function
-	     * @expose
-	     */
-	    bcrypt.hash = function(s, salt, callback, progressCallback) {
-
-	        function _async(callback) {
-	            if (typeof s === 'string' && typeof salt === 'number')
-	                bcrypt.genSalt(salt, function(err, salt) {
-	                    _hash(s, salt, callback, progressCallback);
-	                });
-	            else if (typeof s === 'string' && typeof salt === 'string')
-	                _hash(s, salt, callback, progressCallback);
-	            else
-	                nextTick(callback.bind(this, Error("Illegal arguments: "+(typeof s)+', '+(typeof salt))));
-	        }
-
-	        if (callback) {
-	            if (typeof callback !== 'function')
-	                throw Error("Illegal callback: "+typeof(callback));
-	            _async(callback);
-	        } else
-	            return new Promise(function(resolve, reject) {
-	                _async(function(err, res) {
-	                    if (err) {
-	                        reject(err);
-	                        return;
-	                    }
-	                    resolve(res);
-	                });
-	            });
-	    };
-
-	    /**
-	     * Compares two strings of the same length in constant time.
-	     * @param {string} known Must be of the correct length
-	     * @param {string} unknown Must be the same length as `known`
-	     * @returns {boolean}
-	     * @inner
-	     */
-	    function safeStringCompare(known, unknown) {
-	        var right = 0,
-	            wrong = 0;
-	        for (var i=0, k=known.length; i<k; ++i) {
-	            if (known.charCodeAt(i) === unknown.charCodeAt(i))
-	                ++right;
-	            else
-	                ++wrong;
-	        }
-	        // Prevent removal of unused variables (never true, actually)
-	        if (right < 0)
-	            return false;
-	        return wrong === 0;
-	    }
-
-	    /**
-	     * Synchronously tests a string against a hash.
-	     * @param {string} s String to compare
-	     * @param {string} hash Hash to test against
-	     * @returns {boolean} true if matching, otherwise false
-	     * @throws {Error} If an argument is illegal
-	     * @expose
-	     */
-	    bcrypt.compareSync = function(s, hash) {
-	        if (typeof s !== "string" || typeof hash !== "string")
-	            throw Error("Illegal arguments: "+(typeof s)+', '+(typeof hash));
-	        if (hash.length !== 60)
-	            return false;
-	        return safeStringCompare(bcrypt.hashSync(s, hash.substr(0, hash.length-31)), hash);
-	    };
-
-	    /**
-	     * Asynchronously compares the given data against the given hash.
-	     * @param {string} s Data to compare
-	     * @param {string} hash Data to be compared to
-	     * @param {function(Error, boolean)=} callback Callback receiving the error, if any, otherwise the result
-	     * @param {function(number)=} progressCallback Callback successively called with the percentage of rounds completed
-	     *  (0.0 - 1.0), maximally once per `MAX_EXECUTION_TIME = 100` ms.
-	     * @returns {!Promise} If `callback` has been omitted
-	     * @throws {Error} If `callback` is present but not a function
-	     * @expose
-	     */
-	    bcrypt.compare = function(s, hash, callback, progressCallback) {
-
-	        function _async(callback) {
-	            if (typeof s !== "string" || typeof hash !== "string") {
-	                nextTick(callback.bind(this, Error("Illegal arguments: "+(typeof s)+', '+(typeof hash))));
-	                return;
-	            }
-	            if (hash.length !== 60) {
-	                nextTick(callback.bind(this, null, false));
-	                return;
-	            }
-	            bcrypt.hash(s, hash.substr(0, 29), function(err, comp) {
-	                if (err)
-	                    callback(err);
-	                else
-	                    callback(null, safeStringCompare(comp, hash));
-	            }, progressCallback);
-	        }
-
-	        if (callback) {
-	            if (typeof callback !== 'function')
-	                throw Error("Illegal callback: "+typeof(callback));
-	            _async(callback);
-	        } else
-	            return new Promise(function(resolve, reject) {
-	                _async(function(err, res) {
-	                    if (err) {
-	                        reject(err);
-	                        return;
-	                    }
-	                    resolve(res);
-	                });
-	            });
-	    };
-
-	    /**
-	     * Gets the number of rounds used to encrypt the specified hash.
-	     * @param {string} hash Hash to extract the used number of rounds from
-	     * @returns {number} Number of rounds used
-	     * @throws {Error} If `hash` is not a string
-	     * @expose
-	     */
-	    bcrypt.getRounds = function(hash) {
-	        if (typeof hash !== "string")
-	            throw Error("Illegal arguments: "+(typeof hash));
-	        return parseInt(hash.split("$")[2], 10);
-	    };
-
-	    /**
-	     * Gets the salt portion from a hash. Does not validate the hash.
-	     * @param {string} hash Hash to extract the salt from
-	     * @returns {string} Extracted salt part
-	     * @throws {Error} If `hash` is not a string or otherwise invalid
-	     * @expose
-	     */
-	    bcrypt.getSalt = function(hash) {
-	        if (typeof hash !== 'string')
-	            throw Error("Illegal arguments: "+(typeof hash));
-	        if (hash.length !== 60)
-	            throw Error("Illegal hash length: "+hash.length+" != 60");
-	        return hash.substring(0, 29);
-	    };
-
-	    /**
-	     * Continues with the callback on the next tick.
-	     * @function
-	     * @param {function(...[*])} callback Callback to execute
-	     * @inner
-	     */
-	    var nextTick = typeof process !== 'undefined' && process && typeof process.nextTick === 'function'
-	        ? (typeof setImmediate === 'function' ? setImmediate : process.nextTick)
-	        : setTimeout;
-
-	    /**
-	     * Converts a JavaScript string to UTF8 bytes.
-	     * @param {string} str String
-	     * @returns {!Array.<number>} UTF8 bytes
-	     * @inner
-	     */
-	    function stringToBytes(str) {
-	        var out = [],
-	            i = 0;
-	        utfx.encodeUTF16toUTF8(function() {
-	            if (i >= str.length) return null;
-	            return str.charCodeAt(i++);
-	        }, function(b) {
-	            out.push(b);
-	        });
-	        return out;
-	    }
-
-	    // A base64 implementation for the bcrypt algorithm. This is partly non-standard.
-
-	    /**
-	     * bcrypt's own non-standard base64 dictionary.
-	     * @type {!Array.<string>}
-	     * @const
-	     * @inner
-	     **/
-	    var BASE64_CODE = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split('');
-
-	    /**
-	     * @type {!Array.<number>}
-	     * @const
-	     * @inner
-	     **/
-	    var BASE64_INDEX = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,
-	        1, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
-	        -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-	        20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, 28, 29, 30,
-	        31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	        48, 49, 50, 51, 52, 53, -1, -1, -1, -1, -1];
-
-	    /**
-	     * @type {!function(...number):string}
-	     * @inner
-	     */
-	    var stringFromCharCode = String.fromCharCode;
-
-	    /**
-	     * Encodes a byte array to base64 with up to len bytes of input.
-	     * @param {!Array.<number>} b Byte array
-	     * @param {number} len Maximum input length
-	     * @returns {string}
-	     * @inner
-	     */
-	    function base64_encode(b, len) {
-	        var off = 0,
-	            rs = [],
-	            c1, c2;
-	        if (len <= 0 || len > b.length)
-	            throw Error("Illegal len: "+len);
-	        while (off < len) {
-	            c1 = b[off++] & 0xff;
-	            rs.push(BASE64_CODE[(c1 >> 2) & 0x3f]);
-	            c1 = (c1 & 0x03) << 4;
-	            if (off >= len) {
-	                rs.push(BASE64_CODE[c1 & 0x3f]);
-	                break;
-	            }
-	            c2 = b[off++] & 0xff;
-	            c1 |= (c2 >> 4) & 0x0f;
-	            rs.push(BASE64_CODE[c1 & 0x3f]);
-	            c1 = (c2 & 0x0f) << 2;
-	            if (off >= len) {
-	                rs.push(BASE64_CODE[c1 & 0x3f]);
-	                break;
-	            }
-	            c2 = b[off++] & 0xff;
-	            c1 |= (c2 >> 6) & 0x03;
-	            rs.push(BASE64_CODE[c1 & 0x3f]);
-	            rs.push(BASE64_CODE[c2 & 0x3f]);
-	        }
-	        return rs.join('');
-	    }
-
-	    /**
-	     * Decodes a base64 encoded string to up to len bytes of output.
-	     * @param {string} s String to decode
-	     * @param {number} len Maximum output length
-	     * @returns {!Array.<number>}
-	     * @inner
-	     */
-	    function base64_decode(s, len) {
-	        var off = 0,
-	            slen = s.length,
-	            olen = 0,
-	            rs = [],
-	            c1, c2, c3, c4, o, code;
-	        if (len <= 0)
-	            throw Error("Illegal len: "+len);
-	        while (off < slen - 1 && olen < len) {
-	            code = s.charCodeAt(off++);
-	            c1 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
-	            code = s.charCodeAt(off++);
-	            c2 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
-	            if (c1 == -1 || c2 == -1)
-	                break;
-	            o = (c1 << 2) >>> 0;
-	            o |= (c2 & 0x30) >> 4;
-	            rs.push(stringFromCharCode(o));
-	            if (++olen >= len || off >= slen)
-	                break;
-	            code = s.charCodeAt(off++);
-	            c3 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
-	            if (c3 == -1)
-	                break;
-	            o = ((c2 & 0x0f) << 4) >>> 0;
-	            o |= (c3 & 0x3c) >> 2;
-	            rs.push(stringFromCharCode(o));
-	            if (++olen >= len || off >= slen)
-	                break;
-	            code = s.charCodeAt(off++);
-	            c4 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
-	            o = ((c3 & 0x03) << 6) >>> 0;
-	            o |= c4;
-	            rs.push(stringFromCharCode(o));
-	            ++olen;
-	        }
-	        var res = [];
-	        for (off = 0; off<olen; off++)
-	            res.push(rs[off].charCodeAt(0));
-	        return res;
-	    }
-
-	    /**
-	     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>
-	     * Released under the Apache License, Version 2.0
-	     * see: https://github.com/dcodeIO/utfx for details
-	     */
-	    var utfx = function() {
-
-	        /**
-	         * utfx namespace.
-	         * @inner
-	         * @type {!Object.<string,*>}
-	         */
-	        var utfx = {};
-
-	        /**
-	         * Maximum valid code point.
-	         * @type {number}
-	         * @const
-	         */
-	        utfx.MAX_CODEPOINT = 0x10FFFF;
-
-	        /**
-	         * Encodes UTF8 code points to UTF8 bytes.
-	         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
-	         *  respectively `null` if there are no more code points left or a single numeric code point.
-	         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
-	         */
-	        utfx.encodeUTF8 = function(src, dst) {
-	            var cp = null;
-	            if (typeof src === 'number')
-	                cp = src,
-	                src = function() { return null; };
-	            while (cp !== null || (cp = src()) !== null) {
-	                if (cp < 0x80)
-	                    dst(cp&0x7F);
-	                else if (cp < 0x800)
-	                    dst(((cp>>6)&0x1F)|0xC0),
-	                    dst((cp&0x3F)|0x80);
-	                else if (cp < 0x10000)
-	                    dst(((cp>>12)&0x0F)|0xE0),
-	                    dst(((cp>>6)&0x3F)|0x80),
-	                    dst((cp&0x3F)|0x80);
-	                else
-	                    dst(((cp>>18)&0x07)|0xF0),
-	                    dst(((cp>>12)&0x3F)|0x80),
-	                    dst(((cp>>6)&0x3F)|0x80),
-	                    dst((cp&0x3F)|0x80);
-	                cp = null;
-	            }
-	        };
-
-	        /**
-	         * Decodes UTF8 bytes to UTF8 code points.
-	         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
-	         *  are no more bytes left.
-	         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.
-	         * @throws {RangeError} If a starting byte is invalid in UTF8
-	         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the
-	         *  remaining bytes.
-	         */
-	        utfx.decodeUTF8 = function(src, dst) {
-	            var a, b, c, d, fail = function(b) {
-	                b = b.slice(0, b.indexOf(null));
-	                var err = Error(b.toString());
-	                err.name = "TruncatedError";
-	                err['bytes'] = b;
-	                throw err;
-	            };
-	            while ((a = src()) !== null) {
-	                if ((a&0x80) === 0)
-	                    dst(a);
-	                else if ((a&0xE0) === 0xC0)
-	                    ((b = src()) === null) && fail([a, b]),
-	                    dst(((a&0x1F)<<6) | (b&0x3F));
-	                else if ((a&0xF0) === 0xE0)
-	                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),
-	                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));
-	                else if ((a&0xF8) === 0xF0)
-	                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),
-	                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));
-	                else throw RangeError("Illegal starting byte: "+a);
-	            }
-	        };
-
-	        /**
-	         * Converts UTF16 characters to UTF8 code points.
-	         * @param {!function():number|null} src Characters source as a function returning the next char code respectively
-	         *  `null` if there are no more characters left.
-	         * @param {!function(number)} dst Code points destination as a function successively called with each converted code
-	         *  point.
-	         */
-	        utfx.UTF16toUTF8 = function(src, dst) {
-	            var c1, c2 = null;
-	            while (true) {
-	                if ((c1 = c2 !== null ? c2 : src()) === null)
-	                    break;
-	                if (c1 >= 0xD800 && c1 <= 0xDFFF) {
-	                    if ((c2 = src()) !== null) {
-	                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
-	                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);
-	                            c2 = null; continue;
-	                        }
-	                    }
-	                }
-	                dst(c1);
-	            }
-	            if (c2 !== null) dst(c2);
-	        };
-
-	        /**
-	         * Converts UTF8 code points to UTF16 characters.
-	         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
-	         *  respectively `null` if there are no more code points left or a single numeric code point.
-	         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
-	         * @throws {RangeError} If a code point is out of range
-	         */
-	        utfx.UTF8toUTF16 = function(src, dst) {
-	            var cp = null;
-	            if (typeof src === 'number')
-	                cp = src, src = function() { return null; };
-	            while (cp !== null || (cp = src()) !== null) {
-	                if (cp <= 0xFFFF)
-	                    dst(cp);
-	                else
-	                    cp -= 0x10000,
-	                    dst((cp>>10)+0xD800),
-	                    dst((cp%0x400)+0xDC00);
-	                cp = null;
-	            }
-	        };
-
-	        /**
-	         * Converts and encodes UTF16 characters to UTF8 bytes.
-	         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
-	         *  if there are no more characters left.
-	         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
-	         */
-	        utfx.encodeUTF16toUTF8 = function(src, dst) {
-	            utfx.UTF16toUTF8(src, function(cp) {
-	                utfx.encodeUTF8(cp, dst);
-	            });
-	        };
-
-	        /**
-	         * Decodes and converts UTF8 bytes to UTF16 characters.
-	         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
-	         *  are no more bytes left.
-	         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
-	         * @throws {RangeError} If a starting byte is invalid in UTF8
-	         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.
-	         */
-	        utfx.decodeUTF8toUTF16 = function(src, dst) {
-	            utfx.decodeUTF8(src, function(cp) {
-	                utfx.UTF8toUTF16(cp, dst);
-	            });
-	        };
-
-	        /**
-	         * Calculates the byte length of an UTF8 code point.
-	         * @param {number} cp UTF8 code point
-	         * @returns {number} Byte length
-	         */
-	        utfx.calculateCodePoint = function(cp) {
-	            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
-	        };
-
-	        /**
-	         * Calculates the number of UTF8 bytes required to store UTF8 code points.
-	         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively
-	         *  `null` if there are no more code points left.
-	         * @returns {number} The number of UTF8 bytes required
-	         */
-	        utfx.calculateUTF8 = function(src) {
-	            var cp, l=0;
-	            while ((cp = src()) !== null)
-	                l += utfx.calculateCodePoint(cp);
-	            return l;
-	        };
-
-	        /**
-	         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.
-	         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively
-	         *  `null` if there are no more characters left.
-	         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.
-	         */
-	        utfx.calculateUTF16asUTF8 = function(src) {
-	            var n=0, l=0;
-	            utfx.UTF16toUTF8(src, function(cp) {
-	                ++n; l += utfx.calculateCodePoint(cp);
-	            });
-	            return [n,l];
-	        };
-
-	        return utfx;
-	    }();
-
-	    Date.now = Date.now || function() { return +new Date; };
-
-	    /**
-	     * @type {number}
-	     * @const
-	     * @inner
-	     */
-	    var BCRYPT_SALT_LEN = 16;
-
-	    /**
-	     * @type {number}
-	     * @const
-	     * @inner
-	     */
-	    var GENSALT_DEFAULT_LOG2_ROUNDS = 10;
-
-	    /**
-	     * @type {number}
-	     * @const
-	     * @inner
-	     */
-	    var BLOWFISH_NUM_ROUNDS = 16;
-
-	    /**
-	     * @type {number}
-	     * @const
-	     * @inner
-	     */
-	    var MAX_EXECUTION_TIME = 100;
-
-	    /**
-	     * @type {Array.<number>}
-	     * @const
-	     * @inner
-	     */
-	    var P_ORIG = [
-	        0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822,
-	        0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377,
-	        0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5,
-	        0xb5470917, 0x9216d5d9, 0x8979fb1b
-	    ];
-
-	    /**
-	     * @type {Array.<number>}
-	     * @const
-	     * @inner
-	     */
-	    var S_ORIG = [
-	        0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed,
-	        0x6a267e96, 0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7,
-	        0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3,
-	        0xf4933d7e, 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-	        0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, 0xc5d1b023,
-	        0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
-	        0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda,
-	        0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-	        0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af,
-	        0x7c72e993, 0xb3ee1411, 0x636fbc2a, 0x2ba9c55d, 0x741831f6,
-	        0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381,
-	        0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-	        0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d,
-	        0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5,
-	        0x0f6d6ff3, 0x83f44239, 0x2e0b4482, 0xa4842004, 0x69c8f04a,
-	        0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-	        0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c,
-	        0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
-	        0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3,
-	        0x3b8b5ebe, 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-	        0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, 0x37d0d724,
-	        0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b,
-	        0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b, 0x976ce0bd,
-	        0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-	        0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f,
-	        0x9b30952c, 0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd,
-	        0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39,
-	        0xb9d3fbdb, 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-	        0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, 0x3c7516df,
-	        0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
-	        0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e,
-	        0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-	        0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98,
-	        0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, 0x9a53e479, 0xb6f84565,
-	        0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341,
-	        0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-	        0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0,
-	        0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64,
-	        0x8888b812, 0x900df01c, 0x4fad5ea0, 0x688fc31c, 0xd1cff191,
-	        0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-	        0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0,
-	        0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
-	        0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5,
-	        0xfb9d35cf, 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-	        0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, 0x2464369b,
-	        0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f,
-	        0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9, 0x11c81968,
-	        0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-	        0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5,
-	        0x571be91f, 0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6,
-	        0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799,
-	        0x6e85076a, 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-	        0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, 0xecaa8c71,
-	        0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29,
-	        0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65, 0x6b8fe4d6,
-	        0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-	        0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f,
-	        0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286,
-	        0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec,
-	        0x5716f2b8, 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-	        0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, 0xd19113f9,
-	        0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
-	        0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e,
-	        0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-	        0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290,
-	        0x24977c79, 0x5679b072, 0xbcaf89af, 0xde9a771f, 0xd9930810,
-	        0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6,
-	        0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-	        0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847,
-	        0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451,
-	        0x50940002, 0x133ae4dd, 0x71dff89e, 0x10314e55, 0x81ac77d6,
-	        0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-	        0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570,
-	        0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
-	        0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978,
-	        0x9c10b36a, 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-	        0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, 0x5223a708,
-	        0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883,
-	        0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5, 0x65582185,
-	        0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-	        0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830,
-	        0xeb61bd96, 0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239,
-	        0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab,
-	        0xb2f3846e, 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-	        0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 0x9b540b19,
-	        0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
-	        0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1,
-	        0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-	        0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef,
-	        0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 0x5d4a14d9, 0xe864b7e3,
-	        0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15,
-	        0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-	        0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2,
-	        0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492,
-	        0x47848a0b, 0x5692b285, 0x095bbf00, 0xad19489d, 0x1462b174,
-	        0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-	        0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759,
-	        0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
-	        0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc,
-	        0x800bcadc, 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-	        0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, 0xc5c43465,
-	        0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a,
-	        0xe6e39f2b, 0xdb83adf7, 0xe93d5a68, 0x948140f7, 0xf64c261c,
-	        0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-	        0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e,
-	        0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
-	        0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0,
-	        0x31cb8504, 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-	        0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, 0x68dc1462,
-	        0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c,
-	        0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec, 0xce78a399,
-	        0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-	        0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74,
-	        0xdd5b4332, 0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397,
-	        0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7,
-	        0xd096954b, 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-	        0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, 0xfdf8e802,
-	        0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
-	        0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4,
-	        0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-	        0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2,
-	        0x02e1329e, 0xaf664fd1, 0xcad18115, 0x6b2395e0, 0x333e92e1,
-	        0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c,
-	        0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-	        0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341,
-	        0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8,
-	        0x991be14c, 0xdb6e6b0d, 0xc67b5510, 0x6d672c37, 0x2765d43b,
-	        0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-	        0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88,
-	        0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
-	        0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc,
-	        0x782ef11c, 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-	        0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, 0x44421659,
-	        0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f,
-	        0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086, 0x60787bf8,
-	        0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-	        0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be,
-	        0xbde8ae24, 0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2,
-	        0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255,
-	        0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-	        0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, 0xb90bace1,
-	        0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
-	        0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025,
-	        0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-	        0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01,
-	        0xa70683fa, 0xa002b5c4, 0x0de6d027, 0x9af88c27, 0x773f8641,
-	        0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa,
-	        0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-	        0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409,
-	        0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9,
-	        0x1ac15bb4, 0xd39eb8fc, 0xed545578, 0x08fca5b5, 0xd83d7cd3,
-	        0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-	        0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234,
-	        0x92638212, 0x670efa8e, 0x406000e0, 0x3a39ce37, 0xd3faf5cf,
-	        0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740,
-	        0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-	        0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f,
-	        0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d,
-	        0xd5730a1d, 0x4cd04dc6, 0x2939bbdb, 0xa9ba4650, 0xac9526e8,
-	        0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-	        0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba,
-	        0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
-	        0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69,
-	        0x77fa0a59, 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-	        0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a,
-	        0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b,
-	        0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6, 0x47b0acfd,
-	        0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-	        0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4,
-	        0x88f46dba, 0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2,
-	        0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb,
-	        0x26dcf319, 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-	        0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, 0x4de81751,
-	        0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
-	        0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369,
-	        0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-	        0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd,
-	        0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 0xdda26a7e, 0x3a59ff45,
-	        0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae,
-	        0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-	        0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08,
-	        0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d,
-	        0x06b89fb4, 0xce6ea048, 0x6f3f3b82, 0x3520ab82, 0x011a1d4b,
-	        0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-	        0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e,
-	        0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
-	        0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c,
-	        0xe0b12b4f, 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-	        0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, 0xfae59361,
-	        0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c,
-	        0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be,
-	        0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-	        0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d,
-	        0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891,
-	        0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5,
-	        0xf6fb2299, 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-	        0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, 0xde966292,
-	        0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
-	        0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2,
-	        0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-	        0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c,
-	        0xf746ce76, 0x77afa1c5, 0x20756060, 0x85cbfe4e, 0x8ae88dd8,
-	        0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4,
-	        0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-	        0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
-	    ];
-
-	    /**
-	     * @type {Array.<number>}
-	     * @const
-	     * @inner
-	     */
-	    var C_ORIG = [
-	        0x4f727068, 0x65616e42, 0x65686f6c, 0x64657253, 0x63727944,
-	        0x6f756274
-	    ];
-
-	    /**
-	     * @param {Array.<number>} lr
-	     * @param {number} off
-	     * @param {Array.<number>} P
-	     * @param {Array.<number>} S
-	     * @returns {Array.<number>}
-	     * @inner
-	     */
-	    function _encipher(lr, off, P, S) { // This is our bottleneck: 1714/1905 ticks / 90% - see profile.txt
-	        var n,
-	            l = lr[off],
-	            r = lr[off + 1];
-
-	        l ^= P[0];
-
-	        /*
-	        for (var i=0, k=BLOWFISH_NUM_ROUNDS-2; i<=k;)
-	            // Feistel substitution on left word
-	            n  = S[l >>> 24],
-	            n += S[0x100 | ((l >> 16) & 0xff)],
-	            n ^= S[0x200 | ((l >> 8) & 0xff)],
-	            n += S[0x300 | (l & 0xff)],
-	            r ^= n ^ P[++i],
-	            // Feistel substitution on right word
-	            n  = S[r >>> 24],
-	            n += S[0x100 | ((r >> 16) & 0xff)],
-	            n ^= S[0x200 | ((r >> 8) & 0xff)],
-	            n += S[0x300 | (r & 0xff)],
-	            l ^= n ^ P[++i];
-	        */
-
-	        //The following is an unrolled version of the above loop.
-	        //Iteration 0
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[1];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[2];
-	        //Iteration 1
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[3];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[4];
-	        //Iteration 2
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[5];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[6];
-	        //Iteration 3
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[7];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[8];
-	        //Iteration 4
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[9];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[10];
-	        //Iteration 5
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[11];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[12];
-	        //Iteration 6
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[13];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[14];
-	        //Iteration 7
-	        n  = S[l >>> 24];
-	        n += S[0x100 | ((l >> 16) & 0xff)];
-	        n ^= S[0x200 | ((l >> 8) & 0xff)];
-	        n += S[0x300 | (l & 0xff)];
-	        r ^= n ^ P[15];
-	        n  = S[r >>> 24];
-	        n += S[0x100 | ((r >> 16) & 0xff)];
-	        n ^= S[0x200 | ((r >> 8) & 0xff)];
-	        n += S[0x300 | (r & 0xff)];
-	        l ^= n ^ P[16];
-
-	        lr[off] = r ^ P[BLOWFISH_NUM_ROUNDS + 1];
-	        lr[off + 1] = l;
-	        return lr;
-	    }
-
-	    /**
-	     * @param {Array.<number>} data
-	     * @param {number} offp
-	     * @returns {{key: number, offp: number}}
-	     * @inner
-	     */
-	    function _streamtoword(data, offp) {
-	        for (var i = 0, word = 0; i < 4; ++i)
-	            word = (word << 8) | (data[offp] & 0xff),
-	            offp = (offp + 1) % data.length;
-	        return { key: word, offp: offp };
-	    }
-
-	    /**
-	     * @param {Array.<number>} key
-	     * @param {Array.<number>} P
-	     * @param {Array.<number>} S
-	     * @inner
-	     */
-	    function _key(key, P, S) {
-	        var offset = 0,
-	            lr = [0, 0],
-	            plen = P.length,
-	            slen = S.length,
-	            sw;
-	        for (var i = 0; i < plen; i++)
-	            sw = _streamtoword(key, offset),
-	            offset = sw.offp,
-	            P[i] = P[i] ^ sw.key;
-	        for (i = 0; i < plen; i += 2)
-	            lr = _encipher(lr, 0, P, S),
-	            P[i] = lr[0],
-	            P[i + 1] = lr[1];
-	        for (i = 0; i < slen; i += 2)
-	            lr = _encipher(lr, 0, P, S),
-	            S[i] = lr[0],
-	            S[i + 1] = lr[1];
-	    }
-
-	    /**
-	     * Expensive key schedule Blowfish.
-	     * @param {Array.<number>} data
-	     * @param {Array.<number>} key
-	     * @param {Array.<number>} P
-	     * @param {Array.<number>} S
-	     * @inner
-	     */
-	    function _ekskey(data, key, P, S) {
-	        var offp = 0,
-	            lr = [0, 0],
-	            plen = P.length,
-	            slen = S.length,
-	            sw;
-	        for (var i = 0; i < plen; i++)
-	            sw = _streamtoword(key, offp),
-	            offp = sw.offp,
-	            P[i] = P[i] ^ sw.key;
-	        offp = 0;
-	        for (i = 0; i < plen; i += 2)
-	            sw = _streamtoword(data, offp),
-	            offp = sw.offp,
-	            lr[0] ^= sw.key,
-	            sw = _streamtoword(data, offp),
-	            offp = sw.offp,
-	            lr[1] ^= sw.key,
-	            lr = _encipher(lr, 0, P, S),
-	            P[i] = lr[0],
-	            P[i + 1] = lr[1];
-	        for (i = 0; i < slen; i += 2)
-	            sw = _streamtoword(data, offp),
-	            offp = sw.offp,
-	            lr[0] ^= sw.key,
-	            sw = _streamtoword(data, offp),
-	            offp = sw.offp,
-	            lr[1] ^= sw.key,
-	            lr = _encipher(lr, 0, P, S),
-	            S[i] = lr[0],
-	            S[i + 1] = lr[1];
-	    }
-
-	    /**
-	     * Internaly crypts a string.
-	     * @param {Array.<number>} b Bytes to crypt
-	     * @param {Array.<number>} salt Salt bytes to use
-	     * @param {number} rounds Number of rounds
-	     * @param {function(Error, Array.<number>=)=} callback Callback receiving the error, if any, and the resulting bytes. If
-	     *  omitted, the operation will be performed synchronously.
-	     *  @param {function(number)=} progressCallback Callback called with the current progress
-	     * @returns {!Array.<number>|undefined} Resulting bytes if callback has been omitted, otherwise `undefined`
-	     * @inner
-	     */
-	    function _crypt(b, salt, rounds, callback, progressCallback) {
-	        var cdata = C_ORIG.slice(),
-	            clen = cdata.length,
-	            err;
-
-	        // Validate
-	        if (rounds < 4 || rounds > 31) {
-	            err = Error("Illegal number of rounds (4-31): "+rounds);
-	            if (callback) {
-	                nextTick(callback.bind(this, err));
-	                return;
-	            } else
-	                throw err;
-	        }
-	        if (salt.length !== BCRYPT_SALT_LEN) {
-	            err =Error("Illegal salt length: "+salt.length+" != "+BCRYPT_SALT_LEN);
-	            if (callback) {
-	                nextTick(callback.bind(this, err));
-	                return;
-	            } else
-	                throw err;
-	        }
-	        rounds = (1 << rounds) >>> 0;
-
-	        var P, S, i = 0, j;
-
-	        //Use typed arrays when available - huge speedup!
-	        if (Int32Array) {
-	            P = new Int32Array(P_ORIG);
-	            S = new Int32Array(S_ORIG);
-	        } else {
-	            P = P_ORIG.slice();
-	            S = S_ORIG.slice();
-	        }
-
-	        _ekskey(salt, b, P, S);
-
-	        /**
-	         * Calcualtes the next round.
-	         * @returns {Array.<number>|undefined} Resulting array if callback has been omitted, otherwise `undefined`
-	         * @inner
-	         */
-	        function next() {
-	            if (progressCallback)
-	                progressCallback(i / rounds);
-	            if (i < rounds) {
-	                var start = Date.now();
-	                for (; i < rounds;) {
-	                    i = i + 1;
-	                    _key(b, P, S);
-	                    _key(salt, P, S);
-	                    if (Date.now() - start > MAX_EXECUTION_TIME)
-	                        break;
-	                }
-	            } else {
-	                for (i = 0; i < 64; i++)
-	                    for (j = 0; j < (clen >> 1); j++)
-	                        _encipher(cdata, j << 1, P, S);
-	                var ret = [];
-	                for (i = 0; i < clen; i++)
-	                    ret.push(((cdata[i] >> 24) & 0xff) >>> 0),
-	                    ret.push(((cdata[i] >> 16) & 0xff) >>> 0),
-	                    ret.push(((cdata[i] >> 8) & 0xff) >>> 0),
-	                    ret.push((cdata[i] & 0xff) >>> 0);
-	                if (callback) {
-	                    callback(null, ret);
-	                    return;
-	                } else
-	                    return ret;
-	            }
-	            if (callback)
-	                nextTick(next);
-	        }
-
-	        // Async
-	        if (typeof callback !== 'undefined') {
-	            next();
-
-	            // Sync
-	        } else {
-	            var res;
-	            while (true)
-	                if (typeof(res = next()) !== 'undefined')
-	                    return res || [];
-	        }
-	    }
-
-	    /**
-	     * Internally hashes a string.
-	     * @param {string} s String to hash
-	     * @param {?string} salt Salt to use, actually never null
-	     * @param {function(Error, string=)=} callback Callback receiving the error, if any, and the resulting hash. If omitted,
-	     *  hashing is perormed synchronously.
-	     *  @param {function(number)=} progressCallback Callback called with the current progress
-	     * @returns {string|undefined} Resulting hash if callback has been omitted, otherwise `undefined`
-	     * @inner
-	     */
-	    function _hash(s, salt, callback, progressCallback) {
-	        var err;
-	        if (typeof s !== 'string' || typeof salt !== 'string') {
-	            err = Error("Invalid string / salt: Not a string");
-	            if (callback) {
-	                nextTick(callback.bind(this, err));
-	                return;
-	            }
-	            else
-	                throw err;
-	        }
-
-	        // Validate the salt
-	        var minor, offset;
-	        if (salt.charAt(0) !== '$' || salt.charAt(1) !== '2') {
-	            err = Error("Invalid salt version: "+salt.substring(0,2));
-	            if (callback) {
-	                nextTick(callback.bind(this, err));
-	                return;
-	            }
-	            else
-	                throw err;
-	        }
-	        if (salt.charAt(2) === '$')
-	            minor = String.fromCharCode(0),
-	            offset = 3;
-	        else {
-	            minor = salt.charAt(2);
-	            if ((minor !== 'a' && minor !== 'b' && minor !== 'y') || salt.charAt(3) !== '$') {
-	                err = Error("Invalid salt revision: "+salt.substring(2,4));
-	                if (callback) {
-	                    nextTick(callback.bind(this, err));
-	                    return;
-	                } else
-	                    throw err;
-	            }
-	            offset = 4;
-	        }
-
-	        // Extract number of rounds
-	        if (salt.charAt(offset + 2) > '$') {
-	            err = Error("Missing salt rounds");
-	            if (callback) {
-	                nextTick(callback.bind(this, err));
-	                return;
-	            } else
-	                throw err;
-	        }
-	        var r1 = parseInt(salt.substring(offset, offset + 1), 10) * 10,
-	            r2 = parseInt(salt.substring(offset + 1, offset + 2), 10),
-	            rounds = r1 + r2,
-	            real_salt = salt.substring(offset + 3, offset + 25);
-	        s += minor >= 'a' ? "\x00" : "";
-
-	        var passwordb = stringToBytes(s),
-	            saltb = base64_decode(real_salt, BCRYPT_SALT_LEN);
-
-	        /**
-	         * Finishes hashing.
-	         * @param {Array.<number>} bytes Byte array
-	         * @returns {string}
-	         * @inner
-	         */
-	        function finish(bytes) {
-	            var res = [];
-	            res.push("$2");
-	            if (minor >= 'a')
-	                res.push(minor);
-	            res.push("$");
-	            if (rounds < 10)
-	                res.push("0");
-	            res.push(rounds.toString());
-	            res.push("$");
-	            res.push(base64_encode(saltb, saltb.length));
-	            res.push(base64_encode(bytes, C_ORIG.length * 4 - 1));
-	            return res.join('');
-	        }
-
-	        // Sync
-	        if (typeof callback == 'undefined')
-	            return finish(_crypt(passwordb, saltb, rounds));
-
-	        // Async
-	        else {
-	            _crypt(passwordb, saltb, rounds, function(err, bytes) {
-	                if (err)
-	                    callback(err, null);
-	                else
-	                    callback(null, finish(bytes));
-	            }, progressCallback);
-	        }
-	    }
-
-	    /**
-	     * Encodes a byte array to base64 with up to len bytes of input, using the custom bcrypt alphabet.
-	     * @function
-	     * @param {!Array.<number>} b Byte array
-	     * @param {number} len Maximum input length
-	     * @returns {string}
-	     * @expose
-	     */
-	    bcrypt.encodeBase64 = base64_encode;
-
-	    /**
-	     * Decodes a base64 encoded string to up to len bytes of output, using the custom bcrypt alphabet.
-	     * @function
-	     * @param {string} s String to decode
-	     * @param {number} len Maximum output length
-	     * @returns {!Array.<number>}
-	     * @expose
-	     */
-	    bcrypt.decodeBase64 = base64_decode;
-
-	    return bcrypt;
-	}));
-} (bcrypt));
-
-/*
- Copyright (c) 2012 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
- Copyright (c) 2012 Shane Girish <shaneGirish@gmail.com>
- Copyright (c) 2013 Daniel Wirtz <dcode@dcode.io>
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- 3. The name of the author may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-(function (module) {
-	module.exports = bcryptExports;
-} (bcryptjs));
+const I=16,$=10,D=16,F=100,w="./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split(""),S=Array.from({length:64},(n,r)=>r),d=n=>Array(n).fill(-1),f=[...d(46),0,1,...S.slice(54,64),...d(7),...S.slice(2,28),...d(6),...S.slice(28,54),...d(5)],_=[608135816,2242054355,320440878,57701188,2752067618,698298832,137296536,3964562569,1160258022,953160567,3193202383,887688300,3232508343,3380367581,1065670069,3041331479,2450970073,2306472731],P=[3509652390,2564797868,805139163,3491422135,3101798381,1780907670,3128725573,4046225305,614570311,3012652279,134345442,2240740374,1667834072,1901547113,2757295779,4103290238,227898511,1921955416,1904987480,2182433518,2069144605,3260701109,2620446009,720527379,3318853667,677414384,3393288472,3101374703,2390351024,1614419982,1822297739,2954791486,3608508353,3174124327,2024746970,1432378464,3864339955,2857741204,1464375394,1676153920,1439316330,715854006,3033291828,289532110,2706671279,2087905683,3018724369,1668267050,732546397,1947742710,3462151702,2609353502,2950085171,1814351708,2050118529,680887927,999245976,1800124847,3300911131,1713906067,1641548236,4213287313,1216130144,1575780402,4018429277,3917837745,3693486850,3949271944,596196993,3549867205,258830323,2213823033,772490370,2760122372,1774776394,2652871518,566650946,4142492826,1728879713,2882767088,1783734482,3629395816,2517608232,2874225571,1861159788,326777828,3124490320,2130389656,2716951837,967770486,1724537150,2185432712,2364442137,1164943284,2105845187,998989502,3765401048,2244026483,1075463327,1455516326,1322494562,910128902,469688178,1117454909,936433444,3490320968,3675253459,1240580251,122909385,2157517691,634681816,4142456567,3825094682,3061402683,2540495037,79693498,3249098678,1084186820,1583128258,426386531,1761308591,1047286709,322548459,995290223,1845252383,2603652396,3431023940,2942221577,3202600964,3727903485,1712269319,422464435,3234572375,1170764815,3523960633,3117677531,1434042557,442511882,3600875718,1076654713,1738483198,4213154764,2393238008,3677496056,1014306527,4251020053,793779912,2902807211,842905082,4246964064,1395751752,1040244610,2656851899,3396308128,445077038,3742853595,3577915638,679411651,2892444358,2354009459,1767581616,3150600392,3791627101,3102740896,284835224,4246832056,1258075500,768725851,2589189241,3069724005,3532540348,1274779536,3789419226,2764799539,1660621633,3471099624,4011903706,913787905,3497959166,737222580,2514213453,2928710040,3937242737,1804850592,3499020752,2949064160,2386320175,2390070455,2415321851,4061277028,2290661394,2416832540,1336762016,1754252060,3520065937,3014181293,791618072,3188594551,3933548030,2332172193,3852520463,3043980520,413987798,3465142937,3030929376,4245938359,2093235073,3534596313,375366246,2157278981,2479649556,555357303,3870105701,2008414854,3344188149,4221384143,3956125452,2067696032,3594591187,2921233993,2428461,544322398,577241275,1471733935,610547355,4027169054,1432588573,1507829418,2025931657,3646575487,545086370,48609733,2200306550,1653985193,298326376,1316178497,3007786442,2064951626,458293330,2589141269,3591329599,3164325604,727753846,2179363840,146436021,1461446943,4069977195,705550613,3059967265,3887724982,4281599278,3313849956,1404054877,2845806497,146425753,1854211946,1266315497,3048417604,3681880366,3289982499,290971e4,1235738493,2632868024,2414719590,3970600049,1771706367,1449415276,3266420449,422970021,1963543593,2690192192,3826793022,1062508698,1531092325,1804592342,2583117782,2714934279,4024971509,1294809318,4028980673,1289560198,2221992742,1669523910,35572830,157838143,1052438473,1016535060,1802137761,1753167236,1386275462,3080475397,2857371447,1040679964,2145300060,2390574316,1461121720,2956646967,4031777805,4028374788,33600511,2920084762,1018524850,629373528,3691585981,3515945977,2091462646,2486323059,586499841,988145025,935516892,3367335476,2599673255,2839830854,265290510,3972581182,2759138881,3795373465,1005194799,847297441,406762289,1314163512,1332590856,1866599683,4127851711,750260880,613907577,1450815602,3165620655,3734664991,3650291728,3012275730,3704569646,1427272223,778793252,1343938022,2676280711,2052605720,1946737175,3164576444,3914038668,3967478842,3682934266,1661551462,3294938066,4011595847,840292616,3712170807,616741398,312560963,711312465,1351876610,322626781,1910503582,271666773,2175563734,1594956187,70604529,3617834859,1007753275,1495573769,4069517037,2549218298,2663038764,504708206,2263041392,3941167025,2249088522,1514023603,1998579484,1312622330,694541497,2582060303,2151582166,1382467621,776784248,2618340202,3323268794,2497899128,2784771155,503983604,4076293799,907881277,423175695,432175456,1378068232,4145222326,3954048622,3938656102,3820766613,2793130115,2977904593,26017576,3274890735,3194772133,1700274565,1756076034,4006520079,3677328699,720338349,1533947780,354530856,688349552,3973924725,1637815568,332179504,3949051286,53804574,2852348879,3044236432,1282449977,3583942155,3416972820,4006381244,1617046695,2628476075,3002303598,1686838959,431878346,2686675385,1700445008,1080580658,1009431731,832498133,3223435511,2605976345,2271191193,2516031870,1648197032,4164389018,2548247927,300782431,375919233,238389289,3353747414,2531188641,2019080857,1475708069,455242339,2609103871,448939670,3451063019,1395535956,2413381860,1841049896,1491858159,885456874,4264095073,4001119347,1565136089,3898914787,1108368660,540939232,1173283510,2745871338,3681308437,4207628240,3343053890,4016749493,1699691293,1103962373,3625875870,2256883143,3830138730,1031889488,3479347698,1535977030,4236805024,3251091107,2132092099,1774941330,1199868427,1452454533,157007616,2904115357,342012276,595725824,1480756522,206960106,497939518,591360097,863170706,2375253569,3596610801,1814182875,2094937945,3421402208,1082520231,3463918190,2785509508,435703966,3908032597,1641649973,2842273706,3305899714,1510255612,2148256476,2655287854,3276092548,4258621189,236887753,3681803219,274041037,1734335097,3815195456,3317970021,1899903192,1026095262,4050517792,356393447,2410691914,3873677099,3682840055,3913112168,2491498743,4132185628,2489919796,1091903735,1979897079,3170134830,3567386728,3557303409,857797738,1136121015,1342202287,507115054,2535736646,337727348,3213592640,1301675037,2528481711,1895095763,1721773893,3216771564,62756741,2142006736,835421444,2531993523,1442658625,3659876326,2882144922,676362277,1392781812,170690266,3921047035,1759253602,3611846912,1745797284,664899054,1329594018,3901205900,3045908486,2062866102,2865634940,3543621612,3464012697,1080764994,553557557,3656615353,3996768171,991055499,499776247,1265440854,648242737,3940784050,980351604,3713745714,1749149687,3396870395,4211799374,3640570775,1161844396,3125318951,1431517754,545492359,4268468663,3499529547,1437099964,2702547544,3433638243,2581715763,2787789398,1060185593,1593081372,2418618748,4260947970,69676912,2159744348,86519011,2512459080,3838209314,1220612927,3339683548,133810670,1090789135,1078426020,1569222167,845107691,3583754449,4072456591,1091646820,628848692,1613405280,3757631651,526609435,236106946,48312990,2942717905,3402727701,1797494240,859738849,992217954,4005476642,2243076622,3870952857,3732016268,765654824,3490871365,2511836413,1685915746,3888969200,1414112111,2273134842,3281911079,4080962846,172450625,2569994100,980381355,4109958455,2819808352,2716589560,2568741196,3681446669,3329971472,1835478071,660984891,3704678404,4045999559,3422617507,3040415634,1762651403,1719377915,3470491036,2693910283,3642056355,3138596744,1364962596,2073328063,1983633131,926494387,3423689081,2150032023,4096667949,1749200295,3328846651,309677260,2016342300,1779581495,3079819751,111262694,1274766160,443224088,298511866,1025883608,3806446537,1145181785,168956806,3641502830,3584813610,1689216846,3666258015,3200248200,1692713982,2646376535,4042768518,1618508792,1610833997,3523052358,4130873264,2001055236,3610705100,2202168115,4028541809,2961195399,1006657119,2006996926,3186142756,1430667929,3210227297,1314452623,4074634658,4101304120,2273951170,1399257539,3367210612,3027628629,1190975929,2062231137,2333990788,2221543033,2438960610,1181637006,548689776,2362791313,3372408396,3104550113,3145860560,296247880,1970579870,3078560182,3769228297,1714227617,3291629107,3898220290,166772364,1251581989,493813264,448347421,195405023,2709975567,677966185,3703036547,1463355134,2715995803,1338867538,1343315457,2802222074,2684532164,233230375,2599980071,2000651841,3277868038,1638401717,4028070440,3237316320,6314154,819756386,300326615,590932579,1405279636,3267499572,3150704214,2428286686,3959192993,3461946742,1862657033,1266418056,963775037,2089974820,2263052895,1917689273,448879540,3550394620,3981727096,150775221,3627908307,1303187396,508620638,2975983352,2726630617,1817252668,1876281319,1457606340,908771278,3720792119,3617206836,2455994898,1729034894,1080033504,976866871,3556439503,2881648439,1522871579,1555064734,1336096578,3548522304,2579274686,3574697629,3205460757,3593280638,3338716283,3079412587,564236357,2993598910,1781952180,1464380207,3163844217,3332601554,1699332808,1393555694,1183702653,3581086237,1288719814,691649499,2847557200,2895455976,3193889540,2717570544,1781354906,1676643554,2592534050,3230253752,1126444790,2770207658,2633158820,2210423226,2615765581,2414155088,3127139286,673620729,2805611233,1269405062,4015350505,3341807571,4149409754,1057255273,2012875353,2162469141,2276492801,2601117357,993977747,3918593370,2654263191,753973209,36408145,2530585658,25011837,3520020182,2088578344,530523599,2918365339,1524020338,1518925132,3760827505,3759777254,1202760957,3985898139,3906192525,674977740,4174734889,2031300136,2019492241,3983892565,4153806404,3822280332,352677332,2297720250,60907813,90501309,3286998549,1016092578,2535922412,2839152426,457141659,509813237,4120667899,652014361,1966332200,2975202805,55981186,2327461051,676427537,3255491064,2882294119,3433927263,1307055953,942726286,933058658,2468411793,3933900994,4215176142,1361170020,2001714738,2830558078,3274259782,1222529897,1679025792,2729314320,3714953764,1770335741,151462246,3013232138,1682292957,1483529935,471910574,1539241949,458788160,3436315007,1807016891,3718408830,978976581,1043663428,3165965781,1927990952,4200891579,2372276910,3208408903,3533431907,1412390302,2931980059,4132332400,1947078029,3881505623,4168226417,2941484381,1077988104,1320477388,886195818,18198404,3786409e3,2509781533,112762804,3463356488,1866414978,891333506,18488651,661792760,1628790961,3885187036,3141171499,876946877,2693282273,1372485963,791857591,2686433993,3759982718,3167212022,3472953795,2716379847,445679433,3561995674,3504004811,3574258232,54117162,3331405415,2381918588,3769707343,4154350007,1140177722,4074052095,668550556,3214352940,367459370,261225585,2610173221,4209349473,3468074219,3265815641,314222801,3066103646,3808782860,282218597,3406013506,3773591054,379116347,1285071038,846784868,2669647154,3771962079,3550491691,2305946142,453669953,1268987020,3317592352,3279303384,3744833421,2610507566,3859509063,266596637,3847019092,517658769,3462560207,3443424879,370717030,4247526661,2224018117,4143653529,4112773975,2788324899,2477274417,1456262402,2901442914,1517677493,1846949527,2295493580,3734397586,2176403920,1280348187,1908823572,3871786941,846861322,1172426758,3287448474,3383383037,1655181056,3139813346,901632758,1897031941,2986607138,3066810236,3447102507,1393639104,373351379,950779232,625454576,3124240540,4148612726,2007998917,544563296,2244738638,2330496472,2058025392,1291430526,424198748,50039436,29584100,3605783033,2429876329,2791104160,1057563949,3255363231,3075367218,3463963227,1469046755,985887462],k=[1332899944,1700884034,1701343084,1684370003,1668446532,1869963892],b=(n,r)=>{if(r<=0||r>n.length)throw Error(`Illegal len: ${r}`);let o=0,t,e;const l=[];for(;o<r;){if(t=n[o++]&255,l.push(w[t>>2&63]),t=(t&3)<<4,o>=r){l.push(w[t&63]);break}if(e=n[o++]&255,t|=e>>4&15,l.push(w[t&63]),t=(e&15)<<2,o>=r){l.push(w[t&63]);break}e=n[o++]&255,t|=e>>6&3,l.push(w[t&63]),l.push(w[e&63]);}return l.join("")},R=(n,r)=>{if(r<=0)throw Error(`Illegal len: ${r}`);const o=n.length;let t=0,e=0,l,s,i,u,h,p;const a=[];for(;t<o-1&&e<r&&(p=n.charCodeAt(t++),l=p<f.length?f[p]:-1,p=n.charCodeAt(t++),s=p<f.length?f[p]:-1,!(l==-1||s==-1||(h=l<<2>>>0,h|=(s&48)>>4,a.push(String.fromCharCode(h)),++e>=r||t>=o)||(p=n.charCodeAt(t++),i=p<f.length?f[p]:-1,i==-1)||(h=(s&15)<<4>>>0,h|=(i&60)>>2,a.push(String.fromCharCode(h)),++e>=r||t>=o)));)p=n.charCodeAt(t++),u=p<f.length?f[p]:-1,h=(i&3)<<6>>>0,h|=u,a.push(String.fromCharCode(h)),++e;return a.map(c=>c.charCodeAt(0))},v=(n,r)=>{let o=null;for(typeof n=="number"&&(o=n,n=()=>null);o!==null||(o=n())!==null;)o<128?r(o&127):o<2048?(r(o>>6&31|192),r(o&63|128)):o<65536?(r(o>>12&15|224),r(o>>6&63|128),r(o&63|128)):(r(o>>18&7|240),r(o>>12&63|128),r(o>>6&63|128),r(o&63|128)),o=null;},L=(n,r)=>{let o,t=null;for(;(o=t!==null?t:n())!==null;){if(o>=55296&&o<=57343&&(t=n())!==null&&t>=56320&&t<=57343){r((o-55296)*1024+t-56320+65536),t=null;continue}r(o);}t!==null&&r(t);},G=(n,r)=>{L(n,function(o){v(o,r);});},A=typeof process<"u"&&process&&typeof process.nextTick=="function"?typeof setImmediate=="function"?setImmediate:process.nextTick:setTimeout,M=n=>{const r=[];let o=0;return G(()=>o>=n.length?null:n.charCodeAt(o++),t=>{r.push(t);}),r},E=(n,r,o,t)=>{let e,l=n[r],s=n[r+1];return l^=o[0],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[1],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[2],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[3],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[4],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[5],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[6],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[7],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[8],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[9],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[10],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[11],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[12],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[13],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[14],e=t[l>>>24],e+=t[256|l>>16&255],e^=t[512|l>>8&255],e+=t[768|l&255],s^=e^o[15],e=t[s>>>24],e+=t[256|s>>16&255],e^=t[512|s>>8&255],e+=t[768|s&255],l^=e^o[16],n[r]=s^o[D+1],n[r+1]=l,n},m=(n,r)=>{let o=0;for(let t=0;t<4;++t)o=o<<8|n[r]&255,r=(r+1)%n.length;return {key:o,offp:r}},j=(n,r,o)=>{const t=r.length,e=o.length;let l=0,s=[0,0],i;for(let u=0;u<t;u++)i=m(n,l),l=i.offp,r[u]=r[u]^i.key;for(let u=0;u<t;u+=2)s=E(s,0,r,o),r[u]=s[0],r[u+1]=s[1];for(let u=0;u<e;u+=2)s=E(s,0,r,o),o[u]=s[0],o[u+1]=s[1];},X=(n,r,o,t)=>{const e=o.length,l=t.length;let s=0,i=[0,0],u;for(let h=0;h<e;h++)u=m(r,s),s=u.offp,o[h]=o[h]^u.key;s=0;for(let h=0;h<e;h+=2)u=m(n,s),s=u.offp,i[0]^=u.key,u=m(n,s),s=u.offp,i[1]^=u.key,i=E(i,0,o,t),o[h]=i[0],o[h+1]=i[1];for(let h=0;h<l;h+=2)u=m(n,s),s=u.offp,i[0]^=u.key,u=m(n,s),s=u.offp,i[1]^=u.key,i=E(i,0,o,t),t[h]=i[0],t[h+1]=i[1];},U=(n,r,o,t,e)=>{const l=k.slice(),s=l.length;if(o<4||o>31){const c=new Error(`Illegal number of rounds (4-31): ${o}`);if(t===!1)return Promise.reject(c);throw c}if(r.length!==I){const c=new Error(`Illegal salt length: ${r.length} != ${I}`);if(t===!1)return Promise.reject(c);throw c}o=1<<o>>>0;let i,u,h=0,p;Int32Array?(i=new Int32Array(_),u=new Int32Array(P)):(i=_.slice(),u=P.slice()),X(r,n,i,u);const a=()=>{if(e&&e(h/o),h<o){const c=Date.now();for(;h<o&&(h=h+1,j(n,i,u),j(r,i,u),!(Date.now()-c>F)););}else {for(h=0;h<64;h++)for(p=0;p<s>>1;p++)E(l,p<<1,i,u);const c=[];for(h=0;h<s;h++)c.push((l[h]>>24&255)>>>0),c.push((l[h]>>16&255)>>>0),c.push((l[h]>>8&255)>>>0),c.push((l[h]&255)>>>0);return t===!1?Promise.resolve(c):c}if(t===!1)return new Promise(c=>A(()=>{a().then(c);}))};if(t===!1)return a();{let c;for(;;)if(typeof(c=a())<"u")return c||[]}},H=n=>randomBytes$1(n),C=(n=$)=>{if(typeof n!="number")throw Error("Illegal arguments: "+typeof n);n<4?n=4:n>31&&(n=31);const r=[];return r.push("$2a$"),n<10&&r.push("0"),r.push(n.toString()),r.push("$"),r.push(b(H(I),I)),r.join("")},x=(n=$)=>{if(typeof n!="number")throw Error("illegal arguments: "+typeof n);return new Promise((r,o)=>A(()=>{try{r(C(n));}catch(t){o(t);}}))};function T(n,r,o,t){if(typeof n!="string"||typeof r!="string"){const g=new Error("Invalid string / salt: Not a string");if(o===!1)return Promise.reject(g);throw g}let e,l;if(r.charAt(0)!=="$"||r.charAt(1)!=="2"){const g=new Error("Invalid salt version: "+r.substring(0,2));if(o===!1)return Promise.reject(g);throw g}if(r.charAt(2)==="$")e=String.fromCharCode(0),l=3;else {if(e=r.charAt(2),e!=="a"&&e!=="b"&&e!=="y"||r.charAt(3)!=="$"){const g=Error("Invalid salt revision: "+r.substring(2,4));if(o===!1)return Promise.reject(g);throw g}l=4;}if(r.charAt(l+2)>"$"){const g=new Error("Missing salt rounds");if(o===!1)return Promise.reject(g);throw g}const s=parseInt(r.substring(l,l+1),10)*10,i=parseInt(r.substring(l+1,l+2),10),u=s+i,h=r.substring(l+3,l+25);n+=e>="a"?"\0":"";const p=M(n),a=R(h,I),c=g=>{const y=[];return y.push("$2"),e>="a"&&y.push(e),y.push("$"),u<10&&y.push("0"),y.push(u.toString()),y.push("$"),y.push(b(a,a.length)),y.push(b(g,k.length*4-1)),y.join("")};return o===!1?U(p,a,u,!1,t).then(g=>c(g)):c(U(p,a,u,!0,t))}const B=function(n,r,o){return typeof n=="string"&&typeof r=="number"?x(r).then(t=>T(n,t,!1,o)):typeof n=="string"&&typeof r=="string"?T(n,r,!1,o):Promise.reject(new Error(`Illegal arguments: ${typeof n}, ${typeof r}`))},Y=(n,r,o)=>new Promise((t,e)=>{if(typeof n!="string"||typeof r!="string"){A(()=>e(new Error(`Illegal arguments: ${typeof n}, ${typeof r}`)));return}if(r.length!==60){A(()=>e(!1));return}B(n,r.substring(0,29),o).then(l=>t(l===r)).catch(l=>e(l));});
 
-const prisma = new client$1.PrismaClient({
+const prisma = new PrismaClient({
   datasources: {
     db: {
       url: `${config.database}`
@@ -83269,7 +82828,7 @@ const parseFields = async (server) => {
     }
   }
   if (server.password) {
-    server.password = await bcryptjsExports.hash(server.password, 8);
+    server.password = await B(server.password, 8);
   }
 };
 prisma.$use(async (params, next) => {
@@ -83308,7 +82867,7 @@ const queryOrder = async () => {
     }
   });
   isInitial = false;
-  return updateCacheOrder((order == null ? void 0 : order.value) || "");
+  return updateCacheOrder(order?.value || "");
 };
 async function updateOrder(order, Prisma = prisma) {
   const shouldEmit = Prisma === prisma;
@@ -83333,7 +82892,7 @@ async function readServerPassword(username) {
       username
     }
   });
-  return (item == null ? void 0 : item.password) || null;
+  return item?.password || null;
 }
 async function readServersList() {
   const queries = [prisma.server.findMany()];
@@ -83507,462 +83066,6 @@ router$1.get("/events", queryEvents);
 router$1.delete("/events/:id?", removeEvent);
 router$1.get("/config", queryConfig);
 
-var cjs = {};
-
-Object.defineProperty(cjs, '__esModule', { value: true });
-
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-
-  _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _construct(Parent, args, Class) {
-  if (_isNativeReflectConstruct()) {
-    _construct = Reflect.construct;
-  } else {
-    _construct = function _construct(Parent, args, Class) {
-      var a = [null];
-      a.push.apply(a, args);
-      var Constructor = Function.bind.apply(Parent, a);
-      var instance = new Constructor();
-      if (Class) _setPrototypeOf(instance, Class.prototype);
-      return instance;
-    };
-  }
-
-  return _construct.apply(null, arguments);
-}
-
-function _isNativeFunction(fn) {
-  return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-
-function _wrapNativeSuper(Class) {
-  var _cache = typeof Map === "function" ? new Map() : undefined;
-
-  _wrapNativeSuper = function _wrapNativeSuper(Class) {
-    if (Class === null || !_isNativeFunction(Class)) return Class;
-
-    if (typeof Class !== "function") {
-      throw new TypeError("Super expression must either be null or a function");
-    }
-
-    if (typeof _cache !== "undefined") {
-      if (_cache.has(Class)) return _cache.get(Class);
-
-      _cache.set(Class, Wrapper);
-    }
-
-    function Wrapper() {
-      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
-    }
-
-    Wrapper.prototype = Object.create(Class.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    return _setPrototypeOf(Wrapper, Class);
-  };
-
-  return _wrapNativeSuper(Class);
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-var _ref, _Symbol$asyncIterator;
-
-/* eslint-disable unicorn/custom-error-definition, promise/always-return */
-
-/* global setImmediate:false, clearImmediate:false */
-var symbolAsyncIterator = (_ref = (_Symbol$asyncIterator = Symbol == null ? void 0 : Symbol.asyncIterator) != null ? _Symbol$asyncIterator : Symbol == null ? void 0 : Symbol.iterator) != null ? _ref : '@@asyncIterator';
-
-var ERR_INVALID_ARG_TYPE = /*#__PURE__*/function (_Error) {
-  _inheritsLoose(ERR_INVALID_ARG_TYPE, _Error);
-
-  function ERR_INVALID_ARG_TYPE(name, expected, actual) {
-    var _this;
-
-    _this = _Error.call(this, name + " must be " + expected + ", " + typeof actual + " given") || this;
-    _this.name = _this.constructor.name;
-    _this.message = name + " must be " + expected + ", " + typeof actual + " given";
-
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(_assertThisInitialized(_this), _this.constructor);
-    } else {
-      _this.stack = new Error(name + " must be " + expected + ", " + typeof actual + " given").stack;
-    }
-
-    _this.code = 'ERR_INVALID_ARG_TYPE';
-    return _this;
-  }
-
-  return ERR_INVALID_ARG_TYPE;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-var AbortError$1 = /*#__PURE__*/function (_Error2) {
-  _inheritsLoose(AbortError, _Error2);
-
-  function AbortError() {
-    var _this2;
-
-    _this2 = _Error2.call(this, 'The operation was aborted') || this;
-    _this2.name = _this2.constructor.name;
-    _this2.message = 'The operation was aborted';
-
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(_assertThisInitialized(_this2), _this2.constructor);
-    } else {
-      _this2.stack = new Error('The operation was aborted').stack;
-    }
-
-    _this2.code = 'ABORT_ERR';
-    return _this2;
-  }
-
-  return AbortError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-function validateObject(object, name) {
-  if (object === null || typeof object !== 'object') {
-    throw new ERR_INVALID_ARG_TYPE(name, 'Object', object);
-  }
-}
-
-function validateBoolean(value, name) {
-  if (typeof value !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value);
-  }
-}
-
-function validateAbortSignal(signal, name) {
-  if (typeof signal !== 'undefined' && (signal === null || typeof signal !== 'object' || !('aborted' in signal))) {
-    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal);
-  }
-}
-
-function asyncIterator(_ref2) {
-  var nextFunction = _ref2.next,
-      returnFunction = _ref2["return"];
-  var result = {};
-
-  if (typeof nextFunction === 'function') {
-    result.next = nextFunction;
-  }
-
-  if (typeof returnFunction === 'function') {
-    result["return"] = returnFunction;
-  }
-
-  result[symbolAsyncIterator] = function () {
-    return this;
-  };
-
-  return result;
-}
-
-function setTimeoutPromise(after, value, options) {
-  if (after === void 0) {
-    after = 1;
-  }
-
-  if (options === void 0) {
-    options = {};
-  }
-
-  var arguments_ = [].concat(value != null ? value : []);
-
-  try {
-    validateObject(options, 'options');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  var _options = options,
-      signal = _options.signal,
-      _options$ref = _options.ref,
-      reference = _options$ref === void 0 ? true : _options$ref;
-
-  try {
-    validateAbortSignal(signal, 'options.signal');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  try {
-    validateBoolean(reference, 'options.ref');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  if (signal != null && signal.aborted) {
-    return Promise.reject(new AbortError$1());
-  }
-
-  var onCancel;
-  var returnValue = new Promise(function (resolve, reject) {
-    var timeout = setTimeout.apply(void 0, [function () {
-      return resolve(value);
-    }, after].concat(arguments_));
-
-    if (!reference) {
-      timeout == null ? void 0 : timeout.unref == null ? void 0 : timeout.unref();
-    }
-
-    if (signal) {
-      onCancel = function onCancel() {
-        clearTimeout(timeout);
-        reject(new AbortError$1());
-      };
-
-      signal.addEventListener('abort', onCancel);
-    }
-  });
-
-  if (typeof onCancel !== 'undefined') {
-    returnValue["finally"](function () {
-      return signal.removeEventListener('abort', onCancel);
-    });
-  }
-
-  return returnValue;
-}
-
-function setImmediatePromise(value, options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  try {
-    validateObject(options, 'options');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  var _options2 = options,
-      signal = _options2.signal,
-      _options2$ref = _options2.ref,
-      reference = _options2$ref === void 0 ? true : _options2$ref;
-
-  try {
-    validateAbortSignal(signal, 'options.signal');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  try {
-    validateBoolean(reference, 'options.ref');
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  if (signal != null && signal.aborted) {
-    return Promise.reject(new AbortError$1());
-  }
-
-  var onCancel;
-  var returnValue = new Promise(function (resolve, reject) {
-    var immediate = setImmediate(function () {
-      return resolve(value);
-    });
-
-    if (!reference) {
-      immediate == null ? void 0 : immediate.unref == null ? void 0 : immediate.unref();
-    }
-
-    if (signal) {
-      onCancel = function onCancel() {
-        clearImmediate(immediate);
-        reject(new AbortError$1());
-      };
-
-      signal.addEventListener('abort', onCancel);
-    }
-  });
-
-  if (typeof onCancel !== 'undefined') {
-    returnValue["finally"](function () {
-      return signal.removeEventListener('abort', onCancel);
-    });
-  }
-
-  return returnValue;
-}
-
-function setIntervalPromise(after, value, options) {
-  if (after === void 0) {
-    after = 1;
-  }
-
-  if (options === void 0) {
-    options = {};
-  }
-
-  /* eslint-disable no-undefined, no-unreachable-loop, no-loop-func */
-  try {
-    validateObject(options, 'options');
-  } catch (error) {
-    return asyncIterator({
-      next: function next() {
-        return Promise.reject(error);
-      }
-    });
-  }
-
-  var _options3 = options,
-      signal = _options3.signal,
-      _options3$ref = _options3.ref,
-      reference = _options3$ref === void 0 ? true : _options3$ref;
-
-  try {
-    validateAbortSignal(signal, 'options.signal');
-  } catch (error) {
-    return asyncIterator({
-      next: function next() {
-        return Promise.reject(error);
-      }
-    });
-  }
-
-  try {
-    validateBoolean(reference, 'options.ref');
-  } catch (error) {
-    return asyncIterator({
-      next: function next() {
-        return Promise.reject(error);
-      }
-    });
-  }
-
-  if (signal != null && signal.aborted) {
-    return asyncIterator({
-      next: function next() {
-        return Promise.reject(new AbortError$1());
-      }
-    });
-  }
-
-  var onCancel, interval;
-
-  try {
-    var notYielded = 0;
-    var callback;
-    interval = setInterval(function () {
-      notYielded++;
-
-      if (callback) {
-        callback();
-        callback = undefined;
-      }
-    }, after);
-
-    if (!reference) {
-      var _interval;
-
-      (_interval = interval) == null ? void 0 : _interval.unref == null ? void 0 : _interval.unref();
-    }
-
-    if (signal) {
-      onCancel = function onCancel() {
-        clearInterval(interval);
-
-        if (callback) {
-          callback();
-          callback = undefined;
-        }
-      };
-
-      signal.addEventListener('abort', onCancel);
-    }
-
-    return asyncIterator({
-      next: function next() {
-        return new Promise(function (resolve, reject) {
-          if (!(signal != null && signal.aborted)) {
-            if (notYielded === 0) {
-              callback = resolve;
-            } else {
-              resolve();
-            }
-          } else if (notYielded === 0) {
-            reject(new AbortError$1());
-          } else {
-            resolve();
-          }
-        }).then(function () {
-          if (notYielded > 0) {
-            notYielded = notYielded - 1;
-            return {
-              done: false,
-              value: value
-            };
-          }
-
-          return {
-            done: true
-          };
-        });
-      },
-      "return": function _return() {
-        clearInterval(interval);
-        signal == null ? void 0 : signal.removeEventListener('abort', onCancel);
-        return Promise.resolve({});
-      }
-    });
-  } catch (error) {
-    return asyncIterator({
-      next: function next() {
-        clearInterval(interval);
-        signal == null ? void 0 : signal.removeEventListener('abort', onCancel);
-      }
-    });
-  }
-}
-
-cjs.setImmediate = setImmediatePromise;
-cjs.setInterval = setIntervalPromise;
-cjs.setTimeout = setTimeoutPromise;
-
 var bufferUtilExports = {};
 var bufferUtil$1 = {
   get exports(){ return bufferUtilExports; },
@@ -86450,7 +85553,7 @@ const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
  *
  * @extends EventEmitter
  */
-let WebSocket$2 = class WebSocket extends EventEmitter$1 {
+let WebSocket$1 = class WebSocket extends EventEmitter$1 {
   /**
    * Create a new `WebSocket`.
    *
@@ -86902,7 +86005,7 @@ let WebSocket$2 = class WebSocket extends EventEmitter$1 {
  * @constant {Number} CONNECTING
  * @memberof WebSocket
  */
-Object.defineProperty(WebSocket$2, 'CONNECTING', {
+Object.defineProperty(WebSocket$1, 'CONNECTING', {
   enumerable: true,
   value: readyStates.indexOf('CONNECTING')
 });
@@ -86911,7 +86014,7 @@ Object.defineProperty(WebSocket$2, 'CONNECTING', {
  * @constant {Number} CONNECTING
  * @memberof WebSocket.prototype
  */
-Object.defineProperty(WebSocket$2.prototype, 'CONNECTING', {
+Object.defineProperty(WebSocket$1.prototype, 'CONNECTING', {
   enumerable: true,
   value: readyStates.indexOf('CONNECTING')
 });
@@ -86920,7 +86023,7 @@ Object.defineProperty(WebSocket$2.prototype, 'CONNECTING', {
  * @constant {Number} OPEN
  * @memberof WebSocket
  */
-Object.defineProperty(WebSocket$2, 'OPEN', {
+Object.defineProperty(WebSocket$1, 'OPEN', {
   enumerable: true,
   value: readyStates.indexOf('OPEN')
 });
@@ -86929,7 +86032,7 @@ Object.defineProperty(WebSocket$2, 'OPEN', {
  * @constant {Number} OPEN
  * @memberof WebSocket.prototype
  */
-Object.defineProperty(WebSocket$2.prototype, 'OPEN', {
+Object.defineProperty(WebSocket$1.prototype, 'OPEN', {
   enumerable: true,
   value: readyStates.indexOf('OPEN')
 });
@@ -86938,7 +86041,7 @@ Object.defineProperty(WebSocket$2.prototype, 'OPEN', {
  * @constant {Number} CLOSING
  * @memberof WebSocket
  */
-Object.defineProperty(WebSocket$2, 'CLOSING', {
+Object.defineProperty(WebSocket$1, 'CLOSING', {
   enumerable: true,
   value: readyStates.indexOf('CLOSING')
 });
@@ -86947,7 +86050,7 @@ Object.defineProperty(WebSocket$2, 'CLOSING', {
  * @constant {Number} CLOSING
  * @memberof WebSocket.prototype
  */
-Object.defineProperty(WebSocket$2.prototype, 'CLOSING', {
+Object.defineProperty(WebSocket$1.prototype, 'CLOSING', {
   enumerable: true,
   value: readyStates.indexOf('CLOSING')
 });
@@ -86956,7 +86059,7 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSING', {
  * @constant {Number} CLOSED
  * @memberof WebSocket
  */
-Object.defineProperty(WebSocket$2, 'CLOSED', {
+Object.defineProperty(WebSocket$1, 'CLOSED', {
   enumerable: true,
   value: readyStates.indexOf('CLOSED')
 });
@@ -86965,7 +86068,7 @@ Object.defineProperty(WebSocket$2, 'CLOSED', {
  * @constant {Number} CLOSED
  * @memberof WebSocket.prototype
  */
-Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
+Object.defineProperty(WebSocket$1.prototype, 'CLOSED', {
   enumerable: true,
   value: readyStates.indexOf('CLOSED')
 });
@@ -86979,7 +86082,7 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
   'readyState',
   'url'
 ].forEach((property) => {
-  Object.defineProperty(WebSocket$2.prototype, property, { enumerable: true });
+  Object.defineProperty(WebSocket$1.prototype, property, { enumerable: true });
 });
 
 //
@@ -86987,7 +86090,7 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
 // See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
 //
 ['open', 'error', 'close', 'message'].forEach((method) => {
-  Object.defineProperty(WebSocket$2.prototype, `on${method}`, {
+  Object.defineProperty(WebSocket$1.prototype, `on${method}`, {
     enumerable: true,
     get() {
       for (const listener of this.listeners(method)) {
@@ -87013,10 +86116,10 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
   });
 });
 
-WebSocket$2.prototype.addEventListener = addEventListener;
-WebSocket$2.prototype.removeEventListener = removeEventListener;
+WebSocket$1.prototype.addEventListener = addEventListener;
+WebSocket$1.prototype.removeEventListener = removeEventListener;
 
-var websocket = WebSocket$2;
+var websocket = WebSocket$1;
 
 /**
  * Initialize a WebSocket client.
@@ -87309,7 +86412,7 @@ function initAsClient(websocket, address, protocols, options) {
     // The user may have closed the connection from a listener of the
     // `'upgrade'` event.
     //
-    if (websocket.readyState !== WebSocket$2.CONNECTING) return;
+    if (websocket.readyState !== WebSocket$1.CONNECTING) return;
 
     req = websocket._req = null;
 
@@ -87409,7 +86512,7 @@ function initAsClient(websocket, address, protocols, options) {
  * @private
  */
 function emitErrorAndClose(websocket, err) {
-  websocket._readyState = WebSocket$2.CLOSING;
+  websocket._readyState = WebSocket$1.CLOSING;
   websocket.emit('error', err);
   websocket.emitClose();
 }
@@ -87453,7 +86556,7 @@ function tlsConnect(options) {
  * @private
  */
 function abortHandshake$1(websocket, stream, message) {
-  websocket._readyState = WebSocket$2.CLOSING;
+  websocket._readyState = WebSocket$1.CLOSING;
 
   const err = new Error(message);
   Error.captureStackTrace(err, abortHandshake$1);
@@ -87634,7 +86737,7 @@ function socketOnClose() {
   this.removeListener('data', socketOnData);
   this.removeListener('end', socketOnEnd);
 
-  websocket._readyState = WebSocket$2.CLOSING;
+  websocket._readyState = WebSocket$1.CLOSING;
 
   let chunk;
 
@@ -87693,7 +86796,7 @@ function socketOnData(chunk) {
 function socketOnEnd() {
   const websocket = this[kWebSocket$1];
 
-  websocket._readyState = WebSocket$2.CLOSING;
+  websocket._readyState = WebSocket$1.CLOSING;
   websocket._receiver.end();
   this.end();
 }
@@ -87710,169 +86813,11 @@ function socketOnError$1() {
   this.on('error', NOOP);
 
   if (websocket) {
-    websocket._readyState = WebSocket$2.CLOSING;
-    this.destroy();
-  }
-}
-
-const { Duplex } = Stream$7;
-
-/**
- * Emits the `'close'` event on a stream.
- *
- * @param {Duplex} stream The stream.
- * @private
- */
-function emitClose$1(stream) {
-  stream.emit('close');
-}
-
-/**
- * The listener of the `'end'` event.
- *
- * @private
- */
-function duplexOnEnd() {
-  if (!this.destroyed && this._writableState.finished) {
+    websocket._readyState = WebSocket$1.CLOSING;
     this.destroy();
   }
 }
 
-/**
- * The listener of the `'error'` event.
- *
- * @param {Error} err The error
- * @private
- */
-function duplexOnError(err) {
-  this.removeListener('error', duplexOnError);
-  this.destroy();
-  if (this.listenerCount('error') === 0) {
-    // Do not suppress the throwing behavior.
-    this.emit('error', err);
-  }
-}
-
-/**
- * Wraps a `WebSocket` in a duplex stream.
- *
- * @param {WebSocket} ws The `WebSocket` to wrap
- * @param {Object} [options] The options for the `Duplex` constructor
- * @return {Duplex} The duplex stream
- * @public
- */
-function createWebSocketStream(ws, options) {
-  let terminateOnDestroy = true;
-
-  const duplex = new Duplex({
-    ...options,
-    autoDestroy: false,
-    emitClose: false,
-    objectMode: false,
-    writableObjectMode: false
-  });
-
-  ws.on('message', function message(msg, isBinary) {
-    const data =
-      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
-
-    if (!duplex.push(data)) ws.pause();
-  });
-
-  ws.once('error', function error(err) {
-    if (duplex.destroyed) return;
-
-    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-    //
-    // - If the `'error'` event is emitted before the `'open'` event, then
-    //   `ws.terminate()` is a noop as no socket is assigned.
-    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-    //   event of the `Receiver` object. The listener already closes the
-    //   connection by calling `ws.close()`. This allows a close frame to be
-    //   sent to the other peer. If `ws.terminate()` is called right after this,
-    //   then the close frame might not be sent.
-    terminateOnDestroy = false;
-    duplex.destroy(err);
-  });
-
-  ws.once('close', function close() {
-    if (duplex.destroyed) return;
-
-    duplex.push(null);
-  });
-
-  duplex._destroy = function (err, callback) {
-    if (ws.readyState === ws.CLOSED) {
-      callback(err);
-      process.nextTick(emitClose$1, duplex);
-      return;
-    }
-
-    let called = false;
-
-    ws.once('error', function error(err) {
-      called = true;
-      callback(err);
-    });
-
-    ws.once('close', function close() {
-      if (!called) callback(err);
-      process.nextTick(emitClose$1, duplex);
-    });
-
-    if (terminateOnDestroy) ws.terminate();
-  };
-
-  duplex._final = function (callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once('open', function open() {
-        duplex._final(callback);
-      });
-      return;
-    }
-
-    // If the value of the `_socket` property is `null` it means that `ws` is a
-    // client websocket and the handshake failed. In fact, when this happens, a
-    // socket is never assigned to the websocket. Wait for the `'error'` event
-    // that will be emitted by the websocket.
-    if (ws._socket === null) return;
-
-    if (ws._socket._writableState.finished) {
-      callback();
-      if (duplex._readableState.endEmitted) duplex.destroy();
-    } else {
-      ws._socket.once('finish', function finish() {
-        // `duplex` is not destroyed here because the `'end'` event will be
-        // emitted on `duplex` after this `'finish'` event. The EOF signaling
-        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
-        callback();
-      });
-      ws.close();
-    }
-  };
-
-  duplex._read = function () {
-    if (ws.isPaused) ws.resume();
-  };
-
-  duplex._write = function (chunk, encoding, callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once('open', function open() {
-        duplex._write(chunk, encoding, callback);
-      });
-      return;
-    }
-
-    ws.send(chunk, callback);
-  };
-
-  duplex.on('end', duplexOnEnd);
-  duplex.on('error', duplexOnError);
-  return duplex;
-}
-
-var stream$1 = createWebSocketStream;
-
 const { tokenChars } = validationExports;
 
 /**
@@ -87943,7 +86888,7 @@ const { createHash } = require$$0$a;
 const extension = extension$1;
 const PerMessageDeflate = permessageDeflate;
 const subprotocol = subprotocol$1;
-const WebSocket$1 = websocket;
+const WebSocket = websocket;
 const { GUID, kWebSocket } = constants;
 
 const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
@@ -88000,7 +86945,7 @@ class WebSocketServer extends EventEmitter {
       host: null,
       path: null,
       port: null,
-      WebSocket: WebSocket$1,
+      WebSocket,
       ...options
     };
 
@@ -88465,18 +87410,6 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
   }
 }
 
-const WebSocket = websocket;
-
-WebSocket.createWebSocketStream = stream$1;
-WebSocket.Server = websocketServer;
-WebSocket.Receiver = receiver;
-WebSocket.Sender = sender;
-
-WebSocket.WebSocket = WebSocket;
-WebSocket.WebSocketServer = WebSocket.Server;
-
-var ws = WebSocket;
-
 // Integer Utility
 var UINT32_MAX = 4294967295;
 function setInt64(view, offset, value) {
@@ -89817,6 +88750,7 @@ var ipaddr = {
 	                [new IPv4([192, 0, 0, 0]), 24],
 	                [new IPv4([192, 0, 2, 0]), 24],
 	                [new IPv4([192, 88, 99, 0]), 24],
+	                [new IPv4([198, 18, 0, 0]), 15],
 	                [new IPv4([198, 51, 100, 0]), 24],
 	                [new IPv4([203, 0, 113, 0]), 24],
 	                [new IPv4([240, 0, 0, 0]), 4]
@@ -90159,7 +89093,12 @@ var ipaddr = {
 	            // RFC6052, RFC6146
 	            teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32],
 	            // RFC4291
-	            reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]]
+	            reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]],
+	            benchmarking: [new IPv6([0x2001, 0x2, 0, 0, 0, 0, 0, 0]), 48],
+	            amt: [new IPv6([0x2001, 0x3, 0, 0, 0, 0, 0, 0]), 32],
+	            as112v6: [new IPv6([0x2001, 0x4, 0x112, 0, 0, 0, 0, 0]), 48],
+	            deprecated: [new IPv6([0x2001, 0x10, 0, 0, 0, 0, 0, 0]), 28],
+	            orchid2: [new IPv6([0x2001, 0x20, 0, 0, 0, 0, 0, 0]), 28]
 	        };
 
 	        // Checks if this address is an IPv4-mapped IPv6 address.
@@ -90344,11 +89283,9 @@ var ipaddr = {
 
 	        // Returns the address in compact, human-readable format like
 	        // 2001:db8:8:66::1
-	        //
-	        // Deprecated: use toRFC5952String() instead.
+	        // Calls toRFC5952String under the hood.
 	        IPv6.prototype.toString = function () {
-	            // Replace the first sequence of 1 or more '0' parts with '::'
-	            return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
+	            return this.toRFC5952String();
 	        };
 
 	        return IPv6;
@@ -90623,7 +89560,7 @@ async function authServer(username, password) {
   const res = await handleRequest(readServerPassword(username));
   if (res.code || !res.data)
     return false;
-  return bcryptjsExports.compare(password, res.data);
+  return Y(password, res.data);
 }
 function addServer(obj) {
   return handleRequest(createServer(obj));
@@ -90686,10 +89623,11 @@ function setupHeartbeat(io, pingInterval) {
   }, pingInterval * 1e3);
 }
 
-const loggerConnected = log4js_1.getLogger("Connected");
-const loggerConnecting = log4js_1.getLogger("Connecting");
-const loggerDisconnected = log4js_1.getLogger("Disconnected");
-const loggerBanned = log4js_1.getLogger("Banned");
+const { getLogger } = log4js_1;
+const loggerConnected = getLogger("Connected");
+const loggerConnecting = getLogger("Connecting");
+const loggerDisconnected = getLogger("Disconnected");
+const loggerBanned = getLogger("Banned");
 function callHook(instance, hook, ...args) {
   try {
     if (typeof instance[hook] === "function") {
@@ -90700,15 +89638,23 @@ function callHook(instance, hook, ...args) {
   }
 }
 class NodeStatus {
+  options;
+  server;
+  ioPub = new websocketServer({ noServer: true });
+  ioConn = new websocketServer({ noServer: true });
+  /* username -> socket */
+  userMap = /* @__PURE__ */ new Map();
+  /* ip -> banned */
+  isBanned = /* @__PURE__ */ new Map();
+  servers = {};
+  serversPub = [];
+  onServerConnect;
+  onServerBanned;
+  onServerConnected;
+  onServerDisconnected;
+  _serverConnectedPush;
+  _serverDisconnectedPush;
   constructor(server, options) {
-    this.ioPub = new ws.Server({ noServer: true });
-    this.ioConn = new ws.Server({ noServer: true });
-    /* username -> socket */
-    this.userMap = /* @__PURE__ */ new Map();
-    /* ip -> banned */
-    this.isBanned = /* @__PURE__ */ new Map();
-    this.servers = {};
-    this.serversPub = [];
     this.server = server;
     this.options = options;
     emitter.on("update", this.updateStatus.bind(this));
@@ -90729,14 +89675,13 @@ class NodeStatus {
     this.server.on("upgrade", (request, socket, head) => {
       const pathname = request.url;
       if (pathname === "/connect") {
-        this.ioConn.handleUpgrade(request, socket, head, (ws2) => {
-          var _a, _b, _c;
-          ws2.ipAddress = ((_c = (_b = (_a = request.headers["x-forwarded-for"]) == null ? void 0 : _a.split(",")) == null ? void 0 : _b[0]) == null ? void 0 : _c.trim()) || request.socket.remoteAddress;
-          this.ioConn.emit("connection", ws2);
+        this.ioConn.handleUpgrade(request, socket, head, (ws) => {
+          ws.ipAddress = request.headers["x-forwarded-for"]?.split(",")?.[0]?.trim() || request.socket.remoteAddress;
+          this.ioConn.emit("connection", ws);
         });
       } else if (pathname === "/public") {
-        this.ioPub.handleUpgrade(request, socket, head, (ws2) => {
-          this.ioPub.emit("connection", ws2);
+        this.ioPub.handleUpgrade(request, socket, head, (ws) => {
+          this.ioPub.emit("connection", ws);
         });
       } else {
         socket.destroy();
@@ -90751,7 +89696,6 @@ class NodeStatus {
       socket.send("Authentication required");
       loggerConnecting.debug(`Address: ${address}`);
       socket.once("message", async (buf) => {
-        var _a;
         if (this.isBanned.get(address)) {
           socket.send("You are banned. Please try connecting after 60 / 120 seconds");
           return socket.close();
@@ -90765,7 +89709,7 @@ class NodeStatus {
             socket.send("Wrong username and/or password.");
             return this.setBan(socket, address, 120, "Wrong username and/or password.");
           }
-          if (Object.keys(((_a = this.servers[username]) == null ? void 0 : _a.status) || {}).length) {
+          if (Object.keys(this.servers[username]?.status || {}).length) {
             const preSocket = this.userMap.get(username);
             if (preSocket) {
               if (preSocket.ipAddress === address) {
@@ -90774,7 +89718,7 @@ class NodeStatus {
                 preSocket.isAlive = false;
                 preSocket.ping();
                 const ac = new AbortController();
-                const promise = cjs.setTimeout((pingInterval + 5) * 1e3, null, { signal: ac.signal });
+                const promise = timers.setTimeout((pingInterval + 5) * 1e3, null, { signal: ac.signal });
                 preSocket.on("close", () => ac.abort());
                 try {
                   await promise;
@@ -90795,7 +89739,7 @@ class NodeStatus {
         }
         socket.send("Authentication successful. Access granted.");
         let ipType = "IPv6";
-        if (require$$1$4.isIPv4(address) || ipaddrExports.IPv6.parse(address).isIPv4MappedAddress()) {
+        if (isIPv4(address) || ipaddrExports.IPv6.parse(address).isIPv4MappedAddress()) {
           ipType = "IPv4";
         }
         socket.send(`You are connecting via: ${ipType}`);
@@ -90826,14 +89770,13 @@ class NodeStatus {
     return this.updateStatus();
   }
   async updateStatus(username, shouldDisconnect = false) {
-    var _a, _b, _c;
     if (username) {
       const server = (await getServer(username)).data;
       if (!server)
         delete this.servers[username];
       else
-        this.servers[username] = Object.assign(server, { status: ((_b = (_a = this.servers) == null ? void 0 : _a[username]) == null ? void 0 : _b.status) || {} });
-      shouldDisconnect && ((_c = this.userMap.get(username)) == null ? void 0 : _c.terminate()) && this.userMap.delete(username);
+        this.servers[username] = Object.assign(server, { status: this.servers?.[username]?.status || {} });
+      shouldDisconnect && this.userMap.get(username)?.terminate() && this.userMap.delete(username);
     } else {
       const box = (await getListServers()).data;
       if (!box)
@@ -175168,7 +174111,7 @@ function __rest(s, e) {
  * Handles Readable streams requests as concatenation through data handling as
  * well adding tags it each begin, end and between of the streams
  */
-class SandwichStream extends Stream$7.Readable {
+class SandwichStream extends Readable$1 {
     /**
      * Initiates the SandwichStream, you can consider it also passing
      * ReadableOptions to it
@@ -177752,7 +176695,7 @@ function createPush(options) {
   const parseEntities = (msg) => {
     let str;
     if (typeof msg !== "string")
-      str = (msg == null ? void 0 : msg.toString()) || "";
+      str = msg?.toString() || "";
     else
       str = msg;
     let newStr = "";
@@ -177806,7 +176749,7 @@ function createPush(options) {
 ${str}`;
   };
   const tgConfig = options.telegram;
-  if (tgConfig == null ? void 0 : tgConfig.bot_token) {
+  if (tgConfig?.bot_token) {
     const bot = new lib$2.Telegraf(tgConfig.bot_token, {
       ...tgConfig.proxy && {
         telegram: {
@@ -177850,7 +176793,7 @@ Please check your settings\\.`, { parse_mode: "MarkdownV2" });
       const secretPath = `/telegraf/${bot.secretPathComponent()}`;
       bot.telegram.setWebhook(`${tgConfig.web_hook}${secretPath}`).then(() => logger.info("\u{1F916} Telegram Bot is running using webhook"));
       this.server.on("request", (req, res) => {
-        if (req.url && req.url.length === secretPath.length && require$$0$a.timingSafeEqual(Buffer.from(secretPath), Buffer.from(req.url))) {
+        if (req.url && req.url.length === secretPath.length && timingSafeEqual(Buffer.from(secretPath), Buffer.from(req.url))) {
           bot.webhookCallback(secretPath)(req, res);
           res.statusCode = 200;
         }
@@ -177881,17 +176824,14 @@ Please check your settings\\.`, { parse_mode: "MarkdownV2" });
     const timer = setTimeout(
       () => {
         Promise.all(pushList.map(
-          (fn) => {
-            var _a;
-            return fn(`\u{1F34A}*NodeStatus* 
+          (fn) => fn(`\u{1F34A}*NodeStatus* 
 \u{1F630} One server has disconnected\\! 
 
  *\u7528\u6237\u540D*: ${parseEntities(username)} 
- *\u8282\u70B9\u540D*: ${parseEntities((_a = this.servers[username]) == null ? void 0 : _a.name)} 
- *\u65F6\u95F4*: ${parseEntities(now)}`);
-          }
+ *\u8282\u70B9\u540D*: ${parseEntities(this.servers[username]?.name)} 
+ *\u65F6\u95F4*: ${parseEntities(now)}`)
         )).then();
-        cb == null ? void 0 : cb(now);
+        cb?.(now);
         timerMap.delete(username);
       },
       options.pushTimeOut * 1e3
@@ -177901,7 +176841,7 @@ Please check your settings\\.`, { parse_mode: "MarkdownV2" });
 }
 
 async function createStatus(app) {
-  const server = new require$$2$4.Server(app.callback());
+  const server = new Server(app.callback());
   let ipc = null;
   const instance = new NodeStatus(server, {
     interval: config.interval,
@@ -177939,6 +176879,7 @@ async function createStatus(app) {
   return [server, ipc];
 }
 
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 if (!config.port) {
   logger.fatal("No port specified");
   process.exit(1);
@@ -177947,17 +176888,15 @@ if (config.useWeb && !config.webPassword) {
   logger.fatal("No web password specified");
   process.exit(1);
 }
-(async () => {
-  const app = new Koa();
-  app.use(historyApiFallback_1({
-    whiteList: ["/admin/assets", "/telegraf"],
-    rewrites: [
-      { from: /^\/admin/, to: "/admin/index.html" }
-    ]
-  }));
-  app.use(koaMount("/admin", koaStatic(require$$1$3.resolve(__dirname, "./dist/hotaru-admin"), { maxage: 2592e3 })));
-  app.use(koaStatic(require$$1$3.resolve(__dirname, `./dist/${config.webTheme}`), { maxage: 2592e3 }));
-  const [server, ipc] = await createStatus(app);
-  server.listen(config.port, () => logger.info(`\u{1F389}  NodeStatus is listening on http://127.0.0.1:${config.port}`));
-  ipc && ipc.listen(config.ipcAddress, () => logger.info(`\u{1F389}  NodeStatus Ipc is listening on ${config.ipcAddress}`));
-})();
+const app = new Koa();
+app.use(historyApiFallback_1({
+  whiteList: ["/admin/assets", "/telegraf"],
+  rewrites: [
+    { from: /^\/admin/, to: "/admin/index.html" }
+  ]
+}));
+app.use(koaMount("/admin", koaStatic(resolve$3(__dirname$1, "./dist/hotaru-admin"), { maxage: 2592e3 })));
+app.use(koaStatic(resolve$3(__dirname$1, `./dist/${config.webTheme}`), { maxage: 2592e3 }));
+const [server, ipc] = await createStatus(app);
+server.listen(config.port, () => logger.info(`\u{1F389}  NodeStatus is listening on http://127.0.0.1:${config.port}`));
+ipc && ipc.listen(config.ipcAddress, () => logger.info(`\u{1F389}  NodeStatus Ipc is listening on ${config.ipcAddress}`));