@andersbakken/fisk 4.0.2 → 4.0.4

package/scheduler/fisk-scheduler.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs$o = require('fs');
+var fs$p = require('fs');
 var assert$1 = require('assert');
 var require$$0$3 = require('constants');
 var require$$0$4 = require('stream');
@@ -9,12 +9,12 @@ var require$$4$1 = require('util');
 var path$l = require('path');
 var require$$1$1 = require('os');
 var child_process = require('child_process');
-var crypto$1 = require('crypto');
 var require$$0$5 = require('events');
 var require$$1$2 = require('https');
 var require$$2$2 = require('http');
 var require$$3$1 = require('net');
 var require$$4$2 = require('tls');
+var crypto$1 = require('crypto');
 var require$$6$1 = require('url');
 var require$$0$6 = require('zlib');
 var require$$0$7 = require('tty');
@@ -26,7 +26,7 @@ var posix = require('posix');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$o);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$p);
 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);
@@ -34,12 +34,12 @@ var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4$1);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path$l);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
-var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto$1);
 var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$5);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2$2);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
 var require$$4__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$4$2);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto$1);
 var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6$1);
 var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
 var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$7);
@@ -241,7 +241,7 @@ var lib$3 = {
   set exports(v){ libExports$1 = v; },
 };
 
-var fs$n = {};
+var fs$o = {};
 
 var universalify = {};
 
@@ -766,7 +766,7 @@ function clone$1 (obj) {
   return copy
 }
 
-var fs$m = fs__default["default"];
+var fs$n = fs__default["default"];
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone = clone_1;
@@ -808,18 +808,18 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   };
 
 // Once time initialization
-if (!fs$m[gracefulQueue]) {
+if (!fs$n[gracefulQueue]) {
   // This queue can be shared by multiple loaded instances
   var queue = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs$m, queue);
+  publishQueue(fs$n, 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$m.close = (function (fs$close) {
+  fs$n.close = (function (fs$close) {
     function close (fd, cb) {
-      return fs$close.call(fs$m, fd, function (err) {
+      return fs$close.call(fs$n, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
@@ -834,12 +834,12 @@ if (!fs$m[gracefulQueue]) {
       value: fs$close
     });
     return close
-  })(fs$m.close);
+  })(fs$n.close);
 
-  fs$m.closeSync = (function (fs$closeSync) {
+  fs$n.closeSync = (function (fs$closeSync) {
     function closeSync (fd) {
       // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs$m, arguments);
+      fs$closeSync.apply(fs$n, arguments);
       resetQueue();
     }
 
@@ -847,24 +847,24 @@ if (!fs$m[gracefulQueue]) {
       value: fs$closeSync
     });
     return closeSync
-  })(fs$m.closeSync);
+  })(fs$n.closeSync);
 
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
     process.on('exit', function() {
-      debug$7(fs$m[gracefulQueue]);
-      assert__default["default"].equal(fs$m[gracefulQueue].length, 0);
+      debug$7(fs$n[gracefulQueue]);
+      assert__default["default"].equal(fs$n[gracefulQueue].length, 0);
     });
   }
 }
 
 if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs$m[gracefulQueue]);
+  publishQueue(commonjsGlobal, fs$n[gracefulQueue]);
 }
 
-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;
+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;
 }
 
 function patch (fs) {
@@ -1138,7 +1138,7 @@ function patch (fs) {
 
 function enqueue (elem) {
   debug$7('ENQUEUE', elem[0].name, elem[1]);
-  fs$m[gracefulQueue].push(elem);
+  fs$n[gracefulQueue].push(elem);
   retry();
 }
 
@@ -1150,12 +1150,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$m[gracefulQueue].length; ++i) {
+  for (var i = 0; i < fs$n[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$m[gracefulQueue][i].length > 2) {
-      fs$m[gracefulQueue][i][3] = now; // startTime
-      fs$m[gracefulQueue][i][4] = now; // lastTime
+    if (fs$n[gracefulQueue][i].length > 2) {
+      fs$n[gracefulQueue][i][3] = now; // startTime
+      fs$n[gracefulQueue][i][4] = now; // lastTime
     }
   }
   // call retry to make sure we're actively processing the queue
@@ -1167,10 +1167,10 @@ function retry () {
   clearTimeout(retryTimer);
   retryTimer = undefined;
 
-  if (fs$m[gracefulQueue].length === 0)
+  if (fs$n[gracefulQueue].length === 0)
     return
 
-  var elem = fs$m[gracefulQueue].shift();
+  var elem = fs$n[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
   // these items may be unset if they were added by an older graceful-fs
@@ -1205,7 +1205,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$m[gracefulQueue].push(elem);
+      fs$n[gracefulQueue].push(elem);
     }
   }
 
@@ -1318,7 +1318,7 @@ function retry () {
 	    });
 	  })
 	};
-} (fs$n));
+} (fs$o));
 
 const path$k = path__default["default"];
 
@@ -1344,7 +1344,7 @@ var win32 = {
   invalidWin32Path: invalidWin32Path$2
 };
 
-const fs$l = gracefulFs;
+const fs$m = gracefulFs;
 const path$j = path__default["default"];
 const invalidWin32Path$1 = win32.invalidWin32Path;
 
@@ -1365,7 +1365,7 @@ function mkdirs$2 (p, opts, callback, made) {
   }
 
   let mode = opts.mode;
