@andersbakken/fisk 3.6.0 → 3.6.2

package/dist/VM_runtime.js

@@ -7,7 +7,7 @@ var require$$1 = require('fs');
 var require$$0 = require('constants');
 var require$$0$1 = require('stream');
 var require$$4 = require('util');
-var path$j = require('path');
+var path$i = require('path');
 var require$$1$1 = require('os');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -19,7 +19,7 @@ var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$j);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$i);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -30,7 +30,7 @@ var lib = {
   set exports(v){ libExports = v; },
 };
 
-var fs$k = {};
+var fs$j = {};
 
 var universalify = {};
 
@@ -555,7 +555,7 @@ function clone$1 (obj) {
   return copy
 }
 
-var fs$j = require$$1__default["default"];
+var fs$i = require$$1__default["default"];
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone = clone_1;
@@ -597,18 +597,18 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   };
 
 // Once time initialization
-if (!fs$j[gracefulQueue]) {
+if (!fs$i[gracefulQueue]) {
   // This queue can be shared by multiple loaded instances
   var queue = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs$j, queue);
+  publishQueue(fs$i, 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$j.close = (function (fs$close) {
+  fs$i.close = (function (fs$close) {
     function close (fd, cb) {
-      return fs$close.call(fs$j, fd, function (err) {
+      return fs$close.call(fs$i, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
@@ -623,12 +623,12 @@ if (!fs$j[gracefulQueue]) {
       value: fs$close
     });
     return close
-  })(fs$j.close);
+  })(fs$i.close);
 
-  fs$j.closeSync = (function (fs$closeSync) {
+  fs$i.closeSync = (function (fs$closeSync) {
     function closeSync (fd) {
       // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs$j, arguments);
+      fs$closeSync.apply(fs$i, arguments);
       resetQueue();
     }
 
@@ -636,24 +636,24 @@ if (!fs$j[gracefulQueue]) {
       value: fs$closeSync
     });
     return closeSync
-  })(fs$j.closeSync);
+  })(fs$i.closeSync);
 
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
     process.on('exit', function() {
-      debug(fs$j[gracefulQueue]);
-      assert__default["default"].equal(fs$j[gracefulQueue].length, 0);
+      debug(fs$i[gracefulQueue]);
+      assert__default["default"].equal(fs$i[gracefulQueue].length, 0);
     });
   }
 }
 
 if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs$j[gracefulQueue]);
+  publishQueue(commonjsGlobal, fs$i[gracefulQueue]);
 }
 
-var gracefulFs = patch(clone(fs$j));
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$j.__patched) {
-    gracefulFs = patch(fs$j);
-    fs$j.__patched = true;
+var gracefulFs = patch(clone(fs$i));
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$i.__patched) {
+    gracefulFs = patch(fs$i);
+    fs$i.__patched = true;
 }
 
 function patch (fs) {
@@ -927,7 +927,7 @@ function patch (fs) {
 
 function enqueue (elem) {
   debug('ENQUEUE', elem[0].name, elem[1]);
-  fs$j[gracefulQueue].push(elem);
+  fs$i[gracefulQueue].push(elem);
   retry();
 }
 
@@ -939,12 +939,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$j[gracefulQueue].length; ++i) {
+  for (var i = 0; i < fs$i[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$j[gracefulQueue][i].length > 2) {
-      fs$j[gracefulQueue][i][3] = now; // startTime
-      fs$j[gracefulQueue][i][4] = now; // lastTime
+    if (fs$i[gracefulQueue][i].length > 2) {
+      fs$i[gracefulQueue][i][3] = now; // startTime
+      fs$i[gracefulQueue][i][4] = now; // lastTime
     }
   }
   // call retry to make sure we're actively processing the queue
@@ -956,10 +956,10 @@ function retry () {
   clearTimeout(retryTimer);
   retryTimer = undefined;
 
-  if (fs$j[gracefulQueue].length === 0)
+  if (fs$i[gracefulQueue].length === 0)
     return
 
-  var elem = fs$j[gracefulQueue].shift();
+  var elem = fs$i[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
   // these items may be unset if they were added by an older graceful-fs
@@ -994,7 +994,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$j[gracefulQueue].push(elem);
+      fs$i[gracefulQueue].push(elem);
     }
   }
 
@@ -1107,13 +1107,13 @@ function retry () {
 	    });
 	  })
 	};
-} (fs$k));
+} (fs$j));
 
-const path$i = path__default["default"];
+const path$h = path__default["default"];
 
 // get drive on windows
 function getRootPath (p) {
-  p = path$i.normalize(path$i.resolve(p)).split(path$i.sep);
+  p = path$h.normalize(path$h.resolve(p)).split(path$h.sep);
   if (p.length > 0) return p[0]
   return null
 }
@@ -1133,8 +1133,8 @@ var win32 = {
   invalidWin32Path: invalidWin32Path$2
 };
 
-const fs$i = gracefulFs;
-const path$h = path__default["default"];
+const fs$h = gracefulFs;
+const path$g = path__default["default"];
 const invalidWin32Path$1 = win32.invalidWin32Path;
 
 const o777$1 = parseInt('0777', 8);
@@ -1154,7 +1154,7 @@ function mkdirs$2 (p, opts, callback, made) {
   }
 
   let mode = opts.mode;
