npm - @andersbakken/fisk - Versions diffs - 4.0.29 → 4.0.31 - Mend

@andersbakken/fisk 4.0.29 → 4.0.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/builder/fisk-builder.js +3117 -3117
package/monitor/fisk-monitor.js +348 -335
package/package.json +2 -2
package/scheduler/fisk-scheduler.js +634 -621

package/scheduler/fisk-scheduler.js CHANGED Viewed

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 'use strict';
-var fs$p = require('fs');
+var fs$o = require('fs');
 var assert$1 = require('assert');
 var require$$0$3 = require('constants');
 var require$$0$4 = require('stream');
 var require$$4$1 = require('util');
-var path$l = require('path');
+var path$k = require('path');
 var require$$1$1 = require('os');
 var child_process = require('child_process');
 var require$$0$5 = require('events');
@@ -26,12 +26,12 @@ var posix = require('posix');
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$p);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$o);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert$1);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4$1);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$l);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$k);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
 var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$5);
@@ -231,7 +231,7 @@ var lib$3 = {
   set exports(v){ libExports$1 = v; },
 };
-var fs$o = {};
+var fs$n = {};
 var universalify = {};
@@ -756,7 +756,7 @@ function clone$1 (obj) {
   return copy
 }
-var fs$n = fs__default["default"];
+var fs$m = fs__default["default"];
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone = clone_1;
@@ -798,18 +798,18 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   };
 // Once time initialization
-if (!fs$n[gracefulQueue]) {
+if (!fs$m[gracefulQueue]) {
   // This queue can be shared by multiple loaded instances
   var queue = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs$n, queue);
+  publishQueue(fs$m, 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$n.close = (function (fs$close) {
+  fs$m.close = (function (fs$close) {
     function close (fd, cb) {
-      return fs$close.call(fs$n, fd, function (err) {
+      return fs$close.call(fs$m, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
@@ -824,12 +824,12 @@ if (!fs$n[gracefulQueue]) {
       value: fs$close
     });
     return close
-  })(fs$n.close);
+  })(fs$m.close);
-  fs$n.closeSync = (function (fs$closeSync) {
+  fs$m.closeSync = (function (fs$closeSync) {
     function closeSync (fd) {
       // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs$n, arguments);
+      fs$closeSync.apply(fs$m, arguments);
       resetQueue();
     }
@@ -837,24 +837,24 @@ if (!fs$n[gracefulQueue]) {
       value: fs$closeSync
     });
     return closeSync
-  })(fs$n.closeSync);
+  })(fs$m.closeSync);
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
     process.on('exit', function() {
-      debug$7(fs$n[gracefulQueue]);
-      assert__default["default"].equal(fs$n[gracefulQueue].length, 0);
+      debug$7(fs$m[gracefulQueue]);
+      assert__default["default"].equal(fs$m[gracefulQueue].length, 0);
     });
   }
 }
 if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs$n[gracefulQueue]);
+  publishQueue(commonjsGlobal, fs$m[gracefulQueue]);
 }
-var gracefulFs = patch(clone(fs$n));
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$n.__patched) {
-    gracefulFs = patch(fs$n);
-    fs$n.__patched = true;
+var gracefulFs = patch(clone(fs$m));
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$m.__patched) {
+    gracefulFs = patch(fs$m);
+    fs$m.__patched = true;
 }
 function patch (fs) {
@@ -1128,7 +1128,7 @@ function patch (fs) {
 function enqueue (elem) {
   debug$7('ENQUEUE', elem[0].name, elem[1]);
-  fs$n[gracefulQueue].push(elem);
+  fs$m[gracefulQueue].push(elem);
   retry();
 }
@@ -1140,12 +1140,12 @@ var retryTimer;
 // delay between attempts so that we'll retry these jobs sooner
 function resetQueue () {
   var now = Date.now();
-  for (var i = 0; i < fs$n[gracefulQueue].length; ++i) {
+  for (var i = 0; i < fs$m[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$n[gracefulQueue][i].length > 2) {
-      fs$n[gracefulQueue][i][3] = now; // startTime
-      fs$n[gracefulQueue][i][4] = now; // lastTime
+    if (fs$m[gracefulQueue][i].length > 2) {
+      fs$m[gracefulQueue][i][3] = now; // startTime
+      fs$m[gracefulQueue][i][4] = now; // lastTime
     }
   }
   // call retry to make sure we're actively processing the queue
@@ -1157,10 +1157,10 @@ function retry () {
   clearTimeout(retryTimer);
   retryTimer = undefined;
-  if (fs$n[gracefulQueue].length === 0)
+  if (fs$m[gracefulQueue].length === 0)
     return
-  var elem = fs$n[gracefulQueue].shift();
+  var elem = fs$m[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
   // these items may be unset if they were added by an older graceful-fs
@@ -1195,7 +1195,7 @@ function retry () {
     } 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$n[gracefulQueue].push(elem);
+      fs$m[gracefulQueue].push(elem);
     }
   }
@@ -1308,13 +1308,13 @@ function retry () {
 	    });
 	  })
 	};
-} (fs$o));
+} (fs$n));
-const path$k = path__default["default"];
+const path$j = path__default["default"];
 // get drive on windows
 function getRootPath (p) {
-  p = path$k.normalize(path$k.resolve(p)).split(path$k.sep);
+  p = path$j.normalize(path$j.resolve(p)).split(path$j.sep);
   if (p.length > 0) return p[0]
   return null
 }
@@ -1334,8 +1334,8 @@ var win32 = {
   invalidWin32Path: invalidWin32Path$2
 };
-const fs$m = gracefulFs;
-const path$j = path__default["default"];
+const fs$l = gracefulFs;
+const path$i = path__default["default"];
 const invalidWin32Path$1 = win32.invalidWin32Path;
 const o777$1 = parseInt('0777', 8);
@@ -1355,7 +1355,7 @@ function mkdirs$2 (p, opts, callback, made) {
   }
   let mode = opts.mode;