-  const xfs = opts.fs || fs$l;
+  const xfs = opts.fs || fs$m;
 
   if (mode === undefined) {
     mode = o777$1 & (~process.umask());
@@ -1406,7 +1406,7 @@ function mkdirs$2 (p, opts, callback, made) {
 
 var mkdirs_1$1 = mkdirs$2;
 
-const fs$k = gracefulFs;
+const fs$l = gracefulFs;
 const path$i = path__default["default"];
 const invalidWin32Path = win32.invalidWin32Path;
 
@@ -1418,7 +1418,7 @@ function mkdirsSync$2 (p, opts, made) {
   }
 
   let mode = opts.mode;
-  const xfs = opts.fs || fs$k;
+  const xfs = opts.fs || fs$l;
 
   if (process.platform === 'win32' && invalidWin32Path(p)) {
     const errInval = new Error(p + ' contains invalid WIN32 path characters.');
@@ -1473,7 +1473,7 @@ var mkdirs_1 = {
   ensureDirSync: mkdirsSync$1
 };
 
-const fs$j = gracefulFs;
+const fs$k = gracefulFs;
 const os = require$$1__default["default"];
 const path$h = path__default["default"];
 
@@ -1484,11 +1484,11 @@ function hasMillisResSync () {
 
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  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
+  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
 }
 
 function hasMillisRes (callback) {
@@ -1497,15 +1497,15 @@ function hasMillisRes (callback) {
 
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  fs$j.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
+  fs$k.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
     if (err) return callback(err)
-    fs$j.open(tmpfile, 'r+', (err, fd) => {
+    fs$k.open(tmpfile, 'r+', (err, fd) => {
       if (err) return callback(err)
-      fs$j.futimes(fd, d, d, err => {
+      fs$k.futimes(fd, d, d, err => {
         if (err) return callback(err)
-        fs$j.close(fd, err => {
+        fs$k.close(fd, err => {
           if (err) return callback(err)
-          fs$j.stat(tmpfile, (err, stats) => {
+          fs$k.stat(tmpfile, (err, stats) => {
             if (err) return callback(err)
             callback(null, stats.mtime > 1435410243000);
           });
@@ -1527,10 +1527,10 @@ function timeRemoveMillis (timestamp) {
 
 function utimesMillis (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  fs$j.open(path, 'r+', (err, fd) => {
+  fs$k.open(path, 'r+', (err, fd) => {
     if (err) return callback(err)
-    fs$j.futimes(fd, atime, mtime, futimesErr => {
-      fs$j.close(fd, closeErr => {
+    fs$k.futimes(fd, atime, mtime, futimesErr => {
+      fs$k.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
       });
     });
@@ -1538,9 +1538,9 @@ function utimesMillis (path, atime, mtime, callback) {
 }
 
 function utimesMillisSync (path, atime, mtime) {
-  const fd = fs$j.openSync(path, 'r+');
-  fs$j.futimesSync(fd, atime, mtime);
-  return fs$j.closeSync(fd)
+  const fd = fs$k.openSync(path, 'r+');
+  fs$k.futimesSync(fd, atime, mtime);
+  return fs$k.closeSync(fd)
 }
 
 var utimes$1 = {
@@ -1563,7 +1563,7 @@ var buffer$1 = function (size) {
   return new Buffer(size)
 };
 
-const fs$i = gracefulFs;
+const fs$j = gracefulFs;
 const path$g = path__default["default"];
 const mkdirpSync$1 = mkdirs_1.mkdirsSync;
 const utimesSync = utimes$1.utimesMillisSync;
@@ -1591,7 +1591,7 @@ function copySync$2 (src, dest, opts) {
   if (opts.filter && !opts.filter(src, dest)) return
 
   const destParent = path$g.dirname(dest);
-  if (!fs$i.existsSync(destParent)) mkdirpSync$1(destParent);
+  if (!fs$j.existsSync(destParent)) mkdirpSync$1(destParent);
   return startCopy$1(resolvedDest, src, dest, opts)
 }
 
@@ -1601,7 +1601,7 @@ function startCopy$1 (resolvedDest, src, dest, opts) {
 }
 
 function getStats$1 (resolvedDest, src, dest, opts) {
-  const statSync = opts.dereference ? fs$i.statSync : fs$i.lstatSync;
+  const statSync = opts.dereference ? fs$j.statSync : fs$j.lstatSync;
   const st = statSync(src);
 
   if (st.isDirectory()) return onDir$1(st, resolvedDest, src, dest, opts)
@@ -1619,7 +1619,7 @@ function onFile$1 (srcStat, resolvedDest, src, dest, opts) {
 
 function mayCopyFile$1 (srcStat, src, dest, opts) {
   if (opts.overwrite) {
-    fs$i.unlinkSync(dest);
+    fs$j.unlinkSync(dest);
     return copyFile$1(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
     throw new Error(`'${dest}' already exists`)
@@ -1627,9 +1627,9 @@ function mayCopyFile$1 (srcStat, src, dest, opts) {
 }
 
 function copyFile$1 (srcStat, src, dest, opts) {
-  if (typeof fs$i.copyFileSync === 'function') {
-    fs$i.copyFileSync(src, dest);
-    fs$i.chmodSync(dest, srcStat.mode);
+  if (typeof fs$j.copyFileSync === 'function') {
+    fs$j.copyFileSync(src, dest);
+    fs$j.chmodSync(dest, srcStat.mode);
     if (opts.preserveTimestamps) {
       return utimesSync(dest, srcStat.atime, srcStat.mtime)
     }
@@ -1642,20 +1642,20 @@ function copyFileFallback$1 (srcStat, src, dest, opts) {
   const BUF_LENGTH = 64 * 1024;
   const _buff = buffer$1(BUF_LENGTH);
 
-  const fdr = fs$i.openSync(src, 'r');
-  const fdw = fs$i.openSync(dest, 'w', srcStat.mode);
+  const fdr = fs$j.openSync(src, 'r');
+  const fdw = fs$j.openSync(dest, 'w', srcStat.mode);
   let pos = 0;
 
   while (pos < srcStat.size) {
-    const bytesRead = fs$i.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$i.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$j.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$j.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
 
-  if (opts.preserveTimestamps) fs$i.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+  if (opts.preserveTimestamps) fs$j.futimesSync(fdw, srcStat.atime, srcStat.mtime);
 
-  fs$i.closeSync(fdr);
-  fs$i.closeSync(fdw);
+  fs$j.closeSync(fdr);
+  fs$j.closeSync(fdw);
 }
 
 function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
@@ -1674,20 +1674,20 @@ function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
 }
 
 function mayCopyDir$1 (src, dest, opts) {
-  if (!fs$i.statSync(dest).isDirectory()) {
+  if (!fs$j.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$i.mkdirSync(dest, srcStat.mode);
-  fs$i.chmodSync(dest, srcStat.mode);
+  fs$j.mkdirSync(dest, srcStat.mode);
+  fs$j.chmodSync(dest, srcStat.mode);
   return copyDir$1(src, dest, opts)
 }
 
 function copyDir$1 (src, dest, opts) {
-  fs$i.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
+  fs$j.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
 }
 
 function copyDirItem$1 (item, src, dest, opts) {
@@ -1698,7 +1698,7 @@ function copyDirItem$1 (item, src, dest, opts) {
 }
 
 function onLink$1 (resolvedDest, src, dest, opts) {
-  let resolvedSrc = fs$i.readlinkSync(src);
+  let resolvedSrc = fs$j.readlinkSync(src);
 
   if (opts.dereference) {
     resolvedSrc = path$g.resolve(process.cwd(), resolvedSrc);
@@ -1707,7 +1707,7 @@ function onLink$1 (resolvedDest, src, dest, opts) {
   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$i.symlinkSync(resolvedSrc, dest)
+    return fs$j.symlinkSync(resolvedSrc, dest)
   } else {
     if (opts.dereference) {
       resolvedDest = path$g.resolve(process.cwd(), resolvedDest);
@@ -1717,7 +1717,7 @@ function onLink$1 (resolvedDest, src, dest, opts) {
     // 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$i.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
+    if (fs$j.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
     return copyLink$1(resolvedSrc, dest)
@@ -1725,8 +1725,8 @@ function onLink$1 (resolvedDest, src, dest, opts) {
 }
 
 function copyLink$1 (resolvedSrc, dest) {
-  fs$i.unlinkSync(dest);
-  return fs$i.symlinkSync(resolvedSrc, dest)
+  fs$j.unlinkSync(dest);
+  return fs$j.symlinkSync(resolvedSrc, dest)
 }
 
 // return true if dest is a subdir of src, otherwise false.
@@ -1744,7 +1744,7 @@ function isSrcSubdir$3 (src, dest) {
 function checkDest$1 (dest) {
   let resolvedPath;
   try {
-    resolvedPath = fs$i.readlinkSync(dest);
+    resolvedPath = fs$j.readlinkSync(dest);
   } catch (err) {
     if (err.code === 'ENOENT') return notExist$1
 
@@ -1786,18 +1786,18 @@ var copySync$1 = {
 };
 
 const u$a = universalify.fromPromise;
-const fs$h = fs$n;
+const fs$i = fs$o;
 
 function pathExists$8 (path) {
-  return fs$h.access(path).then(() => true).catch(() => false)
+  return fs$i.access(path).then(() => true).catch(() => false)
 }
 
 var pathExists_1 = {
   pathExists: u$a(pathExists$8),
-  pathExistsSync: fs$h.existsSync
+  pathExistsSync: fs$i.existsSync
 };
 
-const fs$g = gracefulFs;
+const fs$h = gracefulFs;
 const path$f = path__default["default"];
 const mkdirp$1 = mkdirs_1.mkdirs;
 const pathExists$7 = pathExists_1.pathExists;
@@ -1861,7 +1861,7 @@ function handleFilter (onInclude, resolvedDest, src, dest, opts, cb) {
 }
 
 function getStats (resolvedDest, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$g.stat : fs$g.lstat;
+  const stat = opts.dereference ? fs$h.stat : fs$h.lstat;
   stat(src, (err, st) => {
     if (err) return cb(err)
 
@@ -1881,7 +1881,7 @@ function onFile (srcStat, resolvedDest, src, dest, opts, cb) {
 
 function mayCopyFile (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
-    fs$g.unlink(dest, err => {
+    fs$h.unlink(dest, err => {
       if (err) return cb(err)
       return copyFile(srcStat, src, dest, opts, cb)
     });
@@ -1891,8 +1891,8 @@ function mayCopyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFile (srcStat, src, dest, opts, cb) {
-  if (typeof fs$g.copyFile === 'function') {
-    return fs$g.copyFile(src, dest, err => {
+  if (typeof fs$h.copyFile === 'function') {
+    return fs$h.copyFile(src, dest, err => {
       if (err) return cb(err)
       return setDestModeAndTimestamps(srcStat, dest, opts, cb)
     })
@@ -1901,9 +1901,9 @@ function copyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFileFallback (srcStat, src, dest, opts, cb) {
-  const rs = fs$g.createReadStream(src);
+  const rs = fs$h.createReadStream(src);
   rs.on('error', err => cb(err)).once('open', () => {
-    const ws = fs$g.createWriteStream(dest, { mode: srcStat.mode });
+    const ws = fs$h.createWriteStream(dest, { mode: srcStat.mode });
     ws.on('error', err => cb(err))
       .on('open', () => rs.pipe(ws))
       .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
@@ -1911,7 +1911,7 @@ function copyFileFallback (srcStat, src, dest, opts, cb) {
 }
 
 function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
-  fs$g.chmod(dest, srcStat.mode, err => {
+  fs$h.chmod(dest, srcStat.mode, err => {
     if (err) return cb(err)
     if (opts.preserveTimestamps) {
       return utimes(dest, srcStat.atime, srcStat.mtime, cb)
@@ -1936,7 +1936,7 @@ function onDir (srcStat, resolvedDest, src, dest, opts, cb) {
 }
 
 function mayCopyDir (src, dest, opts, cb) {
-  fs$g.stat(dest, (err, st) => {
+  fs$h.stat(dest, (err, st) => {
     if (err) return cb(err)
     if (!st.isDirectory()) {
       return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
@@ -1946,9 +1946,9 @@ function mayCopyDir (src, dest, opts, cb) {
 }
 
 function mkDirAndCopy (srcStat, src, dest, opts, cb) {
-  fs$g.mkdir(dest, srcStat.mode, err => {
+  fs$h.mkdir(dest, srcStat.mode, err => {
     if (err) return cb(err)
-    fs$g.chmod(dest, srcStat.mode, err => {
+    fs$h.chmod(dest, srcStat.mode, err => {
       if (err) return cb(err)
       return copyDir(src, dest, opts, cb)
     });
@@ -1956,7 +1956,7 @@ function mkDirAndCopy (srcStat, src, dest, opts, cb) {
 }
 
 function copyDir (src, dest, opts, cb) {
-  fs$g.readdir(src, (err, items) => {
+  fs$h.readdir(src, (err, items) => {
     if (err) return cb(err)
     return copyDirItems(items, src, dest, opts, cb)
   });
@@ -1981,7 +1981,7 @@ function copyDirItem (items, item, src, dest, opts, cb) {
 }
 
 function onLink (resolvedDest, src, dest, opts, cb) {
-  fs$g.readlink(src, (err, resolvedSrc) => {
+  fs$h.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
 
     if (opts.dereference) {
@@ -1991,7 +1991,7 @@ function onLink (resolvedDest, src, dest, opts, cb) {
     if (resolvedDest === notExist || resolvedDest === existsReg) {
       // if dest already exists, fs throws error anyway,
       // so no need to guard against it here.
-      return fs$g.symlink(resolvedSrc, dest, cb)
+      return fs$h.symlink(resolvedSrc, dest, cb)
     } else {
       if (opts.dereference) {
         resolvedDest = path$f.resolve(process.cwd(), resolvedDest);
@@ -2001,7 +2001,7 @@ function onLink (resolvedDest, src, dest, opts, 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$g.stat(dest, (err, st) => {
+      fs$h.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}'.`))
@@ -2013,9 +2013,9 @@ function onLink (resolvedDest, src, dest, opts, cb) {
 }
 
 function copyLink (resolvedSrc, dest, cb) {
-  fs$g.unlink(dest, err => {
+  fs$h.unlink(dest, err => {
     if (err) return cb(err)
-    return fs$g.symlink(resolvedSrc, dest, cb)
+    return fs$h.symlink(resolvedSrc, dest, cb)
   });
 }
 
@@ -2032,7 +2032,7 @@ function isSrcSubdir$2 (src, dest) {
 
 // check if dest exists and is a symlink.
 function checkDest (dest, cb) {
-  fs$g.readlink(dest, (err, resolvedPath) => {
+  fs$h.readlink(dest, (err, resolvedPath) => {
     if (err) {
       if (err.code === 'ENOENT') return cb(null, notExist)
 
@@ -2077,7 +2077,7 @@ var copy$1 = {
   copy: u$9(copy_1)
 };
 
-const fs$f = gracefulFs;
+const fs$g = gracefulFs;
 const path$e = path__default["default"];
 const assert = assert__default["default"];
 
@@ -2093,9 +2093,9 @@ function defaults$2 (options) {
     'readdir'
   ];
   methods.forEach(m => {
-    options[m] = options[m] || fs$f[m];
+    options[m] = options[m] || fs$g[m];
     m = m + 'Sync';
-    options[m] = options[m] || fs$f[m];
+    options[m] = options[m] || fs$g[m];
   });
 
   options.maxBusyTries = options.maxBusyTries || 3;
@@ -2399,14 +2399,14 @@ var remove$2 = {
 };
 
 const u$7 = universalify.fromCallback;
-const fs$e = fs__default["default"];
+const fs$f = fs__default["default"];
 const path$d = 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$e.readdir(dir, (err, items) => {
+  fs$f.readdir(dir, (err, items) => {
     if (err) return mkdir$5.mkdirs(dir, callback)
 
     items = items.map(item => path$d.join(dir, item));
@@ -2427,7 +2427,7 @@ const emptyDir = u$7(function emptyDir (dir, callback) {
 function emptyDirSync (dir) {
   let items;
   try {
-    items = fs$e.readdirSync(dir);
+    items = fs$f.readdirSync(dir);
   } catch (err) {
     return mkdir$5.mkdirsSync(dir)
   }
@@ -2447,19 +2447,19 @@ var empty = {
 
 const u$6 = universalify.fromCallback;
 const path$c = path__default["default"];
-const fs$d = gracefulFs;
+const fs$e = gracefulFs;
 const mkdir$4 = mkdirs_1;
 const pathExists$6 = pathExists_1.pathExists;
 
-function createFile (file, callback) {
+function createFile$1 (file, callback) {
   function makeFile () {
-    fs$d.writeFile(file, '', err => {
+    fs$e.writeFile(file, '', err => {
       if (err) return callback(err)
       callback();
     });
   }
 
-  fs$d.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+  fs$e.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
     if (!err && stats.isFile()) return callback()
     const dir = path$c.dirname(file);
     pathExists$6(dir, (err, dirExists) => {
@@ -2473,35 +2473,35 @@ function createFile (file, callback) {
   });
 }
 
-function createFileSync (file) {
+function createFileSync$1 (file) {
   let stats;
   try {
-    stats = fs$d.statSync(file);
+    stats = fs$e.statSync(file);
   } catch (e) {}
   if (stats && stats.isFile()) return
 
   const dir = path$c.dirname(file);
-  if (!fs$d.existsSync(dir)) {
+  if (!fs$e.existsSync(dir)) {
     mkdir$4.mkdirsSync(dir);
   }
 
-  fs$d.writeFileSync(file, '');
+  fs$e.writeFileSync(file, '');
 }
 
-var file$2 = {
-  createFile: u$6(createFile),
-  createFileSync
+var file$1 = {
+  createFile: u$6(createFile$1),
+  createFileSync: createFileSync$1
 };
 
 const u$5 = universalify.fromCallback;
 const path$b = path__default["default"];
-const fs$c = gracefulFs;
+const fs$d = gracefulFs;
 const mkdir$3 = mkdirs_1;
 const pathExists$5 = pathExists_1.pathExists;
 
 function createLink (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
-    fs$c.link(srcpath, dstpath, err => {
+    fs$d.link(srcpath, dstpath, err => {
       if (err) return callback(err)
       callback(null);
     });
@@ -2510,7 +2510,7 @@ function createLink (srcpath, dstpath, callback) {
   pathExists$5(dstpath, (err, destinationExists) => {
     if (err) return callback(err)
     if (destinationExists) return callback(null)
-    fs$c.lstat(srcpath, (err) => {
+    fs$d.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink');
         return callback(err)
@@ -2530,22 +2530,22 @@ function createLink (srcpath, dstpath, callback) {
 }
 
 function createLinkSync (srcpath, dstpath) {
-  const destinationExists = fs$c.existsSync(dstpath);
+  const destinationExists = fs$d.existsSync(dstpath);
   if (destinationExists) return undefined
 
   try {
-    fs$c.lstatSync(srcpath);
+    fs$d.lstatSync(srcpath);
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
     throw err
   }
 
   const dir = path$b.dirname(dstpath);
-  const dirExists = fs$c.existsSync(dir);
-  if (dirExists) return fs$c.linkSync(srcpath, dstpath)
+  const dirExists = fs$d.existsSync(dir);
+  if (dirExists) return fs$d.linkSync(srcpath, dstpath)
   mkdir$3.mkdirsSync(dir);
 
-  return fs$c.linkSync(srcpath, dstpath)
+  return fs$d.linkSync(srcpath, dstpath)
 }
 
 var link$1 = {
@@ -2554,7 +2554,7 @@ var link$1 = {
 };
 
 const path$a = path__default["default"];
-const fs$b = gracefulFs;
+const fs$c = gracefulFs;
 const pathExists$4 = pathExists_1.pathExists;
 
 /**
@@ -2581,7 +2581,7 @@ const pathExists$4 = pathExists_1.pathExists;
 
 function symlinkPaths$1 (srcpath, dstpath, callback) {
   if (path$a.isAbsolute(srcpath)) {
-    return fs$b.lstat(srcpath, (err) => {
+    return fs$c.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureSymlink');
         return callback(err)
@@ -2602,7 +2602,7 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
           'toDst': srcpath
         })
       } else {
-        return fs$b.lstat(srcpath, (err) => {
+        return fs$c.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace('lstat', 'ensureSymlink');
             return callback(err)
@@ -2620,7 +2620,7 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
 function symlinkPathsSync$1 (srcpath, dstpath) {
   let exists;
   if (path$a.isAbsolute(srcpath)) {
-    exists = fs$b.existsSync(srcpath);
+    exists = fs$c.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       'toCwd': srcpath,
@@ -2629,14 +2629,14 @@ function symlinkPathsSync$1 (srcpath, dstpath) {
   } else {
     const dstdir = path$a.dirname(dstpath);
     const relativeToDst = path$a.join(dstdir, srcpath);
-    exists = fs$b.existsSync(relativeToDst);
+    exists = fs$c.existsSync(relativeToDst);
     if (exists) {
       return {
         'toCwd': relativeToDst,
         'toDst': srcpath
       }
     } else {
-      exists = fs$b.existsSync(srcpath);
+      exists = fs$c.existsSync(srcpath);
       if (!exists) throw new Error('relative srcpath does not exist')
       return {
         'toCwd': srcpath,
@@ -2651,13 +2651,13 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$a = gracefulFs;
+const fs$b = 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$a.lstat(srcpath, (err, stats) => {
+  fs$b.lstat(srcpath, (err, stats) => {
     if (err) return callback(null, 'file')
     type = (stats && stats.isDirectory()) ? 'dir' : 'file';
     callback(null, type);
@@ -2669,7 +2669,7 @@ function symlinkTypeSync$1 (srcpath, type) {
 
   if (type) return type
   try {
-    stats = fs$a.lstatSync(srcpath);
+    stats = fs$b.lstatSync(srcpath);
   } catch (e) {
     return 'file'
   }
@@ -2683,7 +2683,7 @@ var symlinkType_1 = {
 
 const u$4 = universalify.fromCallback;
 const path$9 = path__default["default"];
-const fs$9 = gracefulFs;
+const fs$a = gracefulFs;
 const _mkdirs = mkdirs_1;
 const mkdirs = _mkdirs.mkdirs;
 const mkdirsSync = _mkdirs.mkdirsSync;
@@ -2713,10 +2713,10 @@ function createSymlink (srcpath, dstpath, type, callback) {
         const dir = path$9.dirname(dstpath);
         pathExists$3(dir, (err, dirExists) => {
           if (err) return callback(err)
-          if (dirExists) return fs$9.symlink(srcpath, dstpath, type, callback)
+          if (dirExists) return fs$a.symlink(srcpath, dstpath, type, callback)
           mkdirs(dir, err => {
             if (err) return callback(err)
-            fs$9.symlink(srcpath, dstpath, type, callback);
+            fs$a.symlink(srcpath, dstpath, type, callback);
           });
         });
       });
@@ -2725,17 +2725,17 @@ function createSymlink (srcpath, dstpath, type, callback) {
 }
 
 function createSymlinkSync (srcpath, dstpath, type) {
-  const destinationExists = fs$9.existsSync(dstpath);
+  const destinationExists = fs$a.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$9.existsSync(dir);
-  if (exists) return fs$9.symlinkSync(srcpath, dstpath, type)
+  const exists = fs$a.existsSync(dir);
+  if (exists) return fs$a.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$9.symlinkSync(srcpath, dstpath, type)
+  return fs$a.symlinkSync(srcpath, dstpath, type)
 }
 
 var symlink$1 = {
@@ -2743,16 +2743,16 @@ var symlink$1 = {
   createSymlinkSync
 };
 
-const file$1 = file$2;
+const file = file$1;
 const link = link$1;
 const symlink = symlink$1;
 
 var ensure = {
   // file
-  createFile: file$1.createFile,
-  createFileSync: file$1.createFileSync,
-  ensureFile: file$1.createFile,
-  ensureFileSync: file$1.createFileSync,
+  createFile: file.createFile,
+  createFileSync: file.createFileSync,
+  ensureFile: file.createFile,
+  ensureFileSync: file.createFileSync,
   // link
   createLink: link.createLink,
   createLinkSync: link.createLinkSync,
@@ -2937,7 +2937,7 @@ function outputJson (file, data, options, callback) {
 
 var outputJson_1 = outputJson;
 
-const fs$8 = gracefulFs;
+const fs$9 = gracefulFs;
 const path$7 = path__default["default"];
 const mkdir$1 = mkdirs_1;
 const jsonFile$1 = jsonfile;
@@ -2945,7 +2945,7 @@ const jsonFile$1 = jsonfile;
 function outputJsonSync (file, data, options) {
   const dir = path$7.dirname(file);
 
-  if (!fs$8.existsSync(dir)) {
+  if (!fs$9.existsSync(dir)) {
     mkdir$1.mkdirsSync(dir);
   }
 
@@ -2969,7 +2969,7 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json = jsonFile;
 
-const fs$7 = gracefulFs;
+const fs$8 = gracefulFs;
 const path$6 = path__default["default"];
 const copySync = copySync$1.copySync;
 const removeSync = remove$2.removeSync;
@@ -2983,7 +2983,7 @@ function moveSync (src, dest, options) {
   src = path$6.resolve(src);
   dest = path$6.resolve(dest);
 
-  if (src === dest) return fs$7.accessSync(src)
+  if (src === dest) return fs$8.accessSync(src)
 
   if (isSrcSubdir$1(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
 
@@ -2993,7 +2993,7 @@ function moveSync (src, dest, options) {
   function tryRenameSync () {
     if (overwrite) {
       try {
-        return fs$7.renameSync(src, dest)
+        return fs$8.renameSync(src, dest)
       } catch (err) {
         if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'EPERM') {
           removeSync(dest);
@@ -3006,8 +3006,8 @@ function moveSync (src, dest, options) {
       }
     } else {
       try {
-        fs$7.linkSync(src, dest);
-        return fs$7.unlinkSync(src)
+        fs$8.linkSync(src, dest);
+        return fs$8.unlinkSync(src)
       } catch (err) {
         if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM' || err.code === 'ENOTSUP') {
           return moveSyncAcrossDevice(src, dest, overwrite)
@@ -3019,7 +3019,7 @@ function moveSync (src, dest, options) {
 }
 
 function moveSyncAcrossDevice (src, dest, overwrite) {
-  const stat = fs$7.statSync(src);
+  const stat = fs$8.statSync(src);
 
   if (stat.isDirectory()) {
     return moveDirSyncAcrossDevice(src, dest, overwrite)
@@ -3034,20 +3034,20 @@ function moveFileSyncAcrossDevice (src, dest, overwrite) {
 
   const flags = overwrite ? 'w' : 'wx';
 
-  const fdr = fs$7.openSync(src, 'r');
-  const stat = fs$7.fstatSync(fdr);
-  const fdw = fs$7.openSync(dest, flags, stat.mode);
+  const fdr = fs$8.openSync(src, 'r');
+  const stat = fs$8.fstatSync(fdr);
+  const fdw = fs$8.openSync(dest, flags, stat.mode);
   let pos = 0;
 
   while (pos < stat.size) {
-    const bytesRead = fs$7.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$7.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$8.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$8.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
 
-  fs$7.closeSync(fdr);
-  fs$7.closeSync(fdw);
-  return fs$7.unlinkSync(src)
+  fs$8.closeSync(fdr);
+  fs$8.closeSync(fdw);
+  return fs$8.unlinkSync(src)
 }
 
 function moveDirSyncAcrossDevice (src, dest, overwrite) {
@@ -3072,7 +3072,7 @@ 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$7.statSync(src).isDirectory() &&
+    return fs$8.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)
@@ -3086,7 +3086,7 @@ var moveSync_1 = {
 };
 
 const u$1 = universalify.fromCallback;
-const fs$6 = gracefulFs;
+const fs$7 = gracefulFs;
 const path$5 = path__default["default"];
 const copy = copy$1.copy;
 const remove = remove$2.remove;
@@ -3104,9 +3104,9 @@ function move (src, dest, opts, cb) {
   src = path$5.resolve(src);
   dest = path$5.resolve(dest);
 
-  if (src === dest) return fs$6.access(src, cb)
+  if (src === dest) return fs$7.access(src, cb)
 
-  fs$6.stat(src, (err, st) => {
+  fs$7.stat(src, (err, st) => {
     if (err) return cb(err)
 
     if (st.isDirectory() && isSrcSubdir(src, dest)) {
@@ -3134,7 +3134,7 @@ function doRename (src, dest, overwrite, cb) {
 }
 
 function rename (src, dest, overwrite, cb) {
-  fs$6.rename(src, dest, err => {
+  fs$7.rename(src, dest, err => {
     if (!err) return cb()
     if (err.code !== 'EXDEV') return cb(err)
     return moveAcrossDevice(src, dest, overwrite, cb)
@@ -3167,7 +3167,7 @@ var move_1 = {
 };
 
 const u = universalify.fromCallback;
-const fs$5 = gracefulFs;
+const fs$6 = gracefulFs;
 const path$4 = path__default["default"];
 const mkdir = mkdirs_1;
 const pathExists = pathExists_1.pathExists;
@@ -3181,23 +3181,23 @@ function outputFile (file, data, encoding, callback) {
   const dir = path$4.dirname(file);
   pathExists(dir, (err, itDoes) => {
     if (err) return callback(err)
-    if (itDoes) return fs$5.writeFile(file, data, encoding, callback)
+    if (itDoes) return fs$6.writeFile(file, data, encoding, callback)
 
     mkdir.mkdirs(dir, err => {
       if (err) return callback(err)
 
-      fs$5.writeFile(file, data, encoding, callback);
+      fs$6.writeFile(file, data, encoding, callback);
     });
   });
 }
 
 function outputFileSync (file, ...args) {
   const dir = path$4.dirname(file);
-  if (fs$5.existsSync(dir)) {
-    return fs$5.writeFileSync(file, ...args)
+  if (fs$6.existsSync(dir)) {
+    return fs$6.writeFileSync(file, ...args)
   }
   mkdir.mkdirsSync(dir);
-  fs$5.writeFileSync(file, ...args);
+  fs$6.writeFileSync(file, ...args);
 }
 
 var output = {
@@ -3210,7 +3210,7 @@ var output = {
 	module.exports = Object.assign(
 	  {},
 	  // Export promiseified graceful-fs:
-	  fs$n,
+	  fs$o,
 	  // Export extra methods:
 	  copySync$1,
 	  copy$1,
@@ -3235,11 +3235,11 @@ var output = {
 	}
 } (lib$3));
 
-var fs$4 = libExports$1;
+var fs$5 = libExports$1;
 
 class File {
     constructor(path, hash) {
-        this._fd = fs$4.openSync(path, "w");
+        this._fd = fs$5.openSync(path, "w");
         this.path = path;
         this.hash = hash;
         this.system = undefined;
@@ -3268,14 +3268,14 @@ class File {
         if (!this._fd) {
             throw new Error(`No fd for ${this.path}`);
         }
-        fs$4.closeSync(this._fd);
-        fs$4.unlinkSync(this.path);
+        fs$5.closeSync(this._fd);
+        fs$5.unlinkSync(this.path);
     }
     close() {
         if (this._fd === undefined) {
             throw new Error(`No fd for ${this.path}`);
         }
-        fs$4.closeSync(this._fd);
+        fs$5.closeSync(this._fd);
         this._fd = undefined;
     }
     _write() {
@@ -3283,7 +3283,7 @@ class File {
         const pending = this._pending.shift();
         if (pending) {
             assert__default["default"](this._fd !== undefined);
-            fs$4.write(this._fd, pending.data)
+            fs$5.write(this._fd, pending.data)
                 .then(() => {
                 pending.resolve();
                 assert__default["default"](this._pending);
@@ -3298,7 +3298,7 @@ class File {
             })
                 .catch((e) => {
                 assert__default["default"](this._fd !== undefined);
-                fs$4.closeSync(this._fd);
+                fs$5.closeSync(this._fd);
                 this._fd = undefined;
                 pending.reject(e);
                 this._clearPending(e);
@@ -3354,139 +3354,262 @@ class Links {
     }
 }
 
-var dist = {};
+/**
+ * random table string and table length.
+ */
 
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(dist, "__esModule", { value: true });
-dist.file = dist.TempFile = dist.dir = dist.TempDir = void 0;
-const fs_1 = __importStar(fs__default["default"]);
-const os_1 = __importDefault(require$$1__default["default"]);
-const path_1 = __importDefault(path__default["default"]);
-const crypto_1 = __importDefault(crypto__default["default"]);
-const PATH_SEP = path_1.default.sep;
-const TMP_DIR_PATH = `${os_1.default.tmpdir()}${PATH_SEP}`;
-const FILE_NAME_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-';
-const DEFAULT_O_FLAGS = fs_1.default.constants.O_CREAT | fs_1.default.constants.O_EXCL | fs_1.default.constants.O_RDWR;
-const DEFAULT_FILE_MODE = fs_1.default.constants.S_IRUSR | fs_1.default.constants.S_IWUSR;
-/**
- * Create a pseudo-random sequence of characters.
- * @param len Length of the output string.
- * @returns pseudo-random and valid filename.
- */
-function randomFileName(len) {
-    const bytes = crypto_1.default.randomBytes(len);
-    let str = '';
-    for (const b of bytes) {
-        str += FILE_NAME_ALPHABET[b % FILE_NAME_ALPHABET.length];
-    }
-    return str;
+var TABLE = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    TABLE_LEN = TABLE.length;
+
+
+/**
+ * generate random string from template.
+ *
+ * replace for placeholder "X" in template.
+ * return template if not has placeholder.
+ *
+ * @param {String} template template string.
+ * @throws {TypeError} if template is not a String.
+ * @return {String} replaced string.
+ */
+function generate(template) {
+  var match, i, len, result;
+
+  if (typeof template !== 'string') {
+    throw new TypeError('template must be a String: ' + template);
+  }
+
+  match = template.match(/(X+)[^X]*$/);
+
+  // return template if not has placeholder
+  if (match === null) {
+    return template;
+  }
+
+  // generate random string
+  for (result = '', i = 0, len = match[1].length; i < len; ++i) {
+    result += TABLE[Math.floor(Math.random() * TABLE_LEN)];
+  }
+
+  // concat template and random string
+  return template.slice(0, match.index) + result +
+      template.slice(match.index + result.length);
 }
+
+
 /**
- * TempDir encapsulates the required information for managing a temporary directory.
- * The class is exported but it's recommended to use the async creation funcion `dir()`.
+ * export.
  */
-class TempDir {
-    constructor(path) {
-        this.path = path;
+var randomstring$1 = {
+  generate: generate
+};
+
+var fs$4 = fs__default["default"],
+    randomstring = randomstring$1;
+
+
+/**
+ * create unique name file.
+ *
+ * @param {String} template template string for filename.
+ * @param {Function} callback callback function.
+ * @throws {TypeError} cannot use Promise and callback function is not found.
+ * @return {Promise} Promise.
+ */
+function createFile(template, callback) {
+  var filename = randomstring.generate(template);
+
+  // callback is not a Function
+  if (typeof callback !== 'function') {
+    // can use Promise
+    if (typeof Promise === 'function') {
+      // return Promise
+      return new Promise(function(resolve, reject) {
+        createFile(template, function(err, filename) {
+          (err) ? reject(err) : resolve(filename);
+        });
+      });
+    } else {
+      // throw TypeError when cannot use Promise
+      throw new TypeError('callback function required');
     }
-    async clean(options = {}) {
-        const { force = false } = options;
-        return fs_1.promises.rm(this.path, { recursive: true, force });
+  }
+
+  fs$4.open(filename, 'ax+', 384 /*=0600*/, function(err, fd) {
+    if (err) {
+      if (err.code === 'EEXIST') {
+        // FIXME: infinite loop
+        setImmediate(function(tmpl, cb) {
+          createFile(tmpl, cb);
+        }, template, callback);
+
+        return;
+      }
+
+      // filename set to null if throws error
+      filename = null;
     }
+
+    if (fd) {
+      fs$4.close(fd, function(err) {
+        callback(err, filename);
+      });
+    } else {
+      callback(err, filename);
+    }
+  });
 }
-dist.TempDir = TempDir;
+
+
 /**
- * Create a temporary directory.
- * @param options Directory creation options.
- * @returns A promise that resolves with a temp directory instance.
+ * sync version createFile.
  *
- * @example
- * ```ts
- * import {dir} from '@josh_stern/mktemp';
- * const myDir = await dir();
- * // ...
- * await myDir.clean();
- * ```
+ * @param {String} template template string for filename.
+ * @throws {Error} error of fs.openSync or fs.closeSync.
+ * @return {String} created filename.
  */
-async function dir(options = {}) {
-    const { prefix = '', } = options;
-    const dir = await fs_1.promises.mkdtemp(path_1.default.join(TMP_DIR_PATH, prefix));
-    return new TempDir(dir);
+function createFileSync(template) {
+  var isExist, filename, fd;
+
+  // FIXME: infinite loop
+  do {
+    isExist = false;
+    filename = randomstring.generate(template);
+    try {
+      fd = fs$4.openSync(filename, 'ax+', 384 /*=0600*/);
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        isExist = true;
+      } else {
+        throw e;
+      }
+    } finally {
+      fd && fs$4.closeSync(fd);
+    }
+  } while (isExist);
+
+  return filename;
 }
-dist.dir = dir;
+
+
 /**
- * TempFile encapsulates the required information for managing the temp file.
- * The class is exported but it's recommended to use the async creation function `file()`.
+ * create unique name dir.
+ *
+ * @param {String} template template string for dirname.
+ * @param {Function} callback callback function.
+ * @throws {TypeError} cannot use Promise and callback function is not found.
+ * @return {Promise} Promise.
  */
-class TempFile {
-    constructor(dir, path, handle) {
-        this.dir = dir;
-        this.path = path;
-        this.handle = handle;
+function createDir(template, callback) {
+  var dirname = randomstring.generate(template);
+
+  // callback is not a Function
+  if (typeof callback !== 'function') {
+    // can use Promise
+    if (typeof Promise === 'function') {
+      // return Promise
+      return new Promise(function(resolve, reject) {
+        createDir(template, function(err, dirname) {
+          (err) ? reject(err) : resolve(dirname);
+        });
+      });
+    } else {
+      // throw TypeError when cannot use Promise
+      throw new TypeError('callback function required');
     }
-    async clean(options = {}) {
-        await this.handle.close();
-        return this.dir.clean(options);
+  }
+
+  fs$4.mkdir(dirname, 448 /*=0700*/, function(err) {
+    if (err) {
+      if (err.code === 'EEXIST') {
+        // FIXME: infinite loop
+        setImmediate(function(tmpl, cb) {
+          createDir(tmpl, cb);
+        }, template, callback);
+
+        return;
+      }
+
+      // dirname set to null if throws error
+      dirname = null;
     }
+
+    callback(err, dirname);
+  });
 }
-dist.TempFile = TempFile;
+
+
 /**
- * Create a temporary file.
- * @param options File creation options.
- * @returns A promise that resolves to a temporary file object.
+ * sync version createDir.
  *
- * @example
- * ```ts
- * import {file} from '@josh_stern/mktemp';
- * const myFile = await file();
- * await myFile.handle.write('Hello for a little while');
- * await myFile.clean();
- * ```
+ * @param {String} template template string for dirname.
+ * @return {String} created dirname.
  */
-async function file(options = {}) {
-    const { name = randomFileName(8), ext = '', flags = DEFAULT_O_FLAGS, mode = DEFAULT_FILE_MODE, dirOptions = {}, } = options;
-    const tempDir = await dir(dirOptions);
-    const filePath = path_1.default.join(tempDir.path, `${name}${ext}`);
-    const fh = await fs_1.promises.open(filePath, flags, mode);
-    return new TempFile(tempDir, filePath, fh);
+function createDirSync(template) {
+  var isExist, dirname;
+
+  // FIXME: infinite loop
+  do {
+    isExist = false;
+    dirname = randomstring.generate(template);
+    try {
+      fs$4.mkdirSync(dirname, 448 /*=0700*/);
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        isExist = true;
+      } else {
+        throw e;
+      }
+    }
+  } while (isExist);
+
+  return dirname;
 }
-dist.file = file;
+
+
+/**
+ * export.
+ */
+var mktemp$1 = {
+  createFile: createFile,
+  createFileSync: createFileSync,
+  createDir: createDir,
+  createDirSync: createDirSync
+};
+
+/*!
+ * @license mktemp Copyright(c) 2013-2014 sasa+1
+ * https://github.com/sasaplus1/mktemp
+ * Released under the MIT license.
+ */
+
+var mktemp = mktemp$1;
+
+
+/**
+ * export.
+ */
+var mktemp_1 = {
+  createFile: mktemp.createFile,
+  createFileSync: mktemp.createFileSync,
+  createDir: mktemp.createDir,
+  createDirSync: mktemp.createDirSync
+};
 
 function untarFile(archive, file) {
     return new Promise((resolve, reject) => {
-        dist.dir({ prefix: "fisk_env_info" }).then((tmpdir) => {
-            child_process__default["default"].exec(`tar -zxf "${archive}" ${file}`, { cwd: tmpdir.path }, (err) => {
+        mktemp_1.createDir("/tmp/fisk_env_infoXXXX").then((tmpdir) => {
+            child_process__default["default"].exec(`tar -zxf "${archive}" ${file}`, { cwd: tmpdir }, (err) => {
                 if (err) {
                     reject(err);
                     return;
                 }
-                fs$4.readFile(path__default["default"].join(tmpdir.path, file), "utf8", (err, data) => {
+                fs$5.readFile(path__default["default"].join(tmpdir, file), "utf8", (err, data) => {
                     try {
-                        fs$4.removeSync(tmpdir.path);
+                        fs$5.removeSync(tmpdir);
                     }
                     catch (e) {
-                        console.error("Got an error removing the temp dir", tmpdir.path);
+                        console.error("Got an error removing the temp dir", tmpdir);
                     }
                     if (err) {
                         reject(err);
@@ -3520,12 +3643,12 @@ class Environments {
                 }
             }
             return new Promise((resolve, reject) => {
-                fs$4.stat(p)
+                fs$5.stat(p)
                     .then((st) => {
                     if (st.isDirectory()) {
                         // we're good
                         this._path = p;
-                        fs$4.readdir(p).then((files) => {
+                        fs$5.readdir(p).then((files) => {
                             const promises = [];
                             files.forEach((e) => {
                                 if (e.length === 47 && e.indexOf(".tar.gz", 40) === 40) {
@@ -3560,7 +3683,7 @@ class Environments {
                     .catch((e) => {
                     if ("code" in e && e.code === "ENOENT") {
                         // make the directory
-                        fs$4.mkdirp(p, (err) => {
+                        fs$5.mkdirp(p, (err) => {
                             if (err) {
                                 reject(`Can't make directory ${p}: ${e.message}`);
                                 return;
@@ -3582,7 +3705,7 @@ class Environments {
             return undefined;
         }
         assert__default["default"](this._path);
-        fs$4.mkdirpSync(this._path);
+        fs$5.mkdirpSync(this._path);
         return new File(path__default["default"].join(this._path, `${environment.hash}.tar.gz`), environment.hash);
     }
     complete(file) {
@@ -3679,7 +3802,7 @@ class Environments {
     remove(hash) {
         // ### this should be promisified
         try {
-            fs$4.removeSync(this._data[hash].path);
+            fs$5.removeSync(this._data[hash].path);
             delete this._data[hash];
             this.unlink(hash);
             this.unlink(undefined, hash);
@@ -51858,7 +51981,7 @@ function validateCache(option) {
     // console.log(dir);
     let version;
     try {
-        version = fs$4.readFileSync(file);
+        version = fs$5.readFileSync(file);
         if (version.readUInt32BE() === Version) {
             return;
         }
@@ -51869,11 +51992,11 @@ function validateCache(option) {
     if (version) {
         console.log(`Wrong version. Destroying cache ${dir}`);
     }
-    fs$4.removeSync(dir);
-    fs$4.mkdirpSync(dir);
+    fs$5.removeSync(dir);
+    fs$5.mkdirpSync(dir);
     const buf = Buffer.allocUnsafe(4);
     buf.writeUInt32BE(Version);
-    fs$4.writeFileSync(file, buf);
+    fs$5.writeFileSync(file, buf);
 }
 function common$1(option) {
     validateCache(option);
@@ -53378,7 +53501,7 @@ server.on("error", (error) => {
 });
 let schedulerNpmVersion;
 try {
-    schedulerNpmVersion = String(JSON.parse(fs$4.readFileSync(path__default["default"].join(__dirname, "../package.json"), "utf8")).version);
+    schedulerNpmVersion = String(JSON.parse(fs$5.readFileSync(path__default["default"].join(__dirname, "../package.json"), "utf8")).version);
 }
 catch (err) {
     console.log("Couldn't parse package json", err);
@@ -53398,7 +53521,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$4.mkdirSync(logFileDir);
+    fs$5.mkdirSync(logFileDir);
 }
 catch (err) {
     /* */
@@ -53629,14 +53752,14 @@ function purgeEnvironmentsToMaxSize() {
         const p = Environments.instance.path;
         try {
             let purged = false;
-            fs$4.readdirSync(p)
+            fs$5.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$4.removeSync(abs);
+                        fs$5.removeSync(abs);
                     }
                     catch (err) {
                         console.error("Failed to remove file", abs, err);
@@ -53645,7 +53768,7 @@ function purgeEnvironmentsToMaxSize() {
                 }
                 let stat;
                 try {
-                    stat = fs$4.statSync(abs);
+                    stat = fs$5.statSync(abs);
                 }
                 catch (err) {
                     return undefined;
@@ -53853,7 +53976,7 @@ server.on("listen", (app) => {
             res.sendStatus(404);
             return;
         }
-        const rstream = fs$4.createReadStream(env.path);
+        const rstream = fs$5.createReadStream(env.path);
         rstream.on("error", (err) => {
             console.error("Got read stream error for", env.path, err);
             rstream.close();
@@ -53864,7 +53987,7 @@ server.on("listen", (app) => {
         console.log("quitting", req.query);
         if ("purge_environments" in req.query) {
             try {
-                fs$4.removeSync(path__default["default"].join(common.cacheDir(), "environments"));
+                fs$5.removeSync(path__default["default"].join(common.cacheDir(), "environments"));
             }
             catch (err) {
                 /* */
@@ -53876,7 +53999,7 @@ server.on("listen", (app) => {
 });
 function updateLogFilesToMonitors() {
     if (monitors.length) {
-        fs$4.readdir(logFileDir, (err, files) => {
+        fs$5.readdir(logFileDir, (err, files) => {
             if (files) {
                 files = files.reverse();
             }
@@ -53887,13 +54010,13 @@ function updateLogFilesToMonitors() {
     }
 }
 function clearLogFiles() {
-    fs$4.readdir(logFileDir, (err, files) => {
+    fs$5.readdir(logFileDir, (err, files) => {
         if (err) {
             console.log("Got error removing log files", err);
             return;
         }
         for (const file of files) {
-            fs$4.unlink(path__default["default"].join(logFileDir, file), (err) => {
+            fs$5.unlink(path__default["default"].join(logFileDir, file), (err) => {
                 if (err) {
                     console.log("failed to remove file", path__default["default"].join(logFileDir, file), err);
                 }
@@ -53903,7 +54026,7 @@ function clearLogFiles() {
     });
 }
 try {
-    fs$4.watch(logFileDir, (type) => {
+    fs$5.watch(logFileDir, (type) => {
         if (type === "rename") {
             updateLogFilesToMonitors();
         }
@@ -53938,7 +54061,7 @@ function formatDate(date) {
 }
 function addLogFile(log) {
     try {
-        fs$4.writeFileSync(path__default["default"].join(logFileDir, `${formatDate(new Date())} ${log.source} ${log.ip}`), log.contents);
+        fs$5.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);
@@ -54347,7 +54470,7 @@ server.on("monitor", (client) => {
                 break;
             case "logFiles":
                 // console.log("logFiles:", message);
-                fs$4.readdir(logFileDir, (err, files) => {
+                fs$5.readdir(logFileDir, (err, files) => {
                     if (files) {
                         files = files.reverse();
                     }
@@ -54362,7 +54485,7 @@ server.on("monitor", (client) => {
                     return;
                 }
                 const f = path__default["default"].join(logFileDir, message.file);
-                fs$4.readFile(f, "utf8", (err, contents) => {
+                fs$5.readFile(f, "utf8", (err, contents) => {
                     // console.log("sending file", f, contents.length);
                     client.send({ type: "logFile", file: f, contents: contents || "" });
                 });