-  const xfs = opts.fs || fs$i;
+  const xfs = opts.fs || fs$h;
 
   if (mode === undefined) {
     mode = o777$1 & (~process.umask());
@@ -1162,7 +1162,7 @@ function mkdirs$2 (p, opts, callback, made) {
   if (!made) made = null;
 
   callback = callback || function () {};
-  p = path$h.resolve(p);
+  p = path$g.resolve(p);
 
   xfs.mkdir(p, mode, er => {
     if (!er) {
@@ -1171,8 +1171,8 @@ function mkdirs$2 (p, opts, callback, made) {
     }
     switch (er.code) {
       case 'ENOENT':
-        if (path$h.dirname(p) === p) return callback(er)
-        mkdirs$2(path$h.dirname(p), opts, (er, made) => {
+        if (path$g.dirname(p) === p) return callback(er)
+        mkdirs$2(path$g.dirname(p), opts, (er, made) => {
           if (er) callback(er, made);
           else mkdirs$2(p, opts, callback, made);
         });
@@ -1195,8 +1195,8 @@ function mkdirs$2 (p, opts, callback, made) {
 
 var mkdirs_1$1 = mkdirs$2;
 
-const fs$h = gracefulFs;
-const path$g = path__default["default"];
+const fs$g = gracefulFs;
+const path$f = path__default["default"];
 const invalidWin32Path = win32.invalidWin32Path;
 
 const o777 = parseInt('0777', 8);
@@ -1207,7 +1207,7 @@ function mkdirsSync$2 (p, opts, made) {
   }
 
   let mode = opts.mode;
-  const xfs = opts.fs || fs$h;
+  const xfs = opts.fs || fs$g;
 
   if (process.platform === 'win32' && invalidWin32Path(p)) {
     const errInval = new Error(p + ' contains invalid WIN32 path characters.');
@@ -1220,15 +1220,15 @@ function mkdirsSync$2 (p, opts, made) {
   }
   if (!made) made = null;
 
-  p = path$g.resolve(p);
+  p = path$f.resolve(p);
 
   try {
     xfs.mkdirSync(p, mode);
     made = made || p;
   } catch (err0) {
     if (err0.code === 'ENOENT') {
-      if (path$g.dirname(p) === p) throw err0
-      made = mkdirsSync$2(path$g.dirname(p), opts, made);
+      if (path$f.dirname(p) === p) throw err0
+      made = mkdirsSync$2(path$f.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
@@ -1262,39 +1262,39 @@ var mkdirs_1 = {
   ensureDirSync: mkdirsSync$1
 };
 
-const fs$g = gracefulFs;
+const fs$f = gracefulFs;
 const os = require$$1__default$1["default"];
-const path$f = path__default["default"];
+const path$e = path__default["default"];
 
 // HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
 function hasMillisResSync () {
-  let tmpfile = path$f.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path$f.join(os.tmpdir(), tmpfile);
+  let tmpfile = path$e.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$e.join(os.tmpdir(), tmpfile);
 
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  fs$g.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
-  const fd = fs$g.openSync(tmpfile, 'r+');
-  fs$g.futimesSync(fd, d, d);
-  fs$g.closeSync(fd);
-  return fs$g.statSync(tmpfile).mtime > 1435410243000
+  fs$f.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
+  const fd = fs$f.openSync(tmpfile, 'r+');
+  fs$f.futimesSync(fd, d, d);
+  fs$f.closeSync(fd);
+  return fs$f.statSync(tmpfile).mtime > 1435410243000
 }
 
 function hasMillisRes (callback) {
-  let tmpfile = path$f.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path$f.join(os.tmpdir(), tmpfile);
+  let tmpfile = path$e.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$e.join(os.tmpdir(), tmpfile);
 
   // 550 millis past UNIX epoch
   const d = new Date(1435410243862);
-  fs$g.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
+  fs$f.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
     if (err) return callback(err)
-    fs$g.open(tmpfile, 'r+', (err, fd) => {
+    fs$f.open(tmpfile, 'r+', (err, fd) => {
       if (err) return callback(err)
-      fs$g.futimes(fd, d, d, err => {
+      fs$f.futimes(fd, d, d, err => {
         if (err) return callback(err)
-        fs$g.close(fd, err => {
+        fs$f.close(fd, err => {
           if (err) return callback(err)
-          fs$g.stat(tmpfile, (err, stats) => {
+          fs$f.stat(tmpfile, (err, stats) => {
             if (err) return callback(err)
             callback(null, stats.mtime > 1435410243000);
           });
@@ -1316,10 +1316,10 @@ function timeRemoveMillis (timestamp) {
 
 function utimesMillis (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  fs$g.open(path, 'r+', (err, fd) => {
+  fs$f.open(path, 'r+', (err, fd) => {
     if (err) return callback(err)
-    fs$g.futimes(fd, atime, mtime, futimesErr => {
-      fs$g.close(fd, closeErr => {
+    fs$f.futimes(fd, atime, mtime, futimesErr => {
+      fs$f.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
       });
     });
@@ -1327,9 +1327,9 @@ function utimesMillis (path, atime, mtime, callback) {
 }
 
 function utimesMillisSync (path, atime, mtime) {
-  const fd = fs$g.openSync(path, 'r+');
-  fs$g.futimesSync(fd, atime, mtime);
-  return fs$g.closeSync(fd)
+  const fd = fs$f.openSync(path, 'r+');
+  fs$f.futimesSync(fd, atime, mtime);
+  return fs$f.closeSync(fd)
 }
 
 var utimes$1 = {
@@ -1352,8 +1352,8 @@ var buffer$1 = function (size) {
   return new Buffer(size)
 };
 
-const fs$f = gracefulFs;
-const path$e = path__default["default"];
+const fs$e = gracefulFs;
+const path$d = path__default["default"];
 const mkdirpSync$1 = mkdirs_1.mkdirsSync;
 const utimesSync = utimes$1.utimesMillisSync;
 
@@ -1379,8 +1379,8 @@ function copySync$2 (src, dest, opts) {
 
   if (opts.filter && !opts.filter(src, dest)) return
 
-  const destParent = path$e.dirname(dest);
-  if (!fs$f.existsSync(destParent)) mkdirpSync$1(destParent);
+  const destParent = path$d.dirname(dest);
+  if (!fs$e.existsSync(destParent)) mkdirpSync$1(destParent);
   return startCopy$1(resolvedDest, src, dest, opts)
 }
 
@@ -1390,7 +1390,7 @@ function startCopy$1 (resolvedDest, src, dest, opts) {
 }
 
 function getStats$1 (resolvedDest, src, dest, opts) {
-  const statSync = opts.dereference ? fs$f.statSync : fs$f.lstatSync;
+  const statSync = opts.dereference ? fs$e.statSync : fs$e.lstatSync;
   const st = statSync(src);
 
   if (st.isDirectory()) return onDir$1(st, resolvedDest, src, dest, opts)
@@ -1408,7 +1408,7 @@ function onFile$1 (srcStat, resolvedDest, src, dest, opts) {
 
 function mayCopyFile$1 (srcStat, src, dest, opts) {
   if (opts.overwrite) {
-    fs$f.unlinkSync(dest);
+    fs$e.unlinkSync(dest);
     return copyFile$1(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
     throw new Error(`'${dest}' already exists`)
@@ -1416,9 +1416,9 @@ function mayCopyFile$1 (srcStat, src, dest, opts) {
 }
 
 function copyFile$1 (srcStat, src, dest, opts) {
-  if (typeof fs$f.copyFileSync === 'function') {
-    fs$f.copyFileSync(src, dest);
-    fs$f.chmodSync(dest, srcStat.mode);
+  if (typeof fs$e.copyFileSync === 'function') {
+    fs$e.copyFileSync(src, dest);
+    fs$e.chmodSync(dest, srcStat.mode);
     if (opts.preserveTimestamps) {
       return utimesSync(dest, srcStat.atime, srcStat.mtime)
     }
@@ -1431,20 +1431,20 @@ function copyFileFallback$1 (srcStat, src, dest, opts) {
   const BUF_LENGTH = 64 * 1024;
   const _buff = buffer$1(BUF_LENGTH);
 
-  const fdr = fs$f.openSync(src, 'r');
-  const fdw = fs$f.openSync(dest, 'w', srcStat.mode);
+  const fdr = fs$e.openSync(src, 'r');
+  const fdw = fs$e.openSync(dest, 'w', srcStat.mode);
   let pos = 0;
 
   while (pos < srcStat.size) {
-    const bytesRead = fs$f.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$f.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$e.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$e.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
 
-  if (opts.preserveTimestamps) fs$f.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+  if (opts.preserveTimestamps) fs$e.futimesSync(fdw, srcStat.atime, srcStat.mtime);
 
-  fs$f.closeSync(fdr);
-  fs$f.closeSync(fdw);
+  fs$e.closeSync(fdr);
+  fs$e.closeSync(fdw);
 }
 
 function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
@@ -1463,50 +1463,50 @@ function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
 }
 
 function mayCopyDir$1 (src, dest, opts) {
-  if (!fs$f.statSync(dest).isDirectory()) {
+  if (!fs$e.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$f.mkdirSync(dest, srcStat.mode);
-  fs$f.chmodSync(dest, srcStat.mode);
+  fs$e.mkdirSync(dest, srcStat.mode);
+  fs$e.chmodSync(dest, srcStat.mode);
   return copyDir$1(src, dest, opts)
 }
 
 function copyDir$1 (src, dest, opts) {
-  fs$f.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
+  fs$e.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
 }
 
 function copyDirItem$1 (item, src, dest, opts) {
-  const srcItem = path$e.join(src, item);
-  const destItem = path$e.join(dest, item);
+  const srcItem = path$d.join(src, item);
+  const destItem = path$d.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$f.readlinkSync(src);
+  let resolvedSrc = fs$e.readlinkSync(src);
 
   if (opts.dereference) {
-    resolvedSrc = path$e.resolve(process.cwd(), resolvedSrc);
+    resolvedSrc = path$d.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$f.symlinkSync(resolvedSrc, dest)
+    return fs$e.symlinkSync(resolvedSrc, dest)
   } else {
     if (opts.dereference) {
-      resolvedDest = path$e.resolve(process.cwd(), resolvedDest);
+      resolvedDest = path$d.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$f.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
+    if (fs$e.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
     return copyLink$1(resolvedSrc, dest)
@@ -1514,15 +1514,15 @@ function onLink$1 (resolvedDest, src, dest, opts) {
 }
 
 function copyLink$1 (resolvedSrc, dest) {
-  fs$f.unlinkSync(dest);
-  return fs$f.symlinkSync(resolvedSrc, dest)
+  fs$e.unlinkSync(dest);
+  return fs$e.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$e.resolve(src).split(path$e.sep);
-  const destArray = path$e.resolve(dest).split(path$e.sep);
+  const srcArray = path$d.resolve(src).split(path$d.sep);
+  const destArray = path$d.resolve(dest).split(path$d.sep);
 
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -1533,7 +1533,7 @@ function isSrcSubdir$3 (src, dest) {
 function checkDest$1 (dest) {
   let resolvedPath;
   try {
-    resolvedPath = fs$f.readlinkSync(dest);
+    resolvedPath = fs$e.readlinkSync(dest);
   } catch (err) {
     if (err.code === 'ENOENT') return notExist$1
 
@@ -1547,8 +1547,8 @@ function checkDest$1 (dest) {
 
 function pathsAreIdentical$1 (src, dest) {
   const os = process.platform;
-  const resolvedSrc = path$e.resolve(src);
-  const resolvedDest = path$e.resolve(dest);
+  const resolvedSrc = path$d.resolve(src);
+  const resolvedDest = path$d.resolve(dest);
   // case-insensitive paths
   if (os === 'darwin' || os === 'win32') {
     return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
@@ -1575,19 +1575,19 @@ var copySync$1 = {
 };
 
 const u$a = universalify.fromPromise;
-const fs$e = fs$k;
+const fs$d = fs$j;
 
 function pathExists$8 (path) {
-  return fs$e.access(path).then(() => true).catch(() => false)
+  return fs$d.access(path).then(() => true).catch(() => false)
 }
 
 var pathExists_1 = {
   pathExists: u$a(pathExists$8),
-  pathExistsSync: fs$e.existsSync
+  pathExistsSync: fs$d.existsSync
 };
 
-const fs$d = gracefulFs;
-const path$d = path__default["default"];
+const fs$c = gracefulFs;
+const path$c = path__default["default"];
 const mkdirp$1 = mkdirs_1.mkdirs;
 const pathExists$7 = pathExists_1.pathExists;
 const utimes = utimes$1.utimesMillis;
@@ -1623,7 +1623,7 @@ function copy$2 (src, dest, opts, cb) {
 }
 
 function checkParentDir (resolvedDest, src, dest, opts, cb) {
-  const destParent = path$d.dirname(dest);
+  const destParent = path$c.dirname(dest);
   pathExists$7(destParent, (err, dirExists) => {
     if (err) return cb(err)
     if (dirExists) return startCopy(resolvedDest, src, dest, opts, cb)
@@ -1650,7 +1650,7 @@ function handleFilter (onInclude, resolvedDest, src, dest, opts, cb) {
 }
 
 function getStats (resolvedDest, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$d.stat : fs$d.lstat;
+  const stat = opts.dereference ? fs$c.stat : fs$c.lstat;
   stat(src, (err, st) => {
     if (err) return cb(err)
 
@@ -1670,7 +1670,7 @@ function onFile (srcStat, resolvedDest, src, dest, opts, cb) {
 
 function mayCopyFile (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
-    fs$d.unlink(dest, err => {
+    fs$c.unlink(dest, err => {
       if (err) return cb(err)
       return copyFile(srcStat, src, dest, opts, cb)
     });
@@ -1680,8 +1680,8 @@ function mayCopyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFile (srcStat, src, dest, opts, cb) {
-  if (typeof fs$d.copyFile === 'function') {
-    return fs$d.copyFile(src, dest, err => {
+  if (typeof fs$c.copyFile === 'function') {
+    return fs$c.copyFile(src, dest, err => {
       if (err) return cb(err)
       return setDestModeAndTimestamps(srcStat, dest, opts, cb)
     })
@@ -1690,9 +1690,9 @@ function copyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFileFallback (srcStat, src, dest, opts, cb) {
-  const rs = fs$d.createReadStream(src);
+  const rs = fs$c.createReadStream(src);
   rs.on('error', err => cb(err)).once('open', () => {
-    const ws = fs$d.createWriteStream(dest, { mode: srcStat.mode });
+    const ws = fs$c.createWriteStream(dest, { mode: srcStat.mode });
     ws.on('error', err => cb(err))
       .on('open', () => rs.pipe(ws))
       .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
@@ -1700,7 +1700,7 @@ function copyFileFallback (srcStat, src, dest, opts, cb) {
 }
 
 function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
-  fs$d.chmod(dest, srcStat.mode, err => {
+  fs$c.chmod(dest, srcStat.mode, err => {
     if (err) return cb(err)
     if (opts.preserveTimestamps) {
       return utimes(dest, srcStat.atime, srcStat.mtime, cb)
@@ -1725,7 +1725,7 @@ function onDir (srcStat, resolvedDest, src, dest, opts, cb) {
 }
 
 function mayCopyDir (src, dest, opts, cb) {
-  fs$d.stat(dest, (err, st) => {
+  fs$c.stat(dest, (err, st) => {
     if (err) return cb(err)
     if (!st.isDirectory()) {
       return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
@@ -1735,9 +1735,9 @@ function mayCopyDir (src, dest, opts, cb) {
 }
 
 function mkDirAndCopy (srcStat, src, dest, opts, cb) {
-  fs$d.mkdir(dest, srcStat.mode, err => {
+  fs$c.mkdir(dest, srcStat.mode, err => {
     if (err) return cb(err)
-    fs$d.chmod(dest, srcStat.mode, err => {
+    fs$c.chmod(dest, srcStat.mode, err => {
       if (err) return cb(err)
       return copyDir(src, dest, opts, cb)
     });
@@ -1745,7 +1745,7 @@ function mkDirAndCopy (srcStat, src, dest, opts, cb) {
 }
 
 function copyDir (src, dest, opts, cb) {
-  fs$d.readdir(src, (err, items) => {
+  fs$c.readdir(src, (err, items) => {
     if (err) return cb(err)
     return copyDirItems(items, src, dest, opts, cb)
   });
@@ -1758,8 +1758,8 @@ function copyDirItems (items, src, dest, opts, cb) {
 }
 
 function copyDirItem (items, item, src, dest, opts, cb) {
-  const srcItem = path$d.join(src, item);
-  const destItem = path$d.join(dest, item);
+  const srcItem = path$c.join(src, item);
+  const destItem = path$c.join(dest, item);
   checkPaths(srcItem, destItem, (err, resolvedDest) => {
     if (err) return cb(err)
     startCopy(resolvedDest, srcItem, destItem, opts, err => {
@@ -1770,27 +1770,27 @@ function copyDirItem (items, item, src, dest, opts, cb) {
 }
 
 function onLink (resolvedDest, src, dest, opts, cb) {
-  fs$d.readlink(src, (err, resolvedSrc) => {
+  fs$c.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
 
     if (opts.dereference) {
-      resolvedSrc = path$d.resolve(process.cwd(), resolvedSrc);
+      resolvedSrc = path$c.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$d.symlink(resolvedSrc, dest, cb)
+      return fs$c.symlink(resolvedSrc, dest, cb)
     } else {
       if (opts.dereference) {
-        resolvedDest = path$d.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path$c.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$d.stat(dest, (err, st) => {
+      fs$c.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}'.`))
@@ -1802,17 +1802,17 @@ function onLink (resolvedDest, src, dest, opts, cb) {
 }
 
 function copyLink (resolvedSrc, dest, cb) {
-  fs$d.unlink(dest, err => {
+  fs$c.unlink(dest, err => {
     if (err) return cb(err)
-    return fs$d.symlink(resolvedSrc, dest, cb)
+    return fs$c.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$d.resolve(src).split(path$d.sep);
-  const destArray = path$d.resolve(dest).split(path$d.sep);
+  const srcArray = path$c.resolve(src).split(path$c.sep);
+  const destArray = path$c.resolve(dest).split(path$c.sep);
 
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -1821,7 +1821,7 @@ function isSrcSubdir$2 (src, dest) {
 
 // check if dest exists and is a symlink.
 function checkDest (dest, cb) {
-  fs$d.readlink(dest, (err, resolvedPath) => {
+  fs$c.readlink(dest, (err, resolvedPath) => {
     if (err) {
       if (err.code === 'ENOENT') return cb(null, notExist)
 
@@ -1836,8 +1836,8 @@ function checkDest (dest, cb) {
 
 function pathsAreIdentical (src, dest) {
   const os = process.platform;
-  const resolvedSrc = path$d.resolve(src);
-  const resolvedDest = path$d.resolve(dest);
+  const resolvedSrc = path$c.resolve(src);
+  const resolvedDest = path$c.resolve(dest);
   // case-insensitive paths
   if (os === 'darwin' || os === 'win32') {
     return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
@@ -1866,8 +1866,8 @@ var copy$1 = {
   copy: u$9(copy_1)
 };
 
-const fs$c = gracefulFs;
-const path$c = path__default["default"];
+const fs$b = gracefulFs;
+const path$b = path__default["default"];
 const assert = assert__default["default"];
 
 const isWindows = (process.platform === 'win32');
@@ -1882,9 +1882,9 @@ function defaults (options) {
     'readdir'
   ];
   methods.forEach(m => {
-    options[m] = options[m] || fs$c[m];
+    options[m] = options[m] || fs$b[m];
     m = m + 'Sync';
-    options[m] = options[m] || fs$c[m];
+    options[m] = options[m] || fs$b[m];
   });
 
   options.maxBusyTries = options.maxBusyTries || 3;
@@ -2072,7 +2072,7 @@ function rmkids (p, options, cb) {
     if (n === 0) return options.rmdir(p, cb)
 
     files.forEach(f => {
-      rimraf$1(path$c.join(p, f), options, er => {
+      rimraf$1(path$b.join(p, f), options, er => {
         if (errState) {
           return
         }
@@ -2154,7 +2154,7 @@ function rmdirSync (p, options, originalEr) {
 function rmkidsSync (p, options) {
   assert(p);
   assert(options);
-  options.readdirSync(p).forEach(f => rimrafSync(path$c.join(p, f), options));
+  options.readdirSync(p).forEach(f => rimrafSync(path$b.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.
@@ -2188,17 +2188,17 @@ var remove$2 = {
 };
 
 const u$7 = universalify.fromCallback;
-const fs$b = require$$1__default["default"];
-const path$b = path__default["default"];
+const fs$a = require$$1__default["default"];
+const path$a = 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$b.readdir(dir, (err, items) => {
+  fs$a.readdir(dir, (err, items) => {
     if (err) return mkdir$5.mkdirs(dir, callback)
 
-    items = items.map(item => path$b.join(dir, item));
+    items = items.map(item => path$a.join(dir, item));
 
     deleteItem();
 
@@ -2216,13 +2216,13 @@ const emptyDir = u$7(function emptyDir (dir, callback) {
 function emptyDirSync (dir) {
   let items;
   try {
-    items = fs$b.readdirSync(dir);
+    items = fs$a.readdirSync(dir);
   } catch (err) {
     return mkdir$5.mkdirsSync(dir)
   }
 
   items.forEach(item => {
-    item = path$b.join(dir, item);
+    item = path$a.join(dir, item);
     remove$1.removeSync(item);
   });
 }
@@ -2235,22 +2235,22 @@ var empty = {
 };
 
 const u$6 = universalify.fromCallback;
-const path$a = path__default["default"];
-const fs$a = gracefulFs;
+const path$9 = path__default["default"];
+const fs$9 = gracefulFs;
 const mkdir$4 = mkdirs_1;
 const pathExists$6 = pathExists_1.pathExists;
 
 function createFile (file, callback) {
   function makeFile () {
-    fs$a.writeFile(file, '', err => {
+    fs$9.writeFile(file, '', err => {
       if (err) return callback(err)
       callback();
     });
   }
 
-  fs$a.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+  fs$9.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
     if (!err && stats.isFile()) return callback()
-    const dir = path$a.dirname(file);
+    const dir = path$9.dirname(file);
     pathExists$6(dir, (err, dirExists) => {
       if (err) return callback(err)
       if (dirExists) return makeFile()
@@ -2265,16 +2265,16 @@ function createFile (file, callback) {
 function createFileSync (file) {
   let stats;
   try {
-    stats = fs$a.statSync(file);
+    stats = fs$9.statSync(file);
   } catch (e) {}
   if (stats && stats.isFile()) return
 
-  const dir = path$a.dirname(file);
-  if (!fs$a.existsSync(dir)) {
+  const dir = path$9.dirname(file);
+  if (!fs$9.existsSync(dir)) {
     mkdir$4.mkdirsSync(dir);
   }
 
-  fs$a.writeFileSync(file, '');
+  fs$9.writeFileSync(file, '');
 }
 
 var file$1 = {
@@ -2283,14 +2283,14 @@ var file$1 = {
 };
 
 const u$5 = universalify.fromCallback;
-const path$9 = path__default["default"];
-const fs$9 = gracefulFs;
+const path$8 = path__default["default"];
+const fs$8 = gracefulFs;
 const mkdir$3 = mkdirs_1;
 const pathExists$5 = pathExists_1.pathExists;
 
 function createLink (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
-    fs$9.link(srcpath, dstpath, err => {
+    fs$8.link(srcpath, dstpath, err => {
       if (err) return callback(err)
       callback(null);
     });
@@ -2299,13 +2299,13 @@ function createLink (srcpath, dstpath, callback) {
   pathExists$5(dstpath, (err, destinationExists) => {
     if (err) return callback(err)
     if (destinationExists) return callback(null)
-    fs$9.lstat(srcpath, (err) => {
+    fs$8.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink');
         return callback(err)
       }
 
-      const dir = path$9.dirname(dstpath);
+      const dir = path$8.dirname(dstpath);
       pathExists$5(dir, (err, dirExists) => {
         if (err) return callback(err)
         if (dirExists) return makeLink(srcpath, dstpath)
@@ -2319,22 +2319,22 @@ function createLink (srcpath, dstpath, callback) {
 }
 
 function createLinkSync (srcpath, dstpath) {
-  const destinationExists = fs$9.existsSync(dstpath);
+  const destinationExists = fs$8.existsSync(dstpath);
   if (destinationExists) return undefined
 
   try {
-    fs$9.lstatSync(srcpath);
+    fs$8.lstatSync(srcpath);
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
     throw err
   }
 
-  const dir = path$9.dirname(dstpath);
-  const dirExists = fs$9.existsSync(dir);
-  if (dirExists) return fs$9.linkSync(srcpath, dstpath)
+  const dir = path$8.dirname(dstpath);
+  const dirExists = fs$8.existsSync(dir);
+  if (dirExists) return fs$8.linkSync(srcpath, dstpath)
   mkdir$3.mkdirsSync(dir);
 
-  return fs$9.linkSync(srcpath, dstpath)
+  return fs$8.linkSync(srcpath, dstpath)
 }
 
 var link$1 = {
@@ -2342,8 +2342,8 @@ var link$1 = {
   createLinkSync
 };
 
-const path$8 = path__default["default"];
-const fs$8 = gracefulFs;
+const path$7 = path__default["default"];
+const fs$7 = gracefulFs;
 const pathExists$4 = pathExists_1.pathExists;
 
 /**
@@ -2369,8 +2369,8 @@ const pathExists$4 = pathExists_1.pathExists;
  */
 
 function symlinkPaths$1 (srcpath, dstpath, callback) {
-  if (path$8.isAbsolute(srcpath)) {
-    return fs$8.lstat(srcpath, (err) => {
+  if (path$7.isAbsolute(srcpath)) {
+    return fs$7.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureSymlink');
         return callback(err)
@@ -2381,8 +2381,8 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
       })
     })
   } else {
-    const dstdir = path$8.dirname(dstpath);
-    const relativeToDst = path$8.join(dstdir, srcpath);
+    const dstdir = path$7.dirname(dstpath);
+    const relativeToDst = path$7.join(dstdir, srcpath);
     return pathExists$4(relativeToDst, (err, exists) => {
       if (err) return callback(err)
       if (exists) {
@@ -2391,14 +2391,14 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
           'toDst': srcpath
         })
       } else {
-        return fs$8.lstat(srcpath, (err) => {
+        return fs$7.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace('lstat', 'ensureSymlink');
             return callback(err)
           }
           return callback(null, {
             'toCwd': srcpath,
-            'toDst': path$8.relative(dstdir, srcpath)
+            'toDst': path$7.relative(dstdir, srcpath)
           })
         })
       }
@@ -2408,28 +2408,28 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
 
 function symlinkPathsSync$1 (srcpath, dstpath) {
   let exists;
-  if (path$8.isAbsolute(srcpath)) {
-    exists = fs$8.existsSync(srcpath);
+  if (path$7.isAbsolute(srcpath)) {
+    exists = fs$7.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       'toCwd': srcpath,
       'toDst': srcpath
     }
   } else {
-    const dstdir = path$8.dirname(dstpath);
-    const relativeToDst = path$8.join(dstdir, srcpath);
-    exists = fs$8.existsSync(relativeToDst);
+    const dstdir = path$7.dirname(dstpath);
+    const relativeToDst = path$7.join(dstdir, srcpath);
+    exists = fs$7.existsSync(relativeToDst);
     if (exists) {
       return {
         'toCwd': relativeToDst,
         'toDst': srcpath
       }
     } else {
-      exists = fs$8.existsSync(srcpath);
+      exists = fs$7.existsSync(srcpath);
       if (!exists) throw new Error('relative srcpath does not exist')
       return {
         'toCwd': srcpath,
-        'toDst': path$8.relative(dstdir, srcpath)
+        'toDst': path$7.relative(dstdir, srcpath)
       }
     }
   }
@@ -2440,13 +2440,13 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$7 = gracefulFs;
+const fs$6 = 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$7.lstat(srcpath, (err, stats) => {
+  fs$6.lstat(srcpath, (err, stats) => {
     if (err) return callback(null, 'file')
     type = (stats && stats.isDirectory()) ? 'dir' : 'file';
     callback(null, type);
@@ -2458,7 +2458,7 @@ function symlinkTypeSync$1 (srcpath, type) {
 
   if (type) return type
   try {
-    stats = fs$7.lstatSync(srcpath);
+    stats = fs$6.lstatSync(srcpath);
   } catch (e) {
     return 'file'
   }
@@ -2471,8 +2471,8 @@ var symlinkType_1 = {
 };
 
 const u$4 = universalify.fromCallback;
-const path$7 = path__default["default"];
-const fs$6 = gracefulFs;
+const path$6 = path__default["default"];
+const fs$5 = gracefulFs;
 const _mkdirs = mkdirs_1;
 const mkdirs = _mkdirs.mkdirs;
 const mkdirsSync = _mkdirs.mkdirsSync;
@@ -2499,13 +2499,13 @@ function createSymlink (srcpath, dstpath, type, callback) {
       srcpath = relative.toDst;
       symlinkType(relative.toCwd, type, (err, type) => {
         if (err) return callback(err)
-        const dir = path$7.dirname(dstpath);
+        const dir = path$6.dirname(dstpath);
         pathExists$3(dir, (err, dirExists) => {
           if (err) return callback(err)
-          if (dirExists) return fs$6.symlink(srcpath, dstpath, type, callback)
+          if (dirExists) return fs$5.symlink(srcpath, dstpath, type, callback)
           mkdirs(dir, err => {
             if (err) return callback(err)
-            fs$6.symlink(srcpath, dstpath, type, callback);
+            fs$5.symlink(srcpath, dstpath, type, callback);
           });
         });
       });
@@ -2514,17 +2514,17 @@ function createSymlink (srcpath, dstpath, type, callback) {
 }
 
 function createSymlinkSync (srcpath, dstpath, type) {
-  const destinationExists = fs$6.existsSync(dstpath);
+  const destinationExists = fs$5.existsSync(dstpath);
   if (destinationExists) return undefined
 
   const relative = symlinkPathsSync(srcpath, dstpath);
   srcpath = relative.toDst;
   type = symlinkTypeSync(relative.toCwd, type);
-  const dir = path$7.dirname(dstpath);
-  const exists = fs$6.existsSync(dir);
-  if (exists) return fs$6.symlinkSync(srcpath, dstpath, type)
+  const dir = path$6.dirname(dstpath);
+  const exists = fs$5.existsSync(dir);
+  if (exists) return fs$5.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$6.symlinkSync(srcpath, dstpath, type)
+  return fs$5.symlinkSync(srcpath, dstpath, type)
 }
 
 var symlink$1 = {
@@ -2700,7 +2700,7 @@ var jsonfile = {
   writeJsonSync: jsonFile$3.writeFileSync
 };
 
-const path$6 = path__default["default"];
+const path$5 = path__default["default"];
 const mkdir$2 = mkdirs_1;
 const pathExists$2 = pathExists_1.pathExists;
 const jsonFile$2 = jsonfile;
@@ -2711,7 +2711,7 @@ function outputJson (file, data, options, callback) {
     options = {};
   }
 
-  const dir = path$6.dirname(file);
+  const dir = path$5.dirname(file);
 
   pathExists$2(dir, (err, itDoes) => {
     if (err) return callback(err)
@@ -2726,15 +2726,15 @@ function outputJson (file, data, options, callback) {
 
 var outputJson_1 = outputJson;
 
-const fs$5 = gracefulFs;
-const path$5 = path__default["default"];
+const fs$4 = gracefulFs;
+const path$4 = path__default["default"];
 const mkdir$1 = mkdirs_1;
 const jsonFile$1 = jsonfile;
 
 function outputJsonSync (file, data, options) {
-  const dir = path$5.dirname(file);
+  const dir = path$4.dirname(file);
 
-  if (!fs$5.existsSync(dir)) {
+  if (!fs$4.existsSync(dir)) {
     mkdir$1.mkdirsSync(dir);
   }
 
@@ -2758,8 +2758,8 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json = jsonFile;
 
-const fs$4 = gracefulFs;
-const path$4 = path__default["default"];
+const fs$3 = gracefulFs;
+const path$3 = path__default["default"];
 const copySync = copySync$1.copySync;
 const removeSync = remove$2.removeSync;
 const mkdirpSync = mkdirs_1.mkdirsSync;
@@ -2769,20 +2769,20 @@ function moveSync (src, dest, options) {
   options = options || {};
   const overwrite = options.overwrite || options.clobber || false;
 
-  src = path$4.resolve(src);
-  dest = path$4.resolve(dest);
+  src = path$3.resolve(src);
+  dest = path$3.resolve(dest);
 
-  if (src === dest) return fs$4.accessSync(src)
+  if (src === dest) return fs$3.accessSync(src)
 
   if (isSrcSubdir$1(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
 
-  mkdirpSync(path$4.dirname(dest));
+  mkdirpSync(path$3.dirname(dest));
   tryRenameSync();
 
   function tryRenameSync () {
     if (overwrite) {
       try {
-        return fs$4.renameSync(src, dest)
+        return fs$3.renameSync(src, dest)
       } catch (err) {
         if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'EPERM') {
           removeSync(dest);
@@ -2795,8 +2795,8 @@ function moveSync (src, dest, options) {
       }
     } else {
       try {
-        fs$4.linkSync(src, dest);
-        return fs$4.unlinkSync(src)
+        fs$3.linkSync(src, dest);
+        return fs$3.unlinkSync(src)
       } catch (err) {
         if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM' || err.code === 'ENOTSUP') {
           return moveSyncAcrossDevice(src, dest, overwrite)
@@ -2808,7 +2808,7 @@ function moveSync (src, dest, options) {
 }
 
 function moveSyncAcrossDevice (src, dest, overwrite) {
-  const stat = fs$4.statSync(src);
+  const stat = fs$3.statSync(src);
 
   if (stat.isDirectory()) {
     return moveDirSyncAcrossDevice(src, dest, overwrite)
@@ -2823,20 +2823,20 @@ function moveFileSyncAcrossDevice (src, dest, overwrite) {
 
   const flags = overwrite ? 'w' : 'wx';
 
-  const fdr = fs$4.openSync(src, 'r');
-  const stat = fs$4.fstatSync(fdr);
-  const fdw = fs$4.openSync(dest, flags, stat.mode);
+  const fdr = fs$3.openSync(src, 'r');
+  const stat = fs$3.fstatSync(fdr);
+  const fdw = fs$3.openSync(dest, flags, stat.mode);
   let pos = 0;
 
   while (pos < stat.size) {
-    const bytesRead = fs$4.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    fs$4.writeSync(fdw, _buff, 0, bytesRead);
+    const bytesRead = fs$3.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$3.writeSync(fdw, _buff, 0, bytesRead);
     pos += bytesRead;
   }
 
-  fs$4.closeSync(fdr);
-  fs$4.closeSync(fdw);
-  return fs$4.unlinkSync(src)
+  fs$3.closeSync(fdr);
+  fs$3.closeSync(fdw);
+  return fs$3.unlinkSync(src)
 }
 
 function moveDirSyncAcrossDevice (src, dest, overwrite) {
@@ -2861,10 +2861,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$4.statSync(src).isDirectory() &&
+    return fs$3.statSync(src).isDirectory() &&
            src !== dest &&
            dest.indexOf(src) > -1 &&
-           dest.split(path$4.dirname(src) + path$4.sep)[1].split(path$4.sep)[0] === path$4.basename(src)
+           dest.split(path$3.dirname(src) + path$3.sep)[1].split(path$3.sep)[0] === path$3.basename(src)
   } catch (e) {
     return false
   }
@@ -2875,8 +2875,8 @@ var moveSync_1 = {
 };
 
 const u$1 = universalify.fromCallback;
-const fs$3 = gracefulFs;
-const path$3 = path__default["default"];
+const fs$2 = gracefulFs;
+const path$2 = path__default["default"];
 const copy = copy$1.copy;
 const remove = remove$2.remove;
 const mkdirp = mkdirs_1.mkdirp;
@@ -2890,18 +2890,18 @@ function move (src, dest, opts, cb) {
 
   const overwrite = opts.overwrite || opts.clobber || false;
 
-  src = path$3.resolve(src);
-  dest = path$3.resolve(dest);
+  src = path$2.resolve(src);
+  dest = path$2.resolve(dest);
 
-  if (src === dest) return fs$3.access(src, cb)
+  if (src === dest) return fs$2.access(src, cb)
 
-  fs$3.stat(src, (err, st) => {
+  fs$2.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$3.dirname(dest), err => {
+    mkdirp(path$2.dirname(dest), err => {
       if (err) return cb(err)
       return doRename(src, dest, overwrite, cb)
     });
@@ -2923,7 +2923,7 @@ function doRename (src, dest, overwrite, cb) {
 }
 
 function rename (src, dest, overwrite, cb) {
-  fs$3.rename(src, dest, err => {
+  fs$2.rename(src, dest, err => {
     if (!err) return cb()
     if (err.code !== 'EXDEV') return cb(err)
     return moveAcrossDevice(src, dest, overwrite, cb)
@@ -2943,8 +2943,8 @@ function moveAcrossDevice (src, dest, overwrite, cb) {
 }
 
 function isSrcSubdir (src, dest) {
-  const srcArray = src.split(path$3.sep);
-  const destArray = dest.split(path$3.sep);
+  const srcArray = src.split(path$2.sep);
+  const destArray = dest.split(path$2.sep);
 
   return srcArray.reduce((acc, current, i) => {
     return acc && destArray[i] === current
@@ -2956,8 +2956,8 @@ var move_1 = {
 };
 
 const u = universalify.fromCallback;
-const fs$2 = gracefulFs;
-const path$2 = path__default["default"];
+const fs$1 = gracefulFs;
+const path$1 = path__default["default"];
 const mkdir = mkdirs_1;
 const pathExists = pathExists_1.pathExists;
 
@@ -2967,26 +2967,26 @@ function outputFile (file, data, encoding, callback) {
     encoding = 'utf8';
   }
 
-  const dir = path$2.dirname(file);
+  const dir = path$1.dirname(file);
   pathExists(dir, (err, itDoes) => {
     if (err) return callback(err)
-    if (itDoes) return fs$2.writeFile(file, data, encoding, callback)
+    if (itDoes) return fs$1.writeFile(file, data, encoding, callback)
 
     mkdir.mkdirs(dir, err => {
       if (err) return callback(err)
 
-      fs$2.writeFile(file, data, encoding, callback);
+      fs$1.writeFile(file, data, encoding, callback);
     });
   });
 }
 
 function outputFileSync (file, ...args) {
-  const dir = path$2.dirname(file);
-  if (fs$2.existsSync(dir)) {
-    return fs$2.writeFileSync(file, ...args)
+  const dir = path$1.dirname(file);
+  if (fs$1.existsSync(dir)) {
+    return fs$1.writeFileSync(file, ...args)
   }
   mkdir.mkdirsSync(dir);
-  fs$2.writeFileSync(file, ...args);
+  fs$1.writeFileSync(file, ...args);
 }
 
 var output = {
@@ -2999,7 +2999,7 @@ var output = {
 	module.exports = Object.assign(
 	  {},
 	  // Export promiseified graceful-fs:
-	  fs$k,
+	  fs$j,
 	  // Export extra methods:
 	  copySync$1,
 	  copy$1,
@@ -3024,7 +3024,7 @@ var output = {
 	}
 } (lib));
 
-var fs$1 = libExports;
+var fs = libExports;
 
 class Compile extends EventEmitter__default["default"] {
     constructor(args, argv0, dir, debug) {
@@ -3205,7 +3205,7 @@ class Compile extends EventEmitter__default["default"] {
         if (debug) {
             console.log("Calling", argv0, compiler, args.map((x) => '"' + x + '"').join(" "));
         }
-        if (!fs$1.existsSync("/usr/bin/as")) {
+        if (!fs.existsSync("/usr/bin/as")) {
             this.emit("stderr", "as doesn't exist");
         }
         // const env = Object.assign({ TMPDIR: dir, TEMPDIR: dir, TEMP: dir }, process.env);
@@ -3229,13 +3229,13 @@ class Compile extends EventEmitter__default["default"] {
             const files = [];
             const addDir = (dir, prefix) => {
                 try {
-                    fs$1.readdirSync(dir).forEach((file) => {
+                    fs.readdirSync(dir).forEach((file) => {
                         if (file === "sourcefile") {
                             return;
                         }
                         try {
                             assert__default["default"](output !== undefined, "Must have output");
-                            const stat = fs$1.statSync(path__default["default"].join(dir, file));
+                            const stat = fs.statSync(path__default["default"].join(dir, file));
                             if (stat.isDirectory()) {
                                 addDir(path__default["default"].join(dir, file), prefix ? prefix + file + "/" : file + "/");
                             }
@@ -3312,309 +3312,6 @@ class Compile extends EventEmitter__default["default"] {
 // });
 module.exports = Compile;
 
-var posixExports = {};
-var posix$2 = {
-  get exports(){ return posixExports; },
-  set exports(v){ posixExports = v; },
-};
-
-var path$1 = path__default["default"];
-
-
-var IS_LINUX = require$$1__default$1["default"].platform() === 'linux';
-
-
-// Attempt to load the bindings module from various possible locations
-function load_extension() {
-    var ext_dirs = [
-        'build/bindings', 'build/Release', 'out/Release', 'Release',
-        'build/Debug', 'out/Debug',
-    ], i;
-    for (i in ext_dirs) {
-        try {
-            return require(path$1.join(__dirname, '../..', ext_dirs[i],
-                                      'posix.node'));
-
-        } catch (error) {
-            if (!/Cannot find module/.test(error.message)) {
-                throw error;
-            }
-        }
-    }
-    throw new Error("unable to load the node-posix extension module");
-}
-
-var posix$1 = load_extension();
-
-var syslog_constants = {};
-posix$1.update_syslog_constants(syslog_constants);
-
-function syslog_const(value) {
-    if (syslog_constants[value] === undefined) {
-        throw new Error("invalid syslog constant value: " + value);
-    }
-
-    return syslog_constants[value];
-}
-
-function syslog_flags(option, prefix) {
-    prefix = prefix || "";
-    var opt = 0, key, flag;
-    for (key in option) {
-        flag = syslog_const(prefix + key); // checks all flags
-        opt |= option[key] ? flag : 0;
-    }
-    return opt;
-}
-
-posix$2.exports = {
-    getgid: process.getgid,
-    getuid: process.getuid,
-    setgid: process.setgid,
-    setuid: process.setuid,
-
-    chroot: posix$1.chroot,
-    closelog: posix$1.closelog,
-    getegid: posix$1.getegid,
-    geteuid: posix$1.geteuid,
-    getgrnam: posix$1.getgrnam,
-    getpgid: posix$1.getpgid,
-    setpgid: posix$1.setpgid,
-    getppid: posix$1.getppid,
-    getpwnam: posix$1.getpwnam,
-    getrlimit: posix$1.getrlimit,
-    setrlimit: posix$1.setrlimit,
-    setsid: posix$1.setsid,
-
-    openlog: function (ident, option, facility) {
-        return posix$1.openlog(ident, syslog_flags(option),
-                             syslog_const(facility));
-    },
-
-    syslog: function (priority, message) {
-        return posix$1.syslog(syslog_const(priority), message);
-    },
-
-    setlogmask: function (maskpri) {
-        var bits = posix$1.setlogmask(syslog_flags(maskpri, "mask_")), flags = {}, key;
-        for (key in syslog_constants) {
-            if (key.match("^mask_")) {
-                flags[key.substr(5, 10)] = (bits & syslog_constants[key])
-                    ? true : false;
-            }
-        }
-        return flags;
-    },
-
-    // http://pubs.opengroup.org/onlinepubs/007904875/functions/getpgrp.html
-    getpgrp: function () {
-        return posix$1.getpgid(0);
-    },
-
-    seteuid: function (euid) {
-        euid = (typeof (euid) === 'string') ? posix$1.getpwnam(euid).uid : euid;
-        return posix$1.seteuid(euid);
-    },
-
-    setreuid: function (ruid, euid) {
-        ruid = (typeof (ruid) === 'string') ? posix$1.getpwnam(ruid).uid : ruid;
-        euid = (typeof (euid) === 'string') ? posix$1.getpwnam(euid).uid : euid;
-        return posix$1.setreuid(ruid, euid);
-    },
-
-    setegid: function (egid) {
-        egid = (typeof (egid) === 'string') ? posix$1.getgrnam(egid).gid : egid;
-        return posix$1.setegid(egid);
-    },
-
-    setregid: function (rgid, egid) {
-        rgid = (typeof (rgid) === 'string') ? posix$1.getgrnam(rgid).gid : rgid;
-        egid = (typeof (egid) === 'string') ? posix$1.getgrnam(egid).gid : egid;
-        return posix$1.setregid(rgid, egid);
-    },
-
-    gethostname: posix$1.gethostname,
-    sethostname: posix$1.sethostname,
-};
-
-var swap_constants = {};
-
-function swap_const(value) {
-    var constant = swap_constants[value];
-    if (constant === undefined) {
-        throw "invalid swap constant value: " + value;
-    }
-
-    return constant;
-}
-
-function swap_flags(option) {
-    var opt = 0, key, flag;
-    for (key in option) {
-        flag = swap_const(key);  // checks all flags
-        opt |= option[key] ? flag : 0;
-    }
-    return opt;
-}
-
-
-if (IS_LINUX) {
-    posix$1.update_swap_constants(swap_constants);
-    posixExports.swapon = function (path, swapflags) {
-        return posix$1.swapon(path, swap_flags(swapflags));
-    };
-    posixExports.swapoff = posix$1.swapoff;
-}
-
-if ('initgroups' in posix$1) {
-    // initgroups is in SVr4 and 4.3BSD, not POSIX
-    posixExports.initgroups = function (user, group) {
-        var gid = (typeof (group) === 'string') ? posix$1.getgrnam(group).gid : group;
-        return posix$1.initgroups(user, gid);
-    };
-}
-
-/**
- * Copyright (c) 2014, 2015, 2021 Tim Kuijsten
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-var fs = require$$1__default["default"];
-var path = path__default["default"];
-
-var posix = posixExports;
-
-/**
- * Change the root directory of the current process. A normal user must be provided
- * since changing root without dropping privileges makes no sense from a security
- * point of view.
- *
- * @param {String} newRoot  The path to the new root directory for this process.
- *        The whole path should be owned by the super user and may not be writable
- *        by the group owner or others.
- * @param {String|Number} user  The user to switch to after changing the root
- *        directory. Can be either a name or an id.
- * @param {String|Number} [group]  The group to switch to after changing the root
- *        directory. Can be either a name or an id of any group the user belongs to
- *        (see /etc/groups). Defaults to the users primary group (see /etc/passwd).
- * @throw if any operation fails
- */
-var chroot = function chroot(newRoot, user, group) {
-  if (typeof newRoot !== 'string') { throw new TypeError('newRoot must be a string'); }
-  if (typeof user !== 'string' && typeof user !== 'number') { throw new TypeError('user must be a string or a number'); }
-  if (typeof group !== 'undefined') {
-    if (typeof group !== 'string' && typeof group !== 'number') { throw new TypeError('group must be a string or a number'); }
-  }
-
-  if (!(newRoot.length > 0)) { throw new Error('newRoot must contain at least one character'); }
-  if (typeof user === 'string' && !(user.length > 0)) { throw new Error('user must contain at least one character'); }
-
-  if (process.getuid() !== 0 || posix.geteuid() !== 0) {
-    throw new Error('chroot must be called while running as root');
-  }
-
-  var pwd, grp, uid, gid;
-
-  // resolve user to a numeric id
-  try {
-    pwd = posix.getpwnam(user);
-  } catch(err) {
-    throw new Error('user not found: ' + user);
-  }
-
-  uid = pwd.uid;
-  gid = pwd.gid;
-
-  if (typeof group !== 'undefined') {
-    if (typeof group === 'number') {
-      gid = group;
-    } else {
-      // resolve group to a numeric id
-      try {
-        grp = posix.getgrnam(group);
-      } catch(err) {
-        throw new Error('group not found: ' + group);
-      }
-
-      gid = grp.gid;
-    }
-  }
-
-
-  if (typeof uid !== 'number') { throw new TypeError('could not resolve the user to a number'); }
-  if (typeof gid !== 'number') { throw new TypeError('could not resolve the group to a number'); }
-
-  if (!(uid > 0)) { throw new Error('new user can not have user id 0'); }
-  if (!(gid > 0)) { throw new Error('new group can not have group id 0'); }
-
-  // check permissions up to the original root of the file system
-  var rpath = newRoot = fs.realpathSync(newRoot);
-
-  var stats;
-  do {
-    stats = fs.statSync(rpath);
-    if (stats.uid !== 0 || (stats.mode & (fs.constants.S_IWGRP | fs.constants.S_IWOTH)) !== 0) {
-      throw new Error('bad chroot dir ' + rpath + ' owner: ' + stats.uid + ' or permissions: 0' + stats.mode.toString(8));
-    }
-    rpath = path.dirname(rpath);
-  } while (rpath !== '/');
-
-  try {
-    posix.chroot(newRoot);
-  } catch(err) {
-    throw new Error('changing root failed: ' + err.message);
-  }
-  process.chdir('/');
-
-  // PWD might be set in some environments and is part of POSIX
-  if (typeof process.env.PWD !== 'undefined') {
-    process.env.PWD = '/';
-  }
-
-  try {
-    if (typeof group === 'undefined') {
-      // change to the given user and all the groups that it is a member of
-      process.initgroups(uid, gid);
-    } else {
-      // change to the given user and the given group (not all groups the user is member of)
-      process.setgroups([gid]);
-    }
-  } catch(err) {
-    throw new Error('changing groups failed: ' + err.message);
-  }
-
-  process.setgid(gid);
-  process.setuid(uid);
-
-  // try to restore privileges
-  try {
-    posix.setreuid(-1, 0);
-  } catch(err) {
-    // double check real and effective ids of the user and group and supplemental groups
-    var ids = [process.getuid(), process.getgid(), posix.geteuid(), posix.getegid()];
-    Array.prototype.push.apply(ids, process.getgroups());
-
-    // if none of the ids is zero, privileges are successfully dropped 
-    if (!~ids.indexOf(0)) {
-      // success
-      return;
-    }
-  }
-
-  throw new Error('unable to drop privileges');
-};
-
 var minimist = function (args, opts) {
     if (!opts) opts = {};
     
@@ -3865,6 +3562,168 @@ function isConstructorOrProto (obj, key) {
     return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
 }
 
+var posixExports = {};
+var posix$1 = {
+  get exports(){ return posixExports; },
+  set exports(v){ posixExports = v; },
+};
+
+var path = path__default["default"];
+
+
+var IS_LINUX = require$$1__default$1["default"].platform() === 'linux';
+
+
+// Attempt to load the bindings module from various possible locations
+function load_extension() {
+    var ext_dirs = [
+        'build/bindings', 'build/Release', 'out/Release', 'Release',
+        'build/Debug', 'out/Debug',
+    ], i;
+    for (i in ext_dirs) {
+        try {
+            return require(path.join(__dirname, '../..', ext_dirs[i],
+                                      'posix.node'));
+
+        } catch (error) {
+            if (!/Cannot find module/.test(error.message)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error("unable to load the node-posix extension module");
+}
+
+var posix = load_extension();
+
+var syslog_constants = {};
+posix.update_syslog_constants(syslog_constants);
+
+function syslog_const(value) {
+    if (syslog_constants[value] === undefined) {
+        throw new Error("invalid syslog constant value: " + value);
+    }
+
+    return syslog_constants[value];
+}
+
+function syslog_flags(option, prefix) {
+    prefix = prefix || "";
+    var opt = 0, key, flag;
+    for (key in option) {
+        flag = syslog_const(prefix + key); // checks all flags
+        opt |= option[key] ? flag : 0;
+    }
+    return opt;
+}
+
+posix$1.exports = {
+    getgid: process.getgid,
+    getuid: process.getuid,
+    setgid: process.setgid,
+    setuid: process.setuid,
+
+    chroot: posix.chroot,
+    closelog: posix.closelog,
+    getegid: posix.getegid,
+    geteuid: posix.geteuid,
+    getgrnam: posix.getgrnam,
+    getpgid: posix.getpgid,
+    setpgid: posix.setpgid,
+    getppid: posix.getppid,
+    getpwnam: posix.getpwnam,
+    getrlimit: posix.getrlimit,
+    setrlimit: posix.setrlimit,
+    setsid: posix.setsid,
+
+    openlog: function (ident, option, facility) {
+        return posix.openlog(ident, syslog_flags(option),
+                             syslog_const(facility));
+    },
+
+    syslog: function (priority, message) {
+        return posix.syslog(syslog_const(priority), message);
+    },
+
+    setlogmask: function (maskpri) {
+        var bits = posix.setlogmask(syslog_flags(maskpri, "mask_")), flags = {}, key;
+        for (key in syslog_constants) {
+            if (key.match("^mask_")) {
+                flags[key.substr(5, 10)] = (bits & syslog_constants[key])
+                    ? true : false;
+            }
+        }
+        return flags;
+    },
+
+    // http://pubs.opengroup.org/onlinepubs/007904875/functions/getpgrp.html
+    getpgrp: function () {
+        return posix.getpgid(0);
+    },
+
+    seteuid: function (euid) {
+        euid = (typeof (euid) === 'string') ? posix.getpwnam(euid).uid : euid;
+        return posix.seteuid(euid);
+    },
+
+    setreuid: function (ruid, euid) {
+        ruid = (typeof (ruid) === 'string') ? posix.getpwnam(ruid).uid : ruid;
+        euid = (typeof (euid) === 'string') ? posix.getpwnam(euid).uid : euid;
+        return posix.setreuid(ruid, euid);
+    },
+
+    setegid: function (egid) {
+        egid = (typeof (egid) === 'string') ? posix.getgrnam(egid).gid : egid;
+        return posix.setegid(egid);
+    },
+
+    setregid: function (rgid, egid) {
+        rgid = (typeof (rgid) === 'string') ? posix.getgrnam(rgid).gid : rgid;
+        egid = (typeof (egid) === 'string') ? posix.getgrnam(egid).gid : egid;
+        return posix.setregid(rgid, egid);
+    },
+
+    gethostname: posix.gethostname,
+    sethostname: posix.sethostname,
+};
+
+var swap_constants = {};
+
+function swap_const(value) {
+    var constant = swap_constants[value];
+    if (constant === undefined) {
+        throw "invalid swap constant value: " + value;
+    }
+
+    return constant;
+}
+
+function swap_flags(option) {
+    var opt = 0, key, flag;
+    for (key in option) {
+        flag = swap_const(key);  // checks all flags
+        opt |= option[key] ? flag : 0;
+    }
+    return opt;
+}
+
+
+if (IS_LINUX) {
+    posix.update_swap_constants(swap_constants);
+    posixExports.swapon = function (path, swapflags) {
+        return posix.swapon(path, swap_flags(swapflags));
+    };
+    posixExports.swapoff = posix.swapoff;
+}
+
+if ('initgroups' in posix) {
+    // initgroups is in SVr4 and 4.3BSD, not POSIX
+    posixExports.initgroups = function (user, group) {
+        var gid = (typeof (group) === 'string') ? posix.getgrnam(group).gid : group;
+        return posix.initgroups(user, gid);
+    };
+}
+
 const argv = minimist(process.argv.slice(2));
 function send(message) {
     try {
@@ -3884,19 +3743,34 @@ process.on("uncaughtException", (err) => {
     send({ type: "error", message: `Uncaught exception ${err.stack} ${err.toString()}` });
     console.error("Uncaught exception", err);
 });
-// let pwd;
+let pwd;
+if (argv.user) {
+    try {
+        pwd = posixExports.getpwnam(argv.user);
+    }
+    catch (err) {
+        console.error("Couldn't find user", argv.user);
+        throw err;
+    }
+    try {
+        process.initgroups(argv.user, pwd.gid);
+    }
+    catch (err) {
+        throw new Error("Changing groups failed: " + err.message);
+    }
+}
 try {
     console.log("Chrooting to", argv.root);
-    chroot(argv.root, argv.user || "root");
+    posixExports.chroot(argv.root);
 }
 catch (err) {
     console.error("Changing root or user failed", err);
     process.exit(1);
 }
-// if (pwd) {
-//     process.setgid(pwd.gid);
-//     process.setuid(pwd.uid);
-// }
+if (pwd) {
+    process.setgid(pwd.gid);
+    process.setuid(pwd.uid);
+}
 process.on("error", (error) => {
     console.error(`Got process error ${error} ${JSON.stringify(argv)}. Going down`);
     process.exit();