-  const xfs = opts.fs || fs$m;
+  const xfs = opts.fs || fs$l;
   if (mode === undefined) {
     mode = o777$1 & (~process.umask());
@@ -1363,7 +1363,7 @@ function mkdirs$2 (p, opts, callback, made) {
   if (!made) made = null;
   callback = callback || function () {};
-  p = path$j.resolve(p);
+  p = path$i.resolve(p);
   xfs.mkdir(p, mode, er => {
     if (!er) {
@@ -1372,8 +1372,8 @@ function mkdirs$2 (p, opts, callback, made) {
     }
     switch (er.code) {
       case 'ENOENT':
-        if (path$j.dirname(p) === p) return callback(er)
-        mkdirs$2(path$j.dirname(p), opts, (er, made) => {
+        if (path$i.dirname(p) === p) return callback(er)
+        mkdirs$2(path$i.dirname(p), opts, (er, made) => {
           if (er) callback(er, made);
           else mkdirs$2(p, opts, callback, made);
         });
@@ -1396,8 +1396,8 @@ function mkdirs$2 (p, opts, callback, made) {
 var mkdirs_1$1 = mkdirs$2;
-const fs$l = gracefulFs;
-const path$i = path__default["default"];
+const fs$k = gracefulFs;
+const path$h = path__default["default"];
 const invalidWin32Path = win32.invalidWin32Path;
 const o777 = parseInt('0777', 8);
@@ -1408,7 +1408,7 @@ function mkdirsSync$2 (p, opts, made) {
   }
   let mode = opts.mode;
-  const xfs = opts.fs || fs$l;
+  const xfs = opts.fs || fs$k;
   if (process.platform === 'win32' && invalidWin32Path(p)) {
     const errInval = new Error(p + ' contains invalid WIN32 path characters.');
@@ -1421,15 +1421,15 @@ function mkdirsSync$2 (p, opts, made) {
   }
   if (!made) made = null;
-  p = path$i.resolve(p);
+  p = path$h.resolve(p);
   try {
     xfs.mkdirSync(p, mode);
     made = made || p;
   } catch (err0) {
     if (err0.code === 'ENOENT') {
-      if (path$i.dirname(p) === p) throw err0
-      made = mkdirsSync$2(path$i.dirname(p), opts, made);
+      if (path$h.dirname(p) === p) throw err0
+      made = mkdirsSync$2(path$h.dirname(p), opts, made);
       mkdirsSync$2(p, opts, made);
     } else {
       // In the case of any other error, just see if there's a dir there
@@ -1463,39 +1463,39 @@ var mkdirs_1 = {
   ensureDirSync: mkdirsSync$1
 };
-const fs$k = gracefulFs;
+const fs$j = gracefulFs;
 const os = require$$1__default["default"];
-const path$h = path__default["default"];
+const path$g = path__default["default"];
 // HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
 function hasMillisResSync () {
-  let tmpfile = path$h.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path$h.join(os.tmpdir(), tmpfile);
+  let tmpfile = path$g.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$g.join(os.tmpdir(), tmpfile);
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  fs$k.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
-  const fd = fs$k.openSync(tmpfile, 'r+');
-  fs$k.futimesSync(fd, d, d);
-  fs$k.closeSync(fd);
-  return fs$k.statSync(tmpfile).mtime > 1435410243000
+  fs$j.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
+  const fd = fs$j.openSync(tmpfile, 'r+');
+  fs$j.futimesSync(fd, d, d);
+  fs$j.closeSync(fd);
+  return fs$j.statSync(tmpfile).mtime > 1435410243000
 }
 function hasMillisRes (callback) {
-  let tmpfile = path$h.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path$h.join(os.tmpdir(), tmpfile);
+  let tmpfile = path$g.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$g.join(os.tmpdir(), tmpfile);
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  fs$k.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
+  fs$j.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
     if (err) return callback(err)
-    fs$k.open(tmpfile, 'r+', (err, fd) => {
+    fs$j.open(tmpfile, 'r+', (err, fd) => {
       if (err) return callback(err)
-      fs$k.futimes(fd, d, d, err => {
+      fs$j.futimes(fd, d, d, err => {
         if (err) return callback(err)
-        fs$k.close(fd, err => {
+        fs$j.close(fd, err => {
           if (err) return callback(err)
-          fs$k.stat(tmpfile, (err, stats) => {
+          fs$j.stat(tmpfile, (err, stats) => {
             if (err) return callback(err)
             callback(null, stats.mtime > 1435410243000);
           });
@@ -1517,10 +1517,10 @@ function timeRemoveMillis (timestamp) {
 function utimesMillis (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  fs$k.open(path, 'r+', (err, fd) => {
+  fs$j.open(path, 'r+', (err, fd) => {
     if (err) return callback(err)
-    fs$k.futimes(fd, atime, mtime, futimesErr => {
-      fs$k.close(fd, closeErr => {
+    fs$j.futimes(fd, atime, mtime, futimesErr => {
+      fs$j.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
       });
     });
@@ -1528,9 +1528,9 @@ function utimesMillis (path, atime, mtime, callback) {
 }
 function utimesMillisSync (path, atime, mtime) {
-  const fd = fs$k.openSync(path, 'r+');
-  fs$k.futimesSync(fd, atime, mtime);
-  return fs$k.closeSync(fd)
+  const fd = fs$j.openSync(path, 'r+');
+  fs$j.futimesSync(fd, atime, mtime);
+  return fs$j.closeSync(fd)
 }
 var utimes$1 = {
@@ -1553,8 +1553,8 @@ var buffer$1 = function (size) {
   return new Buffer(size)
 };
-const fs$j = gracefulFs;
-const path$g = path__default["default"];
+const fs$i = gracefulFs;
+const path$f = path__default["default"];
 const mkdirpSync$1 = mkdirs_1.mkdirsSync;
 const utimesSync = utimes$1.utimesMillisSync;
@@ -1580,8 +1580,8 @@ function copySync$2 (src, dest, opts) {
   if (opts.filter && !opts.filter(src, dest)) return
-  const destParent = path$g.dirname(dest);
-  if (!fs$j.existsSync(destParent)) mkdirpSync$1(destParent);
+  const destParent = path$f.dirname(dest);
+  if (!fs$i.existsSync(destParent)) mkdirpSync$1(destParent);
   return startCopy$1(resolvedDest, src, dest, opts)
 }
@@ -1591,7 +1591,7 @@ function startCopy$1 (resolvedDest, src, dest, opts) {
 }
 function getStats$1 (resolvedDest, src, dest, opts) {
-  const statSync = opts.dereference ? fs$j.statSync : fs$j.lstatSync;
+  const statSync = opts.dereference ? fs$i.statSync : fs$i.lstatSync;
   const st = statSync(src);
   if (st.isDirectory()) return onDir$1(st, resolvedDest, src, dest, opts)
@@ -1609,7 +1609,7 @@ function onFile$1 (srcStat, resolvedDest, src, dest, opts) {
 function mayCopyFile$1 (srcStat, src, dest, opts) {
   if (opts.overwrite) {
-    fs$j.unlinkSync(dest);
+    fs$i.unlinkSync(dest);
     return copyFile$1(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
     throw new Error(`'${dest}' already exists`)
@@ -1617,9 +1617,9 @@ function mayCopyFile$1 (srcStat, src, dest, opts) {
 }
 function copyFile$1 (srcStat, src, dest, opts) {
-  if (typeof fs$j.copyFileSync === 'function') {
-    fs$j.copyFileSync(src, dest);
-    fs$j.chmodSync(dest, srcStat.mode);
+  if (typeof fs$i.copyFileSync === 'function') {
+    fs$i.copyFileSync(src, dest);
+    fs$i.chmodSync(dest, srcStat.mode);
     if (opts.preserveTimestamps) {
       return utimesSync(dest, srcStat.atime, srcStat.mtime)
     }
@@ -1632,20 +1632,20 @@ function copyFileFallback$1 (srcStat, src, dest, opts) {
   const BUF_LENGTH = 64 * 1024;
   const _buff = buffer$1(BUF_LENGTH);
-  const fdr = fs$j.openSync(src, 'r');
-  const fdw = fs$j.openSync(dest, 'w', srcStat.mode);
+  const fdr = fs$i.openSync(src, 'r');
+  const fdw = fs$i.openSync(dest, 'w', srcStat.mode);
   let pos = 0;
   while (pos < srcStat.size) {
-    const bytesRead = fs$j.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$j.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$i.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$i.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
-  if (opts.preserveTimestamps) fs$j.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+  if (opts.preserveTimestamps) fs$i.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-  fs$j.closeSync(fdr);
-  fs$j.closeSync(fdw);
+  fs$i.closeSync(fdr);
+  fs$i.closeSync(fdw);
 }
 function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
@@ -1664,50 +1664,50 @@ function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
 }
 function mayCopyDir$1 (src, dest, opts) {
-  if (!fs$j.statSync(dest).isDirectory()) {
+  if (!fs$i.statSync(dest).isDirectory()) {
     throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
   }
   return copyDir$1(src, dest, opts)
 }
 function mkDirAndCopy$1 (srcStat, src, dest, opts) {
-  fs$j.mkdirSync(dest, srcStat.mode);
-  fs$j.chmodSync(dest, srcStat.mode);
+  fs$i.mkdirSync(dest, srcStat.mode);
+  fs$i.chmodSync(dest, srcStat.mode);
   return copyDir$1(src, dest, opts)
 }
 function copyDir$1 (src, dest, opts) {
-  fs$j.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
+  fs$i.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
 }
 function copyDirItem$1 (item, src, dest, opts) {
-  const srcItem = path$g.join(src, item);
-  const destItem = path$g.join(dest, item);
+  const srcItem = path$f.join(src, item);
+  const destItem = path$f.join(dest, item);
   const resolvedDest = checkPaths$1(srcItem, destItem);
   return startCopy$1(resolvedDest, srcItem, destItem, opts)
 }
 function onLink$1 (resolvedDest, src, dest, opts) {
-  let resolvedSrc = fs$j.readlinkSync(src);
+  let resolvedSrc = fs$i.readlinkSync(src);
   if (opts.dereference) {
-    resolvedSrc = path$g.resolve(process.cwd(), resolvedSrc);
+    resolvedSrc = path$f.resolve(process.cwd(), resolvedSrc);
   }
   if (resolvedDest === notExist$1 || resolvedDest === existsReg$1) {
     // if dest already exists, fs throws error anyway,
     // so no need to guard against it here.
-    return fs$j.symlinkSync(resolvedSrc, dest)
+    return fs$i.symlinkSync(resolvedSrc, dest)
   } else {
     if (opts.dereference) {
-      resolvedDest = path$g.resolve(process.cwd(), resolvedDest);
+      resolvedDest = path$f.resolve(process.cwd(), resolvedDest);
     }
     if (pathsAreIdentical$1(resolvedSrc, resolvedDest)) return
     // prevent copy if src is a subdir of dest since unlinking
     // dest in this case would result in removing src contents
     // and therefore a broken symlink would be created.
-    if (fs$j.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
+    if (fs$i.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
     return copyLink$1(resolvedSrc, dest)
@@ -1715,15 +1715,15 @@ function onLink$1 (resolvedDest, src, dest, opts) {
 }
 function copyLink$1 (resolvedSrc, dest) {
-  fs$j.unlinkSync(dest);
-  return fs$j.symlinkSync(resolvedSrc, dest)
+  fs$i.unlinkSync(dest);
+  return fs$i.symlinkSync(resolvedSrc, dest)
 }
 // return true if dest is a subdir of src, otherwise false.
 // extract dest base dir and check if that is the same as src basename.
 function isSrcSubdir$3 (src, dest) {
-  const srcArray = path$g.resolve(src).split(path$g.sep);
-  const destArray = path$g.resolve(dest).split(path$g.sep);
+  const srcArray = path$f.resolve(src).split(path$f.sep);
+  const destArray = path$f.resolve(dest).split(path$f.sep);
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -1734,7 +1734,7 @@ function isSrcSubdir$3 (src, dest) {
 function checkDest$1 (dest) {
   let resolvedPath;
   try {
-    resolvedPath = fs$j.readlinkSync(dest);
+    resolvedPath = fs$i.readlinkSync(dest);
   } catch (err) {
     if (err.code === 'ENOENT') return notExist$1
@@ -1748,8 +1748,8 @@ function checkDest$1 (dest) {
 function pathsAreIdentical$1 (src, dest) {
   const os = process.platform;
-  const resolvedSrc = path$g.resolve(src);
-  const resolvedDest = path$g.resolve(dest);
+  const resolvedSrc = path$f.resolve(src);
+  const resolvedDest = path$f.resolve(dest);
   // case-insensitive paths
   if (os === 'darwin' || os === 'win32') {
     return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
@@ -1776,19 +1776,19 @@ var copySync$1 = {
 };
 const u$a = universalify.fromPromise;
-const fs$i = fs$o;
+const fs$h = fs$n;
 function pathExists$8 (path) {
-  return fs$i.access(path).then(() => true).catch(() => false)
+  return fs$h.access(path).then(() => true).catch(() => false)
 }
 var pathExists_1 = {
   pathExists: u$a(pathExists$8),
-  pathExistsSync: fs$i.existsSync
+  pathExistsSync: fs$h.existsSync
 };
-const fs$h = gracefulFs;
-const path$f = path__default["default"];
+const fs$g = gracefulFs;
+const path$e = path__default["default"];
 const mkdirp$1 = mkdirs_1.mkdirs;
 const pathExists$7 = pathExists_1.pathExists;
 const utimes = utimes$1.utimesMillis;
@@ -1824,7 +1824,7 @@ function copy$2 (src, dest, opts, cb) {
 }
 function checkParentDir (resolvedDest, src, dest, opts, cb) {
-  const destParent = path$f.dirname(dest);
+  const destParent = path$e.dirname(dest);
   pathExists$7(destParent, (err, dirExists) => {
     if (err) return cb(err)
     if (dirExists) return startCopy(resolvedDest, src, dest, opts, cb)
@@ -1851,7 +1851,7 @@ function handleFilter (onInclude, resolvedDest, src, dest, opts, cb) {
 }
 function getStats (resolvedDest, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$h.stat : fs$h.lstat;
+  const stat = opts.dereference ? fs$g.stat : fs$g.lstat;
   stat(src, (err, st) => {
     if (err) return cb(err)
@@ -1871,7 +1871,7 @@ function onFile (srcStat, resolvedDest, src, dest, opts, cb) {
 function mayCopyFile (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
-    fs$h.unlink(dest, err => {
+    fs$g.unlink(dest, err => {
       if (err) return cb(err)
       return copyFile(srcStat, src, dest, opts, cb)
     });
@@ -1881,8 +1881,8 @@ function mayCopyFile (srcStat, src, dest, opts, cb) {
 }
 function copyFile (srcStat, src, dest, opts, cb) {
-  if (typeof fs$h.copyFile === 'function') {
-    return fs$h.copyFile(src, dest, err => {
+  if (typeof fs$g.copyFile === 'function') {
+    return fs$g.copyFile(src, dest, err => {
       if (err) return cb(err)
       return setDestModeAndTimestamps(srcStat, dest, opts, cb)
     })
@@ -1891,9 +1891,9 @@ function copyFile (srcStat, src, dest, opts, cb) {
 }
 function copyFileFallback (srcStat, src, dest, opts, cb) {
-  const rs = fs$h.createReadStream(src);
+  const rs = fs$g.createReadStream(src);
   rs.on('error', err => cb(err)).once('open', () => {
-    const ws = fs$h.createWriteStream(dest, { mode: srcStat.mode });
+    const ws = fs$g.createWriteStream(dest, { mode: srcStat.mode });
     ws.on('error', err => cb(err))
       .on('open', () => rs.pipe(ws))
       .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
@@ -1901,7 +1901,7 @@ function copyFileFallback (srcStat, src, dest, opts, cb) {
 }
 function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
-  fs$h.chmod(dest, srcStat.mode, err => {
+  fs$g.chmod(dest, srcStat.mode, err => {
     if (err) return cb(err)
     if (opts.preserveTimestamps) {
       return utimes(dest, srcStat.atime, srcStat.mtime, cb)
@@ -1926,7 +1926,7 @@ function onDir (srcStat, resolvedDest, src, dest, opts, cb) {
 }
 function mayCopyDir (src, dest, opts, cb) {
-  fs$h.stat(dest, (err, st) => {
+  fs$g.stat(dest, (err, st) => {
     if (err) return cb(err)
     if (!st.isDirectory()) {
       return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
@@ -1936,9 +1936,9 @@ function mayCopyDir (src, dest, opts, cb) {
 }
 function mkDirAndCopy (srcStat, src, dest, opts, cb) {
-  fs$h.mkdir(dest, srcStat.mode, err => {
+  fs$g.mkdir(dest, srcStat.mode, err => {
     if (err) return cb(err)
-    fs$h.chmod(dest, srcStat.mode, err => {
+    fs$g.chmod(dest, srcStat.mode, err => {
       if (err) return cb(err)
       return copyDir(src, dest, opts, cb)
     });
@@ -1946,7 +1946,7 @@ function mkDirAndCopy (srcStat, src, dest, opts, cb) {
 }
 function copyDir (src, dest, opts, cb) {
-  fs$h.readdir(src, (err, items) => {
+  fs$g.readdir(src, (err, items) => {
     if (err) return cb(err)
     return copyDirItems(items, src, dest, opts, cb)
   });
@@ -1959,8 +1959,8 @@ function copyDirItems (items, src, dest, opts, cb) {
 }
 function copyDirItem (items, item, src, dest, opts, cb) {
-  const srcItem = path$f.join(src, item);
-  const destItem = path$f.join(dest, item);
+  const srcItem = path$e.join(src, item);
+  const destItem = path$e.join(dest, item);
   checkPaths(srcItem, destItem, (err, resolvedDest) => {
     if (err) return cb(err)
     startCopy(resolvedDest, srcItem, destItem, opts, err => {
@@ -1971,27 +1971,27 @@ function copyDirItem (items, item, src, dest, opts, cb) {
 }
 function onLink (resolvedDest, src, dest, opts, cb) {
-  fs$h.readlink(src, (err, resolvedSrc) => {
+  fs$g.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
     if (opts.dereference) {
-      resolvedSrc = path$f.resolve(process.cwd(), resolvedSrc);
+      resolvedSrc = path$e.resolve(process.cwd(), resolvedSrc);
     }
     if (resolvedDest === notExist || resolvedDest === existsReg) {
       // if dest already exists, fs throws error anyway,
       // so no need to guard against it here.
-      return fs$h.symlink(resolvedSrc, dest, cb)
+      return fs$g.symlink(resolvedSrc, dest, cb)
     } else {
       if (opts.dereference) {
-        resolvedDest = path$f.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path$e.resolve(process.cwd(), resolvedDest);
       }
       if (pathsAreIdentical(resolvedSrc, resolvedDest)) return cb()
       // prevent copy if src is a subdir of dest since unlinking
       // dest in this case would result in removing src contents
       // and therefore a broken symlink would be created.
-      fs$h.stat(dest, (err, st) => {
+      fs$g.stat(dest, (err, st) => {
         if (err) return cb(err)
         if (st.isDirectory() && isSrcSubdir$2(resolvedDest, resolvedSrc)) {
           return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
@@ -2003,17 +2003,17 @@ function onLink (resolvedDest, src, dest, opts, cb) {
 }
 function copyLink (resolvedSrc, dest, cb) {
-  fs$h.unlink(dest, err => {
+  fs$g.unlink(dest, err => {
     if (err) return cb(err)
-    return fs$h.symlink(resolvedSrc, dest, cb)
+    return fs$g.symlink(resolvedSrc, dest, cb)
   });
 }
 // return true if dest is a subdir of src, otherwise false.
 // extract dest base dir and check if that is the same as src basename.
 function isSrcSubdir$2 (src, dest) {
-  const srcArray = path$f.resolve(src).split(path$f.sep);
-  const destArray = path$f.resolve(dest).split(path$f.sep);
+  const srcArray = path$e.resolve(src).split(path$e.sep);
+  const destArray = path$e.resolve(dest).split(path$e.sep);
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -2022,7 +2022,7 @@ function isSrcSubdir$2 (src, dest) {
 // check if dest exists and is a symlink.
 function checkDest (dest, cb) {
-  fs$h.readlink(dest, (err, resolvedPath) => {
+  fs$g.readlink(dest, (err, resolvedPath) => {
     if (err) {
       if (err.code === 'ENOENT') return cb(null, notExist)
@@ -2037,8 +2037,8 @@ function checkDest (dest, cb) {
 function pathsAreIdentical (src, dest) {
   const os = process.platform;
-  const resolvedSrc = path$f.resolve(src);
-  const resolvedDest = path$f.resolve(dest);
+  const resolvedSrc = path$e.resolve(src);
+  const resolvedDest = path$e.resolve(dest);
   // case-insensitive paths
   if (os === 'darwin' || os === 'win32') {
     return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
@@ -2067,8 +2067,8 @@ var copy$1 = {
   copy: u$9(copy_1)
 };
-const fs$g = gracefulFs;
-const path$e = path__default["default"];
+const fs$f = gracefulFs;
+const path$d = path__default["default"];
 const assert = assert__default["default"];
 const isWindows = (process.platform === 'win32');
@@ -2083,9 +2083,9 @@ function defaults (options) {
     'readdir'
   ];
   methods.forEach(m => {
-    options[m] = options[m] || fs$g[m];
+    options[m] = options[m] || fs$f[m];
     m = m + 'Sync';
-    options[m] = options[m] || fs$g[m];
+    options[m] = options[m] || fs$f[m];
   });
   options.maxBusyTries = options.maxBusyTries || 3;
@@ -2273,7 +2273,7 @@ function rmkids (p, options, cb) {
     if (n === 0) return options.rmdir(p, cb)
     files.forEach(f => {
-      rimraf$1(path$e.join(p, f), options, er => {
+      rimraf$1(path$d.join(p, f), options, er => {
         if (errState) {
           return
         }
@@ -2355,7 +2355,7 @@ function rmdirSync (p, options, originalEr) {
 function rmkidsSync (p, options) {
   assert(p);
   assert(options);
-  options.readdirSync(p).forEach(f => rimrafSync(path$e.join(p, f), options));
+  options.readdirSync(p).forEach(f => rimrafSync(path$d.join(p, f), options));
   // We only end up here once we got ENOTEMPTY at least once, and
   // at this point, we are guaranteed to have removed all the kids.
@@ -2389,17 +2389,17 @@ var remove$2 = {
 };
 const u$7 = universalify.fromCallback;
-const fs$f = fs__default["default"];
-const path$d = path__default["default"];
+const fs$e = fs__default["default"];
+const path$c = path__default["default"];
 const mkdir$5 = mkdirs_1;
 const remove$1 = remove$2;
 const emptyDir = u$7(function emptyDir (dir, callback) {
   callback = callback || function () {};
-  fs$f.readdir(dir, (err, items) => {
+  fs$e.readdir(dir, (err, items) => {
     if (err) return mkdir$5.mkdirs(dir, callback)
-    items = items.map(item => path$d.join(dir, item));
+    items = items.map(item => path$c.join(dir, item));
     deleteItem();
@@ -2417,13 +2417,13 @@ const emptyDir = u$7(function emptyDir (dir, callback) {
 function emptyDirSync (dir) {
   let items;
   try {
-    items = fs$f.readdirSync(dir);
+    items = fs$e.readdirSync(dir);
   } catch (err) {
     return mkdir$5.mkdirsSync(dir)
   }
   items.forEach(item => {
-    item = path$d.join(dir, item);
+    item = path$c.join(dir, item);
     remove$1.removeSync(item);
   });
 }
@@ -2436,22 +2436,22 @@ var empty = {
 };
 const u$6 = universalify.fromCallback;
-const path$c = path__default["default"];
-const fs$e = gracefulFs;
+const path$b = path__default["default"];
+const fs$d = gracefulFs;
 const mkdir$4 = mkdirs_1;
 const pathExists$6 = pathExists_1.pathExists;
 function createFile$1 (file, callback) {
   function makeFile () {
-    fs$e.writeFile(file, '', err => {
+    fs$d.writeFile(file, '', err => {
       if (err) return callback(err)
       callback();
     });
   }
-  fs$e.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+  fs$d.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
     if (!err && stats.isFile()) return callback()
-    const dir = path$c.dirname(file);
+    const dir = path$b.dirname(file);
     pathExists$6(dir, (err, dirExists) => {
       if (err) return callback(err)
       if (dirExists) return makeFile()
@@ -2466,16 +2466,16 @@ function createFile$1 (file, callback) {
 function createFileSync$1 (file) {
   let stats;
   try {
-    stats = fs$e.statSync(file);
+    stats = fs$d.statSync(file);
   } catch (e) {}
   if (stats && stats.isFile()) return
-  const dir = path$c.dirname(file);
-  if (!fs$e.existsSync(dir)) {
+  const dir = path$b.dirname(file);
+  if (!fs$d.existsSync(dir)) {
     mkdir$4.mkdirsSync(dir);
   }
-  fs$e.writeFileSync(file, '');
+  fs$d.writeFileSync(file, '');
 }
 var file$1 = {
@@ -2484,14 +2484,14 @@ var file$1 = {
 };
 const u$5 = universalify.fromCallback;
-const path$b = path__default["default"];
-const fs$d = gracefulFs;
+const path$a = path__default["default"];
+const fs$c = gracefulFs;
 const mkdir$3 = mkdirs_1;
 const pathExists$5 = pathExists_1.pathExists;
 function createLink (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
-    fs$d.link(srcpath, dstpath, err => {
+    fs$c.link(srcpath, dstpath, err => {
       if (err) return callback(err)
       callback(null);
     });
@@ -2500,13 +2500,13 @@ function createLink (srcpath, dstpath, callback) {
   pathExists$5(dstpath, (err, destinationExists) => {
     if (err) return callback(err)
     if (destinationExists) return callback(null)
-    fs$d.lstat(srcpath, (err) => {
+    fs$c.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink');
         return callback(err)
       }
-      const dir = path$b.dirname(dstpath);
+      const dir = path$a.dirname(dstpath);
       pathExists$5(dir, (err, dirExists) => {
         if (err) return callback(err)
         if (dirExists) return makeLink(srcpath, dstpath)
@@ -2520,22 +2520,22 @@ function createLink (srcpath, dstpath, callback) {
 }
 function createLinkSync (srcpath, dstpath) {
-  const destinationExists = fs$d.existsSync(dstpath);
+  const destinationExists = fs$c.existsSync(dstpath);
   if (destinationExists) return undefined
   try {
-    fs$d.lstatSync(srcpath);
+    fs$c.lstatSync(srcpath);
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
     throw err
   }
-  const dir = path$b.dirname(dstpath);
-  const dirExists = fs$d.existsSync(dir);
-  if (dirExists) return fs$d.linkSync(srcpath, dstpath)
+  const dir = path$a.dirname(dstpath);
+  const dirExists = fs$c.existsSync(dir);
+  if (dirExists) return fs$c.linkSync(srcpath, dstpath)
   mkdir$3.mkdirsSync(dir);
-  return fs$d.linkSync(srcpath, dstpath)
+  return fs$c.linkSync(srcpath, dstpath)
 }
 var link$1 = {
@@ -2543,8 +2543,8 @@ var link$1 = {
   createLinkSync
 };
-const path$a = path__default["default"];
-const fs$c = gracefulFs;
+const path$9 = path__default["default"];
+const fs$b = gracefulFs;
 const pathExists$4 = pathExists_1.pathExists;
 /**
@@ -2570,8 +2570,8 @@ const pathExists$4 = pathExists_1.pathExists;
  */
 function symlinkPaths$1 (srcpath, dstpath, callback) {
-  if (path$a.isAbsolute(srcpath)) {
-    return fs$c.lstat(srcpath, (err) => {
+  if (path$9.isAbsolute(srcpath)) {
+    return fs$b.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureSymlink');
         return callback(err)
@@ -2582,8 +2582,8 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
       })
     })
   } else {
-    const dstdir = path$a.dirname(dstpath);
-    const relativeToDst = path$a.join(dstdir, srcpath);
+    const dstdir = path$9.dirname(dstpath);
+    const relativeToDst = path$9.join(dstdir, srcpath);
     return pathExists$4(relativeToDst, (err, exists) => {
       if (err) return callback(err)
       if (exists) {
@@ -2592,14 +2592,14 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
           'toDst': srcpath
         })
       } else {
-        return fs$c.lstat(srcpath, (err) => {
+        return fs$b.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace('lstat', 'ensureSymlink');
             return callback(err)
           }
           return callback(null, {
             'toCwd': srcpath,
-            'toDst': path$a.relative(dstdir, srcpath)
+            'toDst': path$9.relative(dstdir, srcpath)
           })
         })
       }
@@ -2609,28 +2609,28 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
 function symlinkPathsSync$1 (srcpath, dstpath) {
   let exists;
-  if (path$a.isAbsolute(srcpath)) {
-    exists = fs$c.existsSync(srcpath);
+  if (path$9.isAbsolute(srcpath)) {
+    exists = fs$b.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       'toCwd': srcpath,
       'toDst': srcpath
     }
   } else {
-    const dstdir = path$a.dirname(dstpath);
-    const relativeToDst = path$a.join(dstdir, srcpath);
-    exists = fs$c.existsSync(relativeToDst);
+    const dstdir = path$9.dirname(dstpath);
+    const relativeToDst = path$9.join(dstdir, srcpath);
+    exists = fs$b.existsSync(relativeToDst);
     if (exists) {
       return {
         'toCwd': relativeToDst,
         'toDst': srcpath
       }
     } else {
-      exists = fs$c.existsSync(srcpath);
+      exists = fs$b.existsSync(srcpath);
       if (!exists) throw new Error('relative srcpath does not exist')
       return {
         'toCwd': srcpath,
-        'toDst': path$a.relative(dstdir, srcpath)
+        'toDst': path$9.relative(dstdir, srcpath)
       }
     }
   }
@@ -2641,13 +2641,13 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
-const fs$b = gracefulFs;
+const fs$a = gracefulFs;
 function symlinkType$1 (srcpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback;
   type = (typeof type === 'function') ? false : type;
   if (type) return callback(null, type)
-  fs$b.lstat(srcpath, (err, stats) => {
+  fs$a.lstat(srcpath, (err, stats) => {
     if (err) return callback(null, 'file')
     type = (stats && stats.isDirectory()) ? 'dir' : 'file';
     callback(null, type);
@@ -2659,7 +2659,7 @@ function symlinkTypeSync$1 (srcpath, type) {
   if (type) return type
   try {
-    stats = fs$b.lstatSync(srcpath);
+    stats = fs$a.lstatSync(srcpath);
   } catch (e) {
     return 'file'
   }
@@ -2672,8 +2672,8 @@ var symlinkType_1 = {
 };
 const u$4 = universalify.fromCallback;
-const path$9 = path__default["default"];
-const fs$a = gracefulFs;
+const path$8 = path__default["default"];
+const fs$9 = gracefulFs;
 const _mkdirs = mkdirs_1;
 const mkdirs = _mkdirs.mkdirs;
 const mkdirsSync = _mkdirs.mkdirsSync;
@@ -2700,13 +2700,13 @@ function createSymlink (srcpath, dstpath, type, callback) {
       srcpath = relative.toDst;
       symlinkType(relative.toCwd, type, (err, type) => {
         if (err) return callback(err)
-        const dir = path$9.dirname(dstpath);
+        const dir = path$8.dirname(dstpath);
         pathExists$3(dir, (err, dirExists) => {
           if (err) return callback(err)
-          if (dirExists) return fs$a.symlink(srcpath, dstpath, type, callback)
+          if (dirExists) return fs$9.symlink(srcpath, dstpath, type, callback)
           mkdirs(dir, err => {
             if (err) return callback(err)
-            fs$a.symlink(srcpath, dstpath, type, callback);
+            fs$9.symlink(srcpath, dstpath, type, callback);
           });
         });
       });
@@ -2715,17 +2715,17 @@ function createSymlink (srcpath, dstpath, type, callback) {
 }
 function createSymlinkSync (srcpath, dstpath, type) {
-  const destinationExists = fs$a.existsSync(dstpath);
+  const destinationExists = fs$9.existsSync(dstpath);
   if (destinationExists) return undefined
   const relative = symlinkPathsSync(srcpath, dstpath);
   srcpath = relative.toDst;
   type = symlinkTypeSync(relative.toCwd, type);
-  const dir = path$9.dirname(dstpath);
-  const exists = fs$a.existsSync(dir);
-  if (exists) return fs$a.symlinkSync(srcpath, dstpath, type)
+  const dir = path$8.dirname(dstpath);
+  const exists = fs$9.existsSync(dir);
+  if (exists) return fs$9.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$a.symlinkSync(srcpath, dstpath, type)
+  return fs$9.symlinkSync(srcpath, dstpath, type)
 }
 var symlink$1 = {
@@ -2901,7 +2901,7 @@ var jsonfile = {
   writeJsonSync: jsonFile$3.writeFileSync
 };
-const path$8 = path__default["default"];
+const path$7 = path__default["default"];
 const mkdir$2 = mkdirs_1;
 const pathExists$2 = pathExists_1.pathExists;
 const jsonFile$2 = jsonfile;
@@ -2912,7 +2912,7 @@ function outputJson (file, data, options, callback) {
     options = {};
   }
-  const dir = path$8.dirname(file);
+  const dir = path$7.dirname(file);
   pathExists$2(dir, (err, itDoes) => {
     if (err) return callback(err)
@@ -2927,15 +2927,15 @@ function outputJson (file, data, options, callback) {
 var outputJson_1 = outputJson;
-const fs$9 = gracefulFs;
-const path$7 = path__default["default"];
+const fs$8 = gracefulFs;
+const path$6 = path__default["default"];
 const mkdir$1 = mkdirs_1;
 const jsonFile$1 = jsonfile;
 function outputJsonSync (file, data, options) {
-  const dir = path$7.dirname(file);
+  const dir = path$6.dirname(file);
-  if (!fs$9.existsSync(dir)) {
+  if (!fs$8.existsSync(dir)) {
     mkdir$1.mkdirsSync(dir);
   }
@@ -2959,8 +2959,8 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 var json = jsonFile;
-const fs$8 = gracefulFs;
-const path$6 = path__default["default"];
+const fs$7 = gracefulFs;
+const path$5 = path__default["default"];
 const copySync = copySync$1.copySync;
 const removeSync = remove$2.removeSync;
 const mkdirpSync = mkdirs_1.mkdirsSync;
@@ -2970,20 +2970,20 @@ function moveSync (src, dest, options) {
   options = options || {};
   const overwrite = options.overwrite || options.clobber || false;
-  src = path$6.resolve(src);
-  dest = path$6.resolve(dest);
+  src = path$5.resolve(src);
+  dest = path$5.resolve(dest);
-  if (src === dest) return fs$8.accessSync(src)
+  if (src === dest) return fs$7.accessSync(src)
   if (isSrcSubdir$1(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
-  mkdirpSync(path$6.dirname(dest));
+  mkdirpSync(path$5.dirname(dest));
   tryRenameSync();
   function tryRenameSync () {
     if (overwrite) {
       try {
-        return fs$8.renameSync(src, dest)
+        return fs$7.renameSync(src, dest)
       } catch (err) {
         if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'EPERM') {
           removeSync(dest);
@@ -2996,8 +2996,8 @@ function moveSync (src, dest, options) {
       }
     } else {
       try {
-        fs$8.linkSync(src, dest);
-        return fs$8.unlinkSync(src)
+        fs$7.linkSync(src, dest);
+        return fs$7.unlinkSync(src)
       } catch (err) {
         if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM' || err.code === 'ENOTSUP') {
           return moveSyncAcrossDevice(src, dest, overwrite)
@@ -3009,7 +3009,7 @@ function moveSync (src, dest, options) {
 }
 function moveSyncAcrossDevice (src, dest, overwrite) {
-  const stat = fs$8.statSync(src);
+  const stat = fs$7.statSync(src);
   if (stat.isDirectory()) {
     return moveDirSyncAcrossDevice(src, dest, overwrite)
@@ -3024,20 +3024,20 @@ function moveFileSyncAcrossDevice (src, dest, overwrite) {
   const flags = overwrite ? 'w' : 'wx';
-  const fdr = fs$8.openSync(src, 'r');
-  const stat = fs$8.fstatSync(fdr);
-  const fdw = fs$8.openSync(dest, flags, stat.mode);
+  const fdr = fs$7.openSync(src, 'r');
+  const stat = fs$7.fstatSync(fdr);
+  const fdw = fs$7.openSync(dest, flags, stat.mode);
   let pos = 0;
   while (pos < stat.size) {
-    const bytesRead = fs$8.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$8.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$7.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$7.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
-  fs$8.closeSync(fdr);
-  fs$8.closeSync(fdw);
-  return fs$8.unlinkSync(src)
+  fs$7.closeSync(fdr);
+  fs$7.closeSync(fdw);
+  return fs$7.unlinkSync(src)
 }
 function moveDirSyncAcrossDevice (src, dest, overwrite) {
@@ -3062,10 +3062,10 @@ function moveDirSyncAcrossDevice (src, dest, overwrite) {
 // extract dest base dir and check if that is the same as src basename
 function isSrcSubdir$1 (src, dest) {
   try {
-    return fs$8.statSync(src).isDirectory() &&
+    return fs$7.statSync(src).isDirectory() &&
            src !== dest &&
            dest.indexOf(src) > -1 &&
-           dest.split(path$6.dirname(src) + path$6.sep)[1].split(path$6.sep)[0] === path$6.basename(src)
+           dest.split(path$5.dirname(src) + path$5.sep)[1].split(path$5.sep)[0] === path$5.basename(src)
   } catch (e) {
     return false
   }
@@ -3076,8 +3076,8 @@ var moveSync_1 = {
 };
 const u$1 = universalify.fromCallback;
-const fs$7 = gracefulFs;
-const path$5 = path__default["default"];
+const fs$6 = gracefulFs;
+const path$4 = path__default["default"];
 const copy = copy$1.copy;
 const remove = remove$2.remove;
 const mkdirp = mkdirs_1.mkdirp;
@@ -3091,18 +3091,18 @@ function move (src, dest, opts, cb) {
   const overwrite = opts.overwrite || opts.clobber || false;
-  src = path$5.resolve(src);
-  dest = path$5.resolve(dest);
+  src = path$4.resolve(src);
+  dest = path$4.resolve(dest);
-  if (src === dest) return fs$7.access(src, cb)
+  if (src === dest) return fs$6.access(src, cb)
-  fs$7.stat(src, (err, st) => {
+  fs$6.stat(src, (err, st) => {
     if (err) return cb(err)
     if (st.isDirectory() && isSrcSubdir(src, dest)) {
       return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`))
     }
-    mkdirp(path$5.dirname(dest), err => {
+    mkdirp(path$4.dirname(dest), err => {
       if (err) return cb(err)
       return doRename(src, dest, overwrite, cb)
     });
@@ -3124,7 +3124,7 @@ function doRename (src, dest, overwrite, cb) {
 }
 function rename (src, dest, overwrite, cb) {
-  fs$7.rename(src, dest, err => {
+  fs$6.rename(src, dest, err => {
     if (!err) return cb()
     if (err.code !== 'EXDEV') return cb(err)
     return moveAcrossDevice(src, dest, overwrite, cb)
@@ -3144,8 +3144,8 @@ function moveAcrossDevice (src, dest, overwrite, cb) {
 }
 function isSrcSubdir (src, dest) {
-  const srcArray = src.split(path$5.sep);
-  const destArray = dest.split(path$5.sep);
+  const srcArray = src.split(path$4.sep);
+  const destArray = dest.split(path$4.sep);
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -3157,8 +3157,8 @@ var move_1 = {
 };
 const u = universalify.fromCallback;
-const fs$6 = gracefulFs;
-const path$4 = path__default["default"];
+const fs$5 = gracefulFs;
+const path$3 = path__default["default"];
 const mkdir = mkdirs_1;
 const pathExists = pathExists_1.pathExists;
@@ -3168,26 +3168,26 @@ function outputFile (file, data, encoding, callback) {
     encoding = 'utf8';
   }
-  const dir = path$4.dirname(file);
+  const dir = path$3.dirname(file);
   pathExists(dir, (err, itDoes) => {
     if (err) return callback(err)
-    if (itDoes) return fs$6.writeFile(file, data, encoding, callback)
+    if (itDoes) return fs$5.writeFile(file, data, encoding, callback)
     mkdir.mkdirs(dir, err => {
       if (err) return callback(err)
-      fs$6.writeFile(file, data, encoding, callback);
+      fs$5.writeFile(file, data, encoding, callback);
     });
   });
 }
 function outputFileSync (file, ...args) {
-  const dir = path$4.dirname(file);
-  if (fs$6.existsSync(dir)) {
-    return fs$6.writeFileSync(file, ...args)
+  const dir = path$3.dirname(file);
+  if (fs$5.existsSync(dir)) {
+    return fs$5.writeFileSync(file, ...args)
   }
   mkdir.mkdirsSync(dir);
-  fs$6.writeFileSync(file, ...args);
+  fs$5.writeFileSync(file, ...args);
 }
 var output = {
@@ -3200,7 +3200,7 @@ var output = {
 	module.exports = Object.assign(
 	  {},
 	  // Export promiseified graceful-fs:
-	  fs$o,
+	  fs$n,
 	  // Export extra methods:
 	  copySync$1,
 	  copy$1,
@@ -3225,13 +3225,13 @@ var output = {
 	}
 } (lib$3));
-var fs$5 = libExports$1;
+var fs$4 = libExports$1;
 class File {
     constructor(path, hash) {
         this.path = path;
         this.hash = hash;
-        this._fd = fs$5.openSync(path, "w");
+        this._fd = fs$4.openSync(path, "w");
         this.system = undefined;
         this._writing = false;
         this.originalPath = undefined;
@@ -3258,14 +3258,14 @@ class File {
         if (!this._fd) {
             throw new Error(`No fd for ${this.path}`);
         }
-        fs$5.closeSync(this._fd);
-        fs$5.unlinkSync(this.path);
+        fs$4.closeSync(this._fd);
+        fs$4.unlinkSync(this.path);
     }
     close() {
         if (this._fd === undefined) {
             throw new Error(`No fd for ${this.path}`);
         }
-        fs$5.closeSync(this._fd);
+        fs$4.closeSync(this._fd);
         this._fd = undefined;
     }
     _write() {
@@ -3273,7 +3273,7 @@ class File {
         const pending = this._pending.shift();
         if (pending) {
             assert__default["default"](this._fd !== undefined);
-            fs$5.write(this._fd, pending.data)
+            fs$4.write(this._fd, pending.data)
                 .then(() => {
                 pending.resolve();
                 assert__default["default"](this._pending);
@@ -3288,7 +3288,7 @@ class File {
             })
                 .catch((e) => {
                 assert__default["default"](this._fd !== undefined);
-                fs$5.closeSync(this._fd);
+                fs$4.closeSync(this._fd);
                 this._fd = undefined;
                 pending.reject(e);
                 this._clearPending(e);
@@ -3394,7 +3394,7 @@ var randomstring$1 = {
   generate: generate
 };
-var fs$4 = fs__default["default"],
+var fs$3 = fs__default["default"],
     randomstring = randomstring$1;
@@ -3425,7 +3425,7 @@ function createFile(template, callback) {
     }
   }
-  fs$4.open(filename, 'ax+', 384 /*=0600*/, function(err, fd) {
+  fs$3.open(filename, 'ax+', 384 /*=0600*/, function(err, fd) {
     if (err) {
       if (err.code === 'EEXIST') {
         // FIXME: infinite loop
@@ -3441,7 +3441,7 @@ function createFile(template, callback) {
     }
     if (fd) {
-      fs$4.close(fd, function(err) {
+      fs$3.close(fd, function(err) {
         callback(err, filename);
       });
     } else {
@@ -3466,7 +3466,7 @@ function createFileSync(template) {
     isExist = false;
     filename = randomstring.generate(template);
     try {
-      fd = fs$4.openSync(filename, 'ax+', 384 /*=0600*/);
+      fd = fs$3.openSync(filename, 'ax+', 384 /*=0600*/);
     } catch (e) {
       if (e.code === 'EEXIST') {
         isExist = true;
@@ -3474,7 +3474,7 @@ function createFileSync(template) {
         throw e;
       }
     } finally {
-      fd && fs$4.closeSync(fd);
+      fd && fs$3.closeSync(fd);
     }
   } while (isExist);
@@ -3509,7 +3509,7 @@ function createDir(template, callback) {
     }
   }
-  fs$4.mkdir(dirname, 448 /*=0700*/, function(err) {
+  fs$3.mkdir(dirname, 448 /*=0700*/, function(err) {
     if (err) {
       if (err.code === 'EEXIST') {
         // FIXME: infinite loop
@@ -3543,7 +3543,7 @@ function createDirSync(template) {
     isExist = false;
     dirname = randomstring.generate(template);
     try {
-      fs$4.mkdirSync(dirname, 448 /*=0700*/);
+      fs$3.mkdirSync(dirname, 448 /*=0700*/);
     } catch (e) {
       if (e.code === 'EEXIST') {
         isExist = true;
@@ -3592,7 +3592,7 @@ function untarFile(archive, file) {
             child_process__default["default"].exec(`tar -zxf "${archive}" ${file}`, { cwd: tmpdir }, (err) => {
                 if (err) {
                     try {
-                        fs$5.removeSync(tmpdir);
+                        fs$4.removeSync(tmpdir);
                     }
                     catch (e) {
                         console.error("Got an error removing the temp dir", tmpdir);
@@ -3600,9 +3600,9 @@ function untarFile(archive, file) {
                     reject(err);
                     return;
                 }
-                fs$5.readFile(path__default["default"].join(tmpdir, file), "utf8", (error, data) => {
+                fs$4.readFile(path__default["default"].join(tmpdir, file), "utf8", (error, data) => {
                     try {
-                        fs$5.removeSync(tmpdir);
+                        fs$4.removeSync(tmpdir);
                     }
                     catch (e) {
                         console.error("Got an error removing the temp dir", tmpdir);
@@ -3645,12 +3645,12 @@ class Environments {
                 }
             }
             return new Promise((resolve, reject) => {
-                fs$5.stat(p)
+                fs$4.stat(p)
                     .then((st) => {
                     if (st.isDirectory()) {
                         // we're good
                         this._path = p;
-                        fs$5.readdir(p).then((files) => {
+                        fs$4.readdir(p).then((files) => {
                             const promises = [];
                             files.forEach((e) => {
                                 if (e.length === 47 && e.indexOf(".tar.gz", 40) === 40) {
@@ -3685,7 +3685,7 @@ class Environments {
                     .catch((e) => {
                     if ("code" in e && e.code === "ENOENT") {
                         // make the directory
-                        fs$5.mkdirp(p, (err) => {
+                        fs$4.mkdirp(p, (err) => {
                             if (err) {
                                 reject(`Can't make directory ${p}: ${e.message}`);
                                 return;
@@ -3707,7 +3707,7 @@ class Environments {
             return undefined;
         }
         assert__default["default"](this._path);
-        fs$5.mkdirpSync(this._path);
+        fs$4.mkdirpSync(this._path);
         return new File(path__default["default"].join(this._path, `${environment.hash}.tar.gz`), environment.hash);
     }
     complete(file) {
@@ -3798,7 +3798,7 @@ class Environments {
     remove(hash) {
         // ### this should be promisified
         try {
-            fs$5.removeSync(this._data[hash].path);
+            fs$4.removeSync(this._data[hash].path);
             delete this._data[hash];
             this.unlink(hash);
             this.unlink(undefined, hash);
@@ -41046,19 +41046,19 @@ function requireQuery () {
  */
 var debug$1 = requireSrc()('express:view');
-var path$3 = path__default["default"];
-var fs$3 = fs__default["default"];
+var path$2 = path__default["default"];
+var fs$2 = fs__default["default"];
 /**
  * Module variables.
  * @private
  */
-var dirname = path$3.dirname;
-var basename$1 = path$3.basename;
-var extname$2 = path$3.extname;
-var join$1 = path$3.join;
-var resolve$3 = path$3.resolve;
+var dirname = path$2.dirname;
+var basename$1 = path$2.basename;
+var extname$2 = path$2.extname;
+var join$1 = path$2.join;
+var resolve$3 = path$2.resolve;
 /**
  * Module exports.
@@ -41207,7 +41207,7 @@ function tryStat(path) {
   debug$1('stat "%s"', path);
   try {
-    return fs$3.statSync(path);
+    return fs$2.statSync(path);
   } catch (e) {
     return undefined;
   }
@@ -44785,7 +44785,7 @@ var require$$2 = {
 ]
 };
-var fs$2 = fs__default["default"];
+var fs$1 = fs__default["default"];
 function Mime() {
   // Map of extension -> mime type
@@ -44835,7 +44835,7 @@ Mime.prototype.load = function(file) {
   this._loading = file;
   // Read file and split into lines
   var map = {},
-      content = fs$2.readFileSync(file, 'ascii'),
+      content = fs$1.readFileSync(file, 'ascii'),
       lines = content.split(/[\r\n]+/);
   lines.forEach(function(line) {
@@ -45237,12 +45237,12 @@ var encodeUrl$1 = encodeurl;
 var escapeHtml$1 = escapeHtml_1;
 var etag = etag_1;
 var fresh$1 = fresh_1;
-var fs$1 = fs__default["default"];
+var fs = fs__default["default"];
 var mime$2 = mime_1;
 var ms = ms$1;
 var onFinished$1 = requireOnFinished();
 var parseRange$1 = rangeParser_1;
-var path$2 = path__default["default"];
+var path$1 = path__default["default"];
 var statuses$1 = statuses$3;
 var Stream = require$$0__default$1["default"];
 var util = require$$4__default["default"];
@@ -45252,11 +45252,11 @@ var util = require$$4__default["default"];
  * @private
  */
-var extname$1 = path$2.extname;
-var join = path$2.join;
-var normalize = path$2.normalize;
-var resolve$2 = path$2.resolve;
-var sep = path$2.sep;
+var extname$1 = path$1.extname;
+var join = path$1.join;
+var normalize = path$1.normalize;
+var resolve$2 = path$1.resolve;
+var sep = path$1.sep;
 /**
  * Regular expression for identifying a bytes Range header.
@@ -45931,7 +45931,7 @@ SendStream.prototype.sendFile = function sendFile (path) {
   var self = this;
   debug('stat "%s"', path);
-  fs$1.stat(path, function onstat (err, stat) {
+  fs.stat(path, function onstat (err, stat) {
     if (err && err.code === 'ENOENT' && !extname$1(path) && path[path.length - 1] !== sep) {
       // not found, check extensions
       return next(err)
@@ -45952,7 +45952,7 @@ SendStream.prototype.sendFile = function sendFile (path) {
     var p = path + '.' + self._extensions[i++];
     debug('stat "%s"', p);
-    fs$1.stat(p, function (err, stat) {
+    fs.stat(p, function (err, stat) {
       if (err) return next(err)
       if (stat.isDirectory()) return next()
       self.emit('file', p, stat);
@@ -45980,7 +45980,7 @@ SendStream.prototype.sendIndex = function sendIndex (path) {
     var p = join(path, self._index[i]);
     debug('stat "%s"', p);
-    fs$1.stat(p, function (err, stat) {
+    fs.stat(p, function (err, stat) {
       if (err) return next(err)
       if (stat.isDirectory()) return next()
       self.emit('file', p, stat);
@@ -46004,7 +46004,7 @@ SendStream.prototype.stream = function stream (path, options) {
   var res = this.res;
   // pipe
-  var stream = fs$1.createReadStream(path, options);
+  var stream = fs.createReadStream(path, options);
   this.emit('stream', stream);
   stream.pipe(res);
@@ -50617,7 +50617,7 @@ var escapeHtml = escapeHtml_1;
 var http = require$$2__default["default"];
 var isAbsolute = utils.isAbsolute;
 var onFinished = requireOnFinished();
-var path$1 = path__default["default"];
+var path = path__default["default"];
 var statuses = statuses$3;
 var merge = utilsMergeExports;
 var sign = cookieSignature.sign;
@@ -50626,9 +50626,9 @@ var normalizeTypes = utils.normalizeTypes;
 var setCharset = utils.setCharset;
 var cookie = cookie$1;
 var send = sendExports;
-var extname = path$1.extname;
+var extname = path.extname;
 var mime = send.mime;
-var resolve$1 = path$1.resolve;
+var resolve$1 = path.resolve;
 var vary = varyExports;
 /**
@@ -52484,7 +52484,7 @@ function validateCache(option) {
     // console.log(dir);
     let version;
     try {
-        version = fs$5.readFileSync(file);
+        version = fs$4.readFileSync(file);
         if (version.readUInt32BE() === Version) {
             return;
         }
@@ -52495,11 +52495,11 @@ function validateCache(option) {
     if (version) {
         console.log(`Wrong version. Destroying cache ${dir}`);
     }
-    fs$5.removeSync(dir);
-    fs$5.mkdirpSync(dir);
+    fs$4.removeSync(dir);
+    fs$4.mkdirpSync(dir);
     const buf = Buffer.allocUnsafe(4);
     buf.writeUInt32BE(Version);
-    fs$5.writeFileSync(file, buf);
+    fs$4.writeFileSync(file, buf);
 }
 function common$1(option) {
     validateCache(option);
@@ -53490,273 +53490,269 @@ var xdgBasedir = {};
 	}
 } (xdgBasedir));
-var minimist;
-var hasRequiredMinimist;
+function hasKey(obj, keys) {
+	var o = obj;
+	keys.slice(0, -1).forEach(function (key) {
+		o = o[key] || {};
+	});
-function requireMinimist () {
-	if (hasRequiredMinimist) return minimist;
-	hasRequiredMinimist = 1;
-	minimist = function (args, opts) {
-	    if (!opts) opts = {};
-	    var flags = { bools : {}, strings : {}, unknownFn: null };
+	var key = keys[keys.length - 1];
+	return key in o;
+}
-	    if (typeof opts['unknown'] === 'function') {
-	        flags.unknownFn = opts['unknown'];
-	    }
+function isNumber(x) {
+	if (typeof x === 'number') { return true; }
+	if ((/^0x[0-9a-f]+$/i).test(x)) { return true; }
+	return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x);
+}
-	    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
-	      flags.allBools = true;
-	    } else {
-	      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-	          flags.bools[key] = true;
-	      });
-	    }
-	    var aliases = {};
-	    Object.keys(opts.alias || {}).forEach(function (key) {
-	        aliases[key] = [].concat(opts.alias[key]);
-	        aliases[key].forEach(function (x) {
-	            aliases[x] = [key].concat(aliases[key].filter(function (y) {
-	                return x !== y;
-	            }));
-	        });
-	    });
+function isConstructorOrProto(obj, key) {
+	return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';
+}
-	    [].concat(opts.string).filter(Boolean).forEach(function (key) {
-	        flags.strings[key] = true;
-	        if (aliases[key]) {
-	            flags.strings[aliases[key]] = true;
-	        }
-	     });
+var minimist = function (args, opts) {
+	if (!opts) { opts = {}; }
-	    var defaults = opts['default'] || {};
-	    var argv = { _ : [] };
-	    Object.keys(flags.bools).forEach(function (key) {
-	        setArg(key, defaults[key] === undefined ? false : defaults[key]);
-	    });
-	    var notFlags = [];
+	var flags = {
+		bools: {},
+		strings: {},
+		unknownFn: null,
+	};
-	    if (args.indexOf('--') !== -1) {
-	        notFlags = args.slice(args.indexOf('--')+1);
-	        args = args.slice(0, args.indexOf('--'));
-	    }
+	if (typeof opts.unknown === 'function') {
+		flags.unknownFn = opts.unknown;
+	}
-	    function argDefined(key, arg) {
-	        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
-	            flags.strings[key] || flags.bools[key] || aliases[key];
-	    }
+	if (typeof opts.boolean === 'boolean' && opts.boolean) {
+		flags.allBools = true;
+	} else {
+		[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
+			flags.bools[key] = true;
+		});
+	}
-	    function setArg (key, val, arg) {
-	        if (arg && flags.unknownFn && !argDefined(key, arg)) {
-	            if (flags.unknownFn(arg) === false) return;
-	        }
+	var aliases = {};
-	        var value = !flags.strings[key] && isNumber(val)
-	            ? Number(val) : val
-	        ;
-	        setKey(argv, key.split('.'), value);
-	        (aliases[key] || []).forEach(function (x) {
-	            setKey(argv, x.split('.'), value);
-	        });
-	    }
+	function aliasIsBoolean(key) {
+		return aliases[key].some(function (x) {
+			return flags.bools[x];
+		});
+	}
-	    function setKey (obj, keys, value) {
-	        var o = obj;
-	        for (var i = 0; i < keys.length-1; i++) {
-	            var key = keys[i];
-	            if (isConstructorOrProto(o, key)) return;
-	            if (o[key] === undefined) o[key] = {};
-	            if (o[key] === Object.prototype || o[key] === Number.prototype
-	                || o[key] === String.prototype) o[key] = {};
-	            if (o[key] === Array.prototype) o[key] = [];
-	            o = o[key];
-	        }
+	Object.keys(opts.alias || {}).forEach(function (key) {
+		aliases[key] = [].concat(opts.alias[key]);
+		aliases[key].forEach(function (x) {
+			aliases[x] = [key].concat(aliases[key].filter(function (y) {
+				return x !== y;
+			}));
+		});
+	});
-	        var key = keys[keys.length - 1];
-	        if (isConstructorOrProto(o, key)) return;
-	        if (o === Object.prototype || o === Number.prototype
-	            || o === String.prototype) o = {};
-	        if (o === Array.prototype) o = [];
-	        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
-	            o[key] = value;
-	        }
-	        else if (Array.isArray(o[key])) {
-	            o[key].push(value);
-	        }
-	        else {
-	            o[key] = [ o[key], value ];
-	        }
-	    }
-	    function aliasIsBoolean(key) {
-	      return aliases[key].some(function (x) {
-	          return flags.bools[x];
-	      });
-	    }
+	[].concat(opts.string).filter(Boolean).forEach(function (key) {
+		flags.strings[key] = true;
+		if (aliases[key]) {
+			[].concat(aliases[key]).forEach(function (k) {
+				flags.strings[k] = true;
+			});
+		}
+	});
-	    for (var i = 0; i < args.length; i++) {
-	        var arg = args[i];
-	        if (/^--.+=/.test(arg)) {
-	            // Using [\s\S] instead of . because js doesn't support the
-	            // 'dotall' regex modifier. See:
-	            // http://stackoverflow.com/a/1068308/13216
-	            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-	            var key = m[1];
-	            var value = m[2];
-	            if (flags.bools[key]) {
-	                value = value !== 'false';
-	            }
-	            setArg(key, value, arg);
-	        }
-	        else if (/^--no-.+/.test(arg)) {
-	            var key = arg.match(/^--no-(.+)/)[1];
-	            setArg(key, false, arg);
-	        }
-	        else if (/^--.+/.test(arg)) {
-	            var key = arg.match(/^--(.+)/)[1];
-	            var next = args[i + 1];
-	            if (next !== undefined && !/^-/.test(next)
-	            && !flags.bools[key]
-	            && !flags.allBools
-	            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-	                setArg(key, next, arg);
-	                i++;
-	            }
-	            else if (/^(true|false)$/.test(next)) {
-	                setArg(key, next === 'true', arg);
-	                i++;
-	            }
-	            else {
-	                setArg(key, flags.strings[key] ? '' : true, arg);
-	            }
-	        }
-	        else if (/^-[^-]+/.test(arg)) {
-	            var letters = arg.slice(1,-1).split('');
-	            var broken = false;
-	            for (var j = 0; j < letters.length; j++) {
-	                var next = arg.slice(j+2);
-	                if (next === '-') {
-	                    setArg(letters[j], next, arg);
-	                    continue;
-	                }
-	                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
-	                    setArg(letters[j], next.split('=')[1], arg);
-	                    broken = true;
-	                    break;
-	                }
-	                if (/[A-Za-z]/.test(letters[j])
-	                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-	                    setArg(letters[j], next, arg);
-	                    broken = true;
-	                    break;
-	                }
-	                if (letters[j+1] && letters[j+1].match(/\W/)) {
-	                    setArg(letters[j], arg.slice(j+2), arg);
-	                    broken = true;
-	                    break;
-	                }
-	                else {
-	                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
-	                }
-	            }
-	            var key = arg.slice(-1)[0];
-	            if (!broken && key !== '-') {
-	                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
-	                && !flags.bools[key]
-	                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-	                    setArg(key, args[i+1], arg);
-	                    i++;
-	                }
-	                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
-	                    setArg(key, args[i+1] === 'true', arg);
-	                    i++;
-	                }
-	                else {
-	                    setArg(key, flags.strings[key] ? '' : true, arg);
-	                }
-	            }
-	        }
-	        else {
-	            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-	                argv._.push(
-	                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-	                );
-	            }
-	            if (opts.stopEarly) {
-	                argv._.push.apply(argv._, args.slice(i + 1));
-	                break;
-	            }
-	        }
-	    }
-	    Object.keys(defaults).forEach(function (key) {
-	        if (!hasKey(argv, key.split('.'))) {
-	            setKey(argv, key.split('.'), defaults[key]);
-	            (aliases[key] || []).forEach(function (x) {
-	                setKey(argv, x.split('.'), defaults[key]);
-	            });
-	        }
-	    });
-	    if (opts['--']) {
-	        argv['--'] = new Array();
-	        notFlags.forEach(function(key) {
-	            argv['--'].push(key);
-	        });
-	    }
-	    else {
-	        notFlags.forEach(function(key) {
-	            argv._.push(key);
-	        });
-	    }
+	var defaults = opts.default || {};
-	    return argv;
-	};
+	var argv = { _: [] };
-	function hasKey (obj, keys) {
-	    var o = obj;
-	    keys.slice(0,-1).forEach(function (key) {
-	        o = (o[key] || {});
-	    });
+	function argDefined(key, arg) {
+		return (flags.allBools && (/^--[^=]+$/).test(arg))
+			|| flags.strings[key]
+			|| flags.bools[key]
+			|| aliases[key];
+	}
+	function setKey(obj, keys, value) {
+		var o = obj;
+		for (var i = 0; i < keys.length - 1; i++) {
+			var key = keys[i];
+			if (isConstructorOrProto(o, key)) { return; }
+			if (o[key] === undefined) { o[key] = {}; }
+			if (
+				o[key] === Object.prototype
+				|| o[key] === Number.prototype
+				|| o[key] === String.prototype
+			) {
+				o[key] = {};
+			}
+			if (o[key] === Array.prototype) { o[key] = []; }
+			o = o[key];
+		}
-	    var key = keys[keys.length - 1];
-	    return key in o;
+		var lastKey = keys[keys.length - 1];
+		if (isConstructorOrProto(o, lastKey)) { return; }
+		if (
+			o === Object.prototype
+			|| o === Number.prototype
+			|| o === String.prototype
+		) {
+			o = {};
+		}
+		if (o === Array.prototype) { o = []; }
+		if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') {
+			o[lastKey] = value;
+		} else if (Array.isArray(o[lastKey])) {
+			o[lastKey].push(value);
+		} else {
+			o[lastKey] = [o[lastKey], value];
+		}
 	}
-	function isNumber (x) {
-	    if (typeof x === 'number') return true;
-	    if (/^0x[0-9a-f]+$/i.test(x)) return true;
-	    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+	function setArg(key, val, arg) {
+		if (arg && flags.unknownFn && !argDefined(key, arg)) {
+			if (flags.unknownFn(arg) === false) { return; }
+		}
+		var value = !flags.strings[key] && isNumber(val)
+			? Number(val)
+			: val;
+		setKey(argv, key.split('.'), value);
+		(aliases[key] || []).forEach(function (x) {
+			setKey(argv, x.split('.'), value);
+		});
 	}
+	Object.keys(flags.bools).forEach(function (key) {
+		setArg(key, defaults[key] === undefined ? false : defaults[key]);
+	});
+	var notFlags = [];
-	function isConstructorOrProto (obj, key) {
-	    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+	if (args.indexOf('--') !== -1) {
+		notFlags = args.slice(args.indexOf('--') + 1);
+		args = args.slice(0, args.indexOf('--'));
 	}
-	return minimist;
-}
-/*global require,module,process*/
+	for (var i = 0; i < args.length; i++) {
+		var arg = args[i];
+		var key;
+		var next;
+		if ((/^--.+=/).test(arg)) {
+			// Using [\s\S] instead of . because js doesn't support the
+			// 'dotall' regex modifier. See:
+			// http://stackoverflow.com/a/1068308/13216
+			var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+			key = m[1];
+			var value = m[2];
+			if (flags.bools[key]) {
+				value = value !== 'false';
+			}
+			setArg(key, value, arg);
+		} else if ((/^--no-.+/).test(arg)) {
+			key = arg.match(/^--no-(.+)/)[1];
+			setArg(key, false, arg);
+		} else if ((/^--.+/).test(arg)) {
+			key = arg.match(/^--(.+)/)[1];
+			next = args[i + 1];
+			if (
+				next !== undefined
+				&& !(/^(-|--)[^-]/).test(next)
+				&& !flags.bools[key]
+				&& !flags.allBools
+				&& (aliases[key] ? !aliasIsBoolean(key) : true)
+			) {
+				setArg(key, next, arg);
+				i += 1;
+			} else if ((/^(true|false)$/).test(next)) {
+				setArg(key, next === 'true', arg);
+				i += 1;
+			} else {
+				setArg(key, flags.strings[key] ? '' : true, arg);
+			}
+		} else if ((/^-[^-]+/).test(arg)) {
+			var letters = arg.slice(1, -1).split('');
+			var broken = false;
+			for (var j = 0; j < letters.length; j++) {
+				next = arg.slice(j + 2);
-const fs = fs__default["default"];
-const path = path__default["default"];
-const appPath = appRootPath;
-const xdg = xdgBasedir;
+				if (next === '-') {
+					setArg(letters[j], next, arg);
+					continue;
+				}
-function split(data)
-{
+				if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') {
+					setArg(letters[j], next.slice(1), arg);
+					broken = true;
+					break;
+				}
+				if (
+					(/[A-Za-z]/).test(letters[j])
+					&& (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next)
+				) {
+					setArg(letters[j], next, arg);
+					broken = true;
+					break;
+				}
+				if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+					setArg(letters[j], arg.slice(j + 2), arg);
+					broken = true;
+					break;
+				} else {
+					setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+				}
+			}
+			key = arg.slice(-1)[0];
+			if (!broken && key !== '-') {
+				if (
+					args[i + 1]
+					&& !(/^(-|--)[^-]/).test(args[i + 1])
+					&& !flags.bools[key]
+					&& (aliases[key] ? !aliasIsBoolean(key) : true)
+				) {
+					setArg(key, args[i + 1], arg);
+					i += 1;
+				} else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) {
+					setArg(key, args[i + 1] === 'true', arg);
+					i += 1;
+				} else {
+					setArg(key, flags.strings[key] ? '' : true, arg);
+				}
+			}
+		} else {
+			if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+				argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+			}
+			if (opts.stopEarly) {
+				argv._.push.apply(argv._, args.slice(i + 1));
+				break;
+			}
+		}
+	}
+	Object.keys(defaults).forEach(function (k) {
+		if (!hasKey(argv, k.split('.'))) {
+			setKey(argv, k.split('.'), defaults[k]);
+			(aliases[k] || []).forEach(function (x) {
+				setKey(argv, x.split('.'), defaults[k]);
+			});
+		}
+	});
+	if (opts['--']) {
+		argv['--'] = notFlags.slice();
+	} else {
+		notFlags.forEach(function (k) {
+			argv._.push(k);
+		});
+	}
+	return argv;
+};
+function split(data) {
     const pre = data.split("\n");
     // rejoin with lines that starts with a whitespace
     const out = [];
@@ -53775,7 +53771,8 @@ function split(data)
                 --idx;
             if (idx < cur.length - 1)
                 cur = cur.substr(0, idx + 1);
-        } else if (cur.length > 0) {
+        }
+        else if (cur.length > 0) {
             out.push(cur.trim());
             cur = line.trim();
         }
@@ -53785,9 +53782,7 @@ function split(data)
     }
     return out;
 }
-function realValue(v)
-{
+function realValue(v) {
     if (typeof v !== "string")
         return v;
     if (/^[-0-9.]+$/.exec(v)) {
@@ -53796,119 +53791,130 @@ function realValue(v)
             return vf;
     }
     switch (v) {
-    case "true":
-        return true;
-    case "false":
-        return false;
+        case "true":
+            return true;
+        case "false":
+            return false;
     }
     return v;
 }
-class Options {
+class Engine {
+    argv;
+    prefix;
+    additionalFiles;
+    applicationPath;
+    debug;
+    options;
+    configDirs;
     constructor(options, argv) {
         this.argv = Object.assign({}, argv);
         this.prefix = options.prefix;
         this.additionalFiles = options.additionalFiles || [];
-        this.applicationPath = options.noApplicationPath ? "" : appPath.toString();
-        this.debug = options.debug;
+        this.applicationPath = options.noApplicationPath ? "" : appRootPath.toString();
+        this.debug = options.debug ?? false;
         this.options = {};
-        this.configDirs = this.argv["config-dir"] ||  options.configDirs || xdg.configDirs;
+        this.configDirs = this.argv["config-dir"] || options.configDirs || xdgBasedir.configDirs;
         this._read();
     }
     value(name) {
         // foo-bar becomes FOO_BAR as env
-        if (name in this.argv)
+        if (name in this.argv) {
             return this.argv[name];
+        }
         const envname = (this.prefix + "_" + name).replace(/-/g, "_").toUpperCase();
-        if (envname in process.env)
+        if (envname in process.env) {
             return realValue(process.env[envname]);
-        if (name in this.options)
+        }
+        if (name in this.options) {
             return this.options[name];
+        }
         return undefined;
     }
+    string(name) {
+        const ret = this.value(name);
+        if (ret === undefined) {
+            return undefined;
+        }
+        return String(ret);
+    }
     _homedir() {
         let home = process.env.home;
         if (home) {
-            return path.join(home, ".config");
+            return path__default["default"].join(home, ".config");
         }
         return undefined;
     }
     _log(...args) {
         if (this.debug)
             console.log(...args);
     }
     _read() {
         // if we have a config file passed, read it
-        let file = this.value("config-file");
+        let file = this.string("config-file");
         if (!file && this.prefix)
             file = this.prefix + ".conf";
         if (!file)
             return;
         let data = [];
         let seen = new Set();
-        const Failed = 0;
-        const Success = 1;
-        const Seen = 2;
-        const read = file => {
+        const read = (file) => {
             if (seen.has(file))
-                return Seen;
+                return 2 /* OptionsReadResult.Seen */;
             seen.add(file);
             try {
-                const contents = fs.readFileSync(file, "utf8");
+                const contents = fs__default["default"].readFileSync(file, "utf8");
                 this._log(`Loaded ${contents.length} bytes from ${file}`);
                 if (contents) {
-                    data.push({ file: file, contents: contents });
-                    return Success;
+                    data.push({ file, contents });
+                    return 1 /* OptionsReadResult.Success */;
                 }
-            } catch (e) {
+            }
+            catch (e) {
                 this._log(`Failed to load ${file}`);
             }
-            return Failed;
+            return 0 /* OptionsReadResult.Failed */;
         };
         // console.log("about to read file", file, "additionalFiles", this.additionalFiles, "configDirs", this.configDirs, "applicationPath", this.applicationPath, "homedir", this._homedir());
-        if (path.isAbsolute(file)) {
+        if (path__default["default"].isAbsolute(file)) {
             read(file);
-        } else {
+        }
+        else {
             this.additionalFiles.forEach(file => {
-                if (path.isAbsolute(file) && read(file) == Failed)
+                if (path__default["default"].isAbsolute(file) && read(file) == 0 /* OptionsReadResult.Failed */) {
                     read(file + ".conf");
+                }
             });
             ([this.applicationPath, this._homedir()].concat(this.configDirs)).forEach(root => {
                 // in case we appended with undefined
-                if (!root)
+                if (!root) {
                     return;
+                }
                 this.additionalFiles.forEach(additional => {
-                    if (!path.isAbsolute(additional)) {
-                        let file = path.join(root, additional);
-                        if (read(file) == Failed)
+                    if (!path__default["default"].isAbsolute(additional)) {
+                        let file = path__default["default"].join(root, additional);
+                        if (read(file) == 0 /* OptionsReadResult.Failed */)
                             read(file + ".conf");
                     }
                 });
-                let filePath = path.join(root, file);
-                if (read(filePath) == Failed)
+                let filePath = path__default["default"].join(root, file);
+                if (read(filePath) == 0 /* OptionsReadResult.Failed */) {
                     read(filePath + ".conf");
+                }
             });
         }
         for (let i = data.length - 1; i >= 0; --i) {
             let str = data[i].contents;
-            if (!str)
+            if (!str) {
                 continue;
+            }
             try {
                 let obj = JSON.parse(str);
                 for (let key in obj) {
                     this._log(`Assigning ${JSON.stringify(obj[key])} over ${JSON.stringify(this.options[key])} for ${key} from ${data[i].file} (JSON)`);
                     this.options[key] = obj[key];
                 }
-            } catch (err) {
+            }
+            catch (err) {
                 const items = split(str);
                 for (let j = 0; j < items.length; ++j) {
                     const item = items[j].trim();
@@ -53921,12 +53927,12 @@ class Options {
                         this._log("Couldn't find =", item);
                         continue;
                     }
-                    const key = item.substr(0, eq).trim();
+                    const key = item.substring(0, eq).trim();
                     if (!key.length) {
                         this._log("empty key", item);
                         continue;
                     }
-                    const value = item.substr(eq + 1).trim();
+                    const value = item.substring(eq + 1).trim();
                     this._log(`Assigning ${value} over ${this.options[key]} for ${key} from ${data[i].file} (INI)`);
                     this.options[key] = value;
                 }
@@ -53934,37 +53940,34 @@ class Options {
         }
     }
 }
-const data = {};
-var options = function(options, argv) {
-    if (!argv)
-        argv = requireMinimist()(process.argv.slice(2));
-    if (!(options instanceof Object))
-        options = { prefix: options || "" };
-    data.options = new Options(options, argv);
-    let ret = function(name, defaultValue) {
-        const val = data.options.value(name);
-        if (typeof val === "undefined")
+function options (optionsOptions, argv) {
+    if (!argv) {
+        argv = minimist(process.argv.slice(2));
+    }
+    if (!(optionsOptions instanceof Object)) {
+        optionsOptions = { prefix: optionsOptions || "" };
+    }
+    const engine = new Engine(optionsOptions, argv);
+    function value(name, defaultValue) {
+        const val = engine.value(name);
+        if (val === undefined)
             return defaultValue;
         return val;
-    };
-    ret.prefix = options.prefix;
-    ret.int = function(name, defaultValue) {
-        const v = parseInt(data.options.value(name));
+    }
+    function float(name, defaultValue) {
+        const v = parseFloat(engine.string(name) || "");
         if (typeof v === "number" && !isNaN(v))
             return v;
         return defaultValue;
-    };
-    ret.float = function(name, defaultValue) {
-        const v = parseFloat(data.options.value(name));
+    }
+    function int(name, defaultValue) {
+        const v = parseInt(engine.string(name) || "");
         if (typeof v === "number" && !isNaN(v))
             return v;
         return defaultValue;
-    };
-    ret.json = function(name, defaultValue) {
-        const opt = data.options.value(name);
+    }
+    function json(name, defaultValue) {
+        const opt = engine.value(name);
         if (opt === undefined)
             return defaultValue;
         if (typeof opt !== "string")
@@ -53972,12 +53975,22 @@ var options = function(options, argv) {
         try {
             const json = JSON.parse(opt);
             return json;
-        } catch (e) {
+        }
+        catch (e) {
         }
         return defaultValue;
-    };
-    return ret;
-};
+    }
+    function string(name, defaultValue) {
+        return engine.string(name) ?? defaultValue;
+    }
+    return Object.assign(value, {
+        prefix: optionsOptions.prefix,
+        float,
+        int,
+        json,
+        string,
+    });
+}
 const option = options({
     prefix: "fisk/scheduler",
@@ -54005,7 +54018,7 @@ server.on("error", (error) => {
 });
 let schedulerNpmVersion;
 try {
-    schedulerNpmVersion = String(JSON.parse(fs$5.readFileSync(path__default["default"].join(__dirname, "../package.json"), "utf8")).version);
+    schedulerNpmVersion = String(JSON.parse(fs$4.readFileSync(path__default["default"].join(__dirname, "../package.json"), "utf8")).version);
 }
 catch (err) {
     console.log("Couldn't parse package json", err);
@@ -54025,7 +54038,7 @@ const db = new Database(path__default["default"].join(common.cacheDir(), "db.jso
 let objectCache;
 const logFileDir = path__default["default"].join(common.cacheDir(), "logs");
 try {
-    fs$5.mkdirSync(logFileDir);
+    fs$4.mkdirSync(logFileDir);
 }
 catch (err) {
     /* */
@@ -54266,14 +54279,14 @@ function purgeEnvironmentsToMaxSize() {
         const p = Environments.instance.path;
         try {
             let purged = false;
-            fs$5.readdirSync(p)
+            fs$4.readdirSync(p)
                 .map((file) => {
                 // console.log("got file", file);
                 const abs = path__default["default"].join(p, file);
                 if (file.length !== 47 || file.indexOf(".tar.gz", 40) !== 40) {
                     try {
                         console.log("Removing unexpected file", abs);
-                        fs$5.removeSync(abs);
+                        fs$4.removeSync(abs);
                     }
                     catch (err) {
                         console.error("Failed to remove file", abs, err);
@@ -54282,7 +54295,7 @@ function purgeEnvironmentsToMaxSize() {
                 }
                 let stat;
                 try {
-                    stat = fs$5.statSync(abs);
+                    stat = fs$4.statSync(abs);
                 }
                 catch (err) {
                     return undefined;
@@ -54490,7 +54503,7 @@ server.on("listen", (app) => {
             res.sendStatus(404);
             return;
         }
-        const rstream = fs$5.createReadStream(env.path);
+        const rstream = fs$4.createReadStream(env.path);
         rstream.on("error", (err) => {
             console.error("Got read stream error for", env.path, err);
             rstream.close();
@@ -54501,7 +54514,7 @@ server.on("listen", (app) => {
         console.log("quitting", req.query);
         if ("purge_environments" in req.query) {
             try {
-                fs$5.removeSync(path__default["default"].join(common.cacheDir(), "environments"));
+                fs$4.removeSync(path__default["default"].join(common.cacheDir(), "environments"));
             }
             catch (err) {
                 /* */
@@ -54575,7 +54588,7 @@ ${msg.stdout ? "stdout:\n" + msg.stdout + "\n" : ""}${msg.stderr ? "stderr:\n" +
 });
 function updateLogFilesToMonitors() {
     if (monitors.length) {
-        fs$5.readdir(logFileDir, (err, files) => {
+        fs$4.readdir(logFileDir, (err, files) => {
             if (files) {
                 files = files.reverse();
             }
@@ -54588,13 +54601,13 @@ function updateLogFilesToMonitors() {
     }
 }
 function clearLogFiles() {
-    fs$5.readdir(logFileDir, (err, files) => {
+    fs$4.readdir(logFileDir, (err, files) => {
         if (err) {
             console.log("Got error removing log files", err);
             return;
         }
         for (const file of files) {
-            fs$5.unlink(path__default["default"].join(logFileDir, file), (error) => {
+            fs$4.unlink(path__default["default"].join(logFileDir, file), (error) => {
                 if (error) {
                     console.log("failed to remove file", path__default["default"].join(logFileDir, file), error);
                 }
@@ -54604,7 +54617,7 @@ function clearLogFiles() {
     });
 }
 try {
-    fs$5.watch(logFileDir, (type) => {
+    fs$4.watch(logFileDir, (type) => {
         if (type === "rename") {
             updateLogFilesToMonitors();
         }
@@ -54639,7 +54652,7 @@ function formatDate(date) {
 }
 function addLogFile(log) {
     try {
-        fs$5.writeFileSync(path__default["default"].join(logFileDir, `${formatDate(new Date())} ${log.source} ${log.ip}`), log.contents);
+        fs$4.writeFileSync(path__default["default"].join(logFileDir, `${formatDate(new Date())} ${log.source} ${log.ip}`), log.contents);
     }
     catch (err) {
         console.error(`Failed to write log file from ${log.ip}`, err);
@@ -55055,7 +55068,7 @@ server.on("monitor", (client) => {
                 break;
             case "logFiles":
                 // console.log("logFiles:", message);
-                fs$5.readdir(logFileDir, (err, files) => {
+                fs$4.readdir(logFileDir, (err, files) => {
                     if (files) {
                         files = files.reverse();
                     }
@@ -55070,7 +55083,7 @@ server.on("monitor", (client) => {
                     return;
                 }
                 const f = path__default["default"].join(logFileDir, message.file);
-                fs$5.readFile(f, "utf8", (err, contents) => {
+                fs$4.readFile(f, "utf8", (err, contents) => {
                     // console.log("sending file", f, contents.length);
                     client.send({ type: "logFile", file: f, contents: contents || "" });
                 });