vis-dev-utils 3.0.121 → 3.1.0

package/bin/test-e2e-interop.js

@@ -6,8 +6,8 @@
  *
  * Development utilities for the Vis family projects.
  *
- * @version 3.0.121
- * @date    2023-02-16T02:27:46.245Z
+ * @version 3.1.0
+ * @date    2023-03-04T19:12:02.714Z
  *
  * @copyright (c) 2011-2017 Almende B.V, http://almende.com
  * @copyright (c) 2017-2019 visjs contributors, https://github.com/visjs
@@ -73,52 +73,7 @@ var _defineProperty = require('@babel/runtime-corejs3/helpers/defineProperty');
 var _padStartInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/pad-start');
 var node_child_process = require('node:child_process');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _Array$from__default = /*#__PURE__*/_interopDefaultLegacy(_Array$from);
-var _Symbol__default = /*#__PURE__*/_interopDefaultLegacy(_Symbol);
-var _getIteratorMethod__default = /*#__PURE__*/_interopDefaultLegacy(_getIteratorMethod);
-var _Array$isArray__default = /*#__PURE__*/_interopDefaultLegacy(_Array$isArray);
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
-var _reduceInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_reduceInstanceProperty);
-var _mapInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_mapInstanceProperty);
-var _flatMapInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_flatMapInstanceProperty);
-var _sliceInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_sliceInstanceProperty);
-var yargs__default = /*#__PURE__*/_interopDefaultLegacy(yargs);
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
-var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
-var _Set__default = /*#__PURE__*/_interopDefaultLegacy(_Set);
-var _concatInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_concatInstanceProperty);
-var _Object$keys__default = /*#__PURE__*/_interopDefaultLegacy(_Object$keys);
-var _filterInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_filterInstanceProperty);
-var _forEachInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_forEachInstanceProperty);
-var _JSON$stringify__default = /*#__PURE__*/_interopDefaultLegacy(_JSON$stringify);
-var _Object$create__default = /*#__PURE__*/_interopDefaultLegacy(_Object$create);
-var _Object$freeze__default = /*#__PURE__*/_interopDefaultLegacy(_Object$freeze);
-var _Map__default = /*#__PURE__*/_interopDefaultLegacy(_Map);
-var _Promise__default = /*#__PURE__*/_interopDefaultLegacy(_Promise);
-var _everyInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_everyInstanceProperty);
-var _valuesInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_valuesInstanceProperty);
-var _repeatInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_repeatInstanceProperty);
-var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
-var findUp__default = /*#__PURE__*/_interopDefaultLegacy(findUp);
-var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
-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 require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
-var _Object$getOwnPropertySymbols__default = /*#__PURE__*/_interopDefaultLegacy(_Object$getOwnPropertySymbols);
-var _Object$getOwnPropertyDescriptor__default = /*#__PURE__*/_interopDefaultLegacy(_Object$getOwnPropertyDescriptor);
-var _Object$getOwnPropertyDescriptors__default = /*#__PURE__*/_interopDefaultLegacy(_Object$getOwnPropertyDescriptors);
-var _Object$defineProperties__default = /*#__PURE__*/_interopDefaultLegacy(_Object$defineProperties);
-var _Object$defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_Object$defineProperty);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _padStartInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_padStartInstanceProperty);
-
-var y = yargs__default["default"].strict(true).usage("test-e2e-interop [options]").hide("version").config().help().option("fail-command", {
+var y = yargs.strict(true).usage("test-e2e-interop [options]").hide("version").config().help().option("fail-command", {
   demandOption: false,
   describe: 'This command will be run in a shell (therefore commands like "$SHELL" will work) after failure to inspect the state.',
   type: "string"
@@ -161,31 +116,38 @@ var universalify$1 = {};
 
 universalify$1.fromCallback = function (fn) {
   return Object.defineProperty(function (...args) {
-    if (typeof args[args.length - 1] === 'function') fn.apply(this, args);else {
+    if (typeof args[args.length - 1] === 'function') fn.apply(this, args);
+    else {
       return new Promise((resolve, reject) => {
-        fn.call(this, ...args, (err, res) => err != null ? reject(err) : resolve(res));
-      });
+        fn.call(
+          this,
+          ...args,
+          (err, res) => (err != null) ? reject(err) : resolve(res)
+        );
+      })
     }
-  }, 'name', {
-    value: fn.name
-  });
+  }, 'name', { value: fn.name })
 };
+
 universalify$1.fromPromise = function (fn) {
   return Object.defineProperty(function (...args) {
     const cb = args[args.length - 1];
-    if (typeof cb !== 'function') return fn.apply(this, args);else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb);
-  }, 'name', {
-    value: fn.name
-  });
+    if (typeof cb !== 'function') return fn.apply(this, args)
+    else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb);
+  }, 'name', { value: fn.name })
 };
 
-var constants = require$$0__default["default"];
+var constants = require$$0;
+
 var origCwd = process.cwd;
 var cwd = null;
+
 var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-process.cwd = function () {
-  if (!cwd) cwd = origCwd.call(process);
-  return cwd;
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process);
+  return cwd
 };
 try {
   process.cwd();
@@ -200,13 +162,16 @@ if (typeof process.chdir === 'function') {
   };
   if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
 }
+
 var polyfills$1 = patch$1;
-function patch$1(fs) {
+
+function patch$1 (fs) {
   // (re-)implement some things that are known busted or missing.
 
   // lchmod, broken prior to 0.6.2
   // back-port the fix here.
-  if (constants.hasOwnProperty('O_SYMLINK') && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
     patchLchmod(fs);
   }
 
@@ -223,18 +188,23 @@ function patch$1(fs) {
   fs.chown = chownFix(fs.chown);
   fs.fchown = chownFix(fs.fchown);
   fs.lchown = chownFix(fs.lchown);
+
   fs.chmod = chmodFix(fs.chmod);
   fs.fchmod = chmodFix(fs.fchmod);
   fs.lchmod = chmodFix(fs.lchmod);
+
   fs.chownSync = chownFixSync(fs.chownSync);
   fs.fchownSync = chownFixSync(fs.fchownSync);
   fs.lchownSync = chownFixSync(fs.lchownSync);
+
   fs.chmodSync = chmodFixSync(fs.chmodSync);
   fs.fchmodSync = chmodFixSync(fs.fchmodSync);
   fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+
   fs.stat = statFix(fs.stat);
   fs.fstat = statFix(fs.fstat);
   fs.lstat = statFix(fs.lstat);
+
   fs.statSync = statFixSync(fs.statSync);
   fs.fstatSync = statFixSync(fs.fstatSync);
   fs.lstatSync = statFixSync(fs.lstatSync);
@@ -263,81 +233,94 @@ function patch$1(fs) {
   // CPU to a busy looping process, which can cause the program causing the lock
   // contention to be starved of CPU by node, so the contention doesn't resolve.
   if (platform === "win32") {
-    fs.rename = typeof fs.rename !== 'function' ? fs.rename : function (fs$rename) {
-      function rename(from, to, cb) {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
         var start = Date.now();
         var backoff = 0;
-        fs$rename(from, to, function CB(er) {
-          if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 60000) {
-            setTimeout(function () {
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
               fs.stat(to, function (stater, st) {
-                if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);else cb(er);
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er);
               });
             }, backoff);
-            if (backoff < 100) backoff += 10;
+            if (backoff < 100)
+              backoff += 10;
             return;
           }
           if (cb) cb(er);
         });
       }
       if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-      return rename;
-    }(fs.rename);
+      return rename
+    })(fs.rename);
   }
 
   // if read() returns EAGAIN, then just try it again.
-  fs.read = typeof fs.read !== 'function' ? fs.read : function (fs$read) {
-    function read(fd, buffer, offset, length, position, callback_) {
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
       var callback;
       if (callback_ && typeof callback_ === 'function') {
         var eagCounter = 0;
         callback = function (er, _, __) {
           if (er && er.code === 'EAGAIN' && eagCounter < 10) {
-            eagCounter++;
-            return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+            eagCounter ++;
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
           }
           callback_.apply(this, arguments);
         };
       }
-      return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
     }
 
     // This ensures `util.promisify` works as it does for native `fs.read`.
     if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-    return read;
-  }(fs.read);
-  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync : function (fs$readSync) {
-    return function (fd, buffer, offset, length, position) {
-      var eagCounter = 0;
-      while (true) {
-        try {
-          return fs$readSync.call(fs, fd, buffer, offset, length, position);
-        } catch (er) {
-          if (er.code === 'EAGAIN' && eagCounter < 10) {
-            eagCounter++;
-            continue;
-          }
-          throw er;
+    return read
+  })(fs.read);
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0;
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++;
+          continue
         }
+        throw er
       }
-    };
-  }(fs.readSync);
-  function patchLchmod(fs) {
+    }
+  }})(fs.readSync);
+
+  function patchLchmod (fs) {
     fs.lchmod = function (path, mode, callback) {
-      fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function (err, fd) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
         if (err) {
           if (callback) callback(err);
-          return;
+          return
         }
         // prefer to return the chmod error, if one occurs,
         // but still try to close, and report closing errors if they occur.
         fs.fchmod(fd, mode, function (err) {
-          fs.close(fd, function (err2) {
+          fs.close(fd, function(err2) {
             if (callback) callback(err || err2);
           });
         });
       });
     };
+
     fs.lchmodSync = function (path, mode) {
       var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
 
@@ -357,16 +340,17 @@ function patch$1(fs) {
           fs.closeSync(fd);
         }
       }
-      return ret;
+      return ret
     };
   }
-  function patchLutimes(fs) {
+
+  function patchLutimes (fs) {
     if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
       fs.lutimes = function (path, at, mt, cb) {
         fs.open(path, constants.O_SYMLINK, function (er, fd) {
           if (er) {
             if (cb) cb(er);
-            return;
+            return
           }
           fs.futimes(fd, at, mt, function (er) {
             fs.close(fd, function (er2) {
@@ -375,6 +359,7 @@ function patch$1(fs) {
           });
         });
       };
+
       fs.lutimesSync = function (path, at, mt) {
         var fd = fs.openSync(path, constants.O_SYMLINK);
         var ret;
@@ -391,55 +376,60 @@ function patch$1(fs) {
             fs.closeSync(fd);
           }
         }
-        return ret;
+        return ret
       };
+
     } else if (fs.futimes) {
-      fs.lutimes = function (_a, _b, _c, cb) {
-        if (cb) process.nextTick(cb);
-      };
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
       fs.lutimesSync = function () {};
     }
   }
-  function chmodFix(orig) {
-    if (!orig) return orig;
+
+  function chmodFix (orig) {
+    if (!orig) return orig
     return function (target, mode, cb) {
       return orig.call(fs, target, mode, function (er) {
         if (chownErOk(er)) er = null;
         if (cb) cb.apply(this, arguments);
-      });
-    };
+      })
+    }
   }
-  function chmodFixSync(orig) {
-    if (!orig) return orig;
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
     return function (target, mode) {
       try {
-        return orig.call(fs, target, mode);
+        return orig.call(fs, target, mode)
       } catch (er) {
-        if (!chownErOk(er)) throw er;
+        if (!chownErOk(er)) throw er
       }
-    };
+    }
   }
-  function chownFix(orig) {
-    if (!orig) return orig;
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
     return function (target, uid, gid, cb) {
       return orig.call(fs, target, uid, gid, function (er) {
         if (chownErOk(er)) er = null;
         if (cb) cb.apply(this, arguments);
-      });
-    };
+      })
+    }
   }
-  function chownFixSync(orig) {
-    if (!orig) return orig;
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
     return function (target, uid, gid) {
       try {
-        return orig.call(fs, target, uid, gid);
+        return orig.call(fs, target, uid, gid)
       } catch (er) {
-        if (!chownErOk(er)) throw er;
+        if (!chownErOk(er)) throw er
       }
-    };
+    }
   }
-  function statFix(orig) {
-    if (!orig) return orig;
+
+  function statFix (orig) {
+    if (!orig) return orig
     // Older versions of Node erroneously returned signed integers for
     // uid + gid.
     return function (target, options, cb) {
@@ -447,28 +437,31 @@ function patch$1(fs) {
         cb = options;
         options = null;
       }
-      function callback(er, stats) {
+      function callback (er, stats) {
         if (stats) {
           if (stats.uid < 0) stats.uid += 0x100000000;
           if (stats.gid < 0) stats.gid += 0x100000000;
         }
         if (cb) cb.apply(this, arguments);
       }
-      return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
-    };
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
   }
-  function statFixSync(orig) {
-    if (!orig) return orig;
+
+  function statFixSync (orig) {
+    if (!orig) return orig
     // Older versions of Node erroneously returned signed integers for
     // uid + gid.
     return function (target, options) {
-      var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target);
       if (stats) {
         if (stats.uid < 0) stats.uid += 0x100000000;
         if (stats.gid < 0) stats.gid += 0x100000000;
       }
       return stats;
-    };
+    }
   }
 
   // ENOSYS means that the fs doesn't support the op. Just ignore
@@ -483,35 +476,49 @@ function patch$1(fs) {
   //
   // When running as root, or if other types of errors are
   // encountered, then it's strict.
-  function chownErOk(er) {
-    if (!er) return true;
-    if (er.code === "ENOSYS") return true;
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
     var nonroot = !process.getuid || process.getuid() !== 0;
     if (nonroot) {
-      if (er.code === "EINVAL" || er.code === "EPERM") return true;
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
     }
-    return false;
+
+    return false
   }
 }
 
-var Stream = require$$0__default$1["default"].Stream;
+var Stream = require$$0$1.Stream;
+
 var legacyStreams = legacy$1;
-function legacy$1(fs) {
+
+function legacy$1 (fs) {
   return {
     ReadStream: ReadStream,
     WriteStream: WriteStream
-  };
-  function ReadStream(path, options) {
+  }
+
+  function ReadStream (path, options) {
     if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
     Stream.call(this);
+
     var self = this;
+
     this.path = path;
     this.fd = null;
     this.readable = true;
     this.paused = false;
+
     this.flags = 'r';
     this.mode = 438; /*=0666*/
     this.bufferSize = 64 * 1024;
+
     options = options || {};
 
     // Mixin options into this
@@ -520,7 +527,9 @@ function legacy$1(fs) {
       var key = keys[index];
       this[key] = options[key];
     }
+
     if (this.encoding) this.setEncoding(this.encoding);
+
     if (this.start !== undefined) {
       if ('number' !== typeof this.start) {
         throw TypeError('start must be a Number');
@@ -530,38 +539,48 @@ function legacy$1(fs) {
       } else if ('number' !== typeof this.end) {
         throw TypeError('end must be a Number');
       }
+
       if (this.start > this.end) {
         throw new Error('start must be <= end');
       }
+
       this.pos = this.start;
     }
+
     if (this.fd !== null) {
-      process.nextTick(function () {
+      process.nextTick(function() {
         self._read();
       });
       return;
     }
+
     fs.open(this.path, this.flags, this.mode, function (err, fd) {
       if (err) {
         self.emit('error', err);
         self.readable = false;
         return;
       }
+
       self.fd = fd;
       self.emit('open', fd);
       self._read();
     });
   }
-  function WriteStream(path, options) {
+
+  function WriteStream (path, options) {
     if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
     Stream.call(this);
+
     this.path = path;
     this.fd = null;
     this.writable = true;
+
     this.flags = 'w';
     this.encoding = 'binary';
     this.mode = 438; /*=0666*/
     this.bytesWritten = 0;
+
     options = options || {};
 
     // Mixin options into this
@@ -570,6 +589,7 @@ function legacy$1(fs) {
       var key = keys[index];
       this[key] = options[key];
     }
+
     if (this.start !== undefined) {
       if ('number' !== typeof this.start) {
         throw TypeError('start must be a Number');
@@ -577,10 +597,13 @@ function legacy$1(fs) {
       if (this.start < 0) {
         throw new Error('start must be >= zero');
       }
+
       this.pos = this.start;
     }
+
     this.busy = false;
     this._queue = [];
+
     if (this.fd === null) {
       this._open = fs.open;
       this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
@@ -590,25 +613,33 @@ function legacy$1(fs) {
 }
 
 var clone_1 = clone$2;
+
 var getPrototypeOf = Object.getPrototypeOf || function (obj) {
-  return obj.__proto__;
+  return obj.__proto__
 };
-function clone$2(obj) {
-  if (obj === null || typeof obj !== 'object') return obj;
-  if (obj instanceof Object) var copy = {
-    __proto__: getPrototypeOf(obj)
-  };else var copy = Object.create(null);
+
+function clone$2 (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
+
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) };
+  else
+    var copy = Object.create(null);
+
   Object.getOwnPropertyNames(obj).forEach(function (key) {
     Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
   });
-  return copy;
+
+  return copy
 }
 
-var fs$g = require$$0__default$2["default"];
+var fs$g = require$$0$2;
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone$1 = clone_1;
-var util$1 = require$$4__default["default"];
+
+var util$1 = require$$4;
 
 /* istanbul ignore next - node 0.x polyfill */
 var gracefulQueue;
@@ -623,20 +654,26 @@ if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
   gracefulQueue = '___graceful-fs.queue';
   previousSymbol = '___graceful-fs.previous';
 }
-function noop() {}
+
+function noop () {}
+
 function publishQueue(context, queue) {
   Object.defineProperty(context, gracefulQueue, {
-    get: function () {
-      return queue;
+    get: function() {
+      return queue
     }
   });
 }
+
 var debug = noop;
-if (util$1.debuglog) debug = util$1.debuglog('gfs4');else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) debug = function () {
-  var m = util$1.format.apply(util$1, arguments);
-  m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
-  console.error(m);
-};
+if (util$1.debuglog)
+  debug = util$1.debuglog('gfs4');
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util$1.format.apply(util$1, arguments);
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
+    console.error(m);
+  };
 
 // Once time initialization
 if (!fs$g[gracefulQueue]) {
@@ -648,146 +685,209 @@ if (!fs$g[gracefulQueue]) {
   // 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$g.close = function (fs$close) {
-    function close(fd, cb) {
+  fs$g.close = (function (fs$close) {
+    function close (fd, cb) {
       return fs$close.call(fs$g, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
         }
-        if (typeof cb === 'function') cb.apply(this, arguments);
-      });
+
+        if (typeof cb === 'function')
+          cb.apply(this, arguments);
+      })
     }
+
     Object.defineProperty(close, previousSymbol, {
       value: fs$close
     });
-    return close;
-  }(fs$g.close);
-  fs$g.closeSync = function (fs$closeSync) {
-    function closeSync(fd) {
+    return close
+  })(fs$g.close);
+
+  fs$g.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
       // This function uses the graceful-fs shared queue
       fs$closeSync.apply(fs$g, arguments);
       resetQueue();
     }
+
     Object.defineProperty(closeSync, previousSymbol, {
       value: fs$closeSync
     });
-    return closeSync;
-  }(fs$g.closeSync);
+    return closeSync
+  })(fs$g.closeSync);
+
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-    process.on('exit', function () {
+    process.on('exit', function() {
       debug(fs$g[gracefulQueue]);
-      require$$5__default["default"].equal(fs$g[gracefulQueue].length, 0);
+      require$$5.equal(fs$g[gracefulQueue].length, 0);
     });
   }
 }
+
 if (!commonjsGlobal[gracefulQueue]) {
   publishQueue(commonjsGlobal, fs$g[gracefulQueue]);
 }
+
 var gracefulFs = patch(clone$1(fs$g));
 if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$g.__patched) {
-  gracefulFs = patch(fs$g);
-  fs$g.__patched = true;
+    gracefulFs = patch(fs$g);
+    fs$g.__patched = true;
 }
-function patch(fs) {
+
+function patch (fs) {
   // Everything that references the open() function needs to be in here
   polyfills(fs);
   fs.gracefulify = patch;
+
   fs.createReadStream = createReadStream;
   fs.createWriteStream = createWriteStream;
   var fs$readFile = fs.readFile;
   fs.readFile = readFile;
-  function readFile(path, options, cb) {
-    if (typeof options === 'function') cb = options, options = null;
-    return go$readFile(path, options, cb);
-    function go$readFile(path, options, cb, startTime) {
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$readFile(path, options, cb)
+
+    function go$readFile (path, options, cb, startTime) {
       return fs$readFile(path, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (typeof cb === 'function') cb.apply(this, arguments);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
         }
-      });
+      })
     }
   }
+
   var fs$writeFile = fs.writeFile;
   fs.writeFile = writeFile;
-  function writeFile(path, data, options, cb) {
-    if (typeof options === 'function') cb = options, options = null;
-    return go$writeFile(path, data, options, cb);
-    function go$writeFile(path, data, options, cb, startTime) {
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$writeFile(path, data, options, cb)
+
+    function go$writeFile (path, data, options, cb, startTime) {
       return fs$writeFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (typeof cb === 'function') cb.apply(this, arguments);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
         }
-      });
+      })
     }
   }
+
   var fs$appendFile = fs.appendFile;
-  if (fs$appendFile) fs.appendFile = appendFile;
-  function appendFile(path, data, options, cb) {
-    if (typeof options === 'function') cb = options, options = null;
-    return go$appendFile(path, data, options, cb);
-    function go$appendFile(path, data, options, cb, startTime) {
+  if (fs$appendFile)
+    fs.appendFile = appendFile;
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$appendFile(path, data, options, cb)
+
+    function go$appendFile (path, data, options, cb, startTime) {
       return fs$appendFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (typeof cb === 'function') cb.apply(this, arguments);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
         }
-      });
+      })
     }
   }
+
   var fs$copyFile = fs.copyFile;
-  if (fs$copyFile) fs.copyFile = copyFile;
-  function copyFile(src, dest, flags, cb) {
+  if (fs$copyFile)
+    fs.copyFile = copyFile;
+  function copyFile (src, dest, flags, cb) {
     if (typeof flags === 'function') {
       cb = flags;
       flags = 0;
     }
-    return go$copyFile(src, dest, flags, cb);
-    function go$copyFile(src, dest, flags, cb, startTime) {
+    return go$copyFile(src, dest, flags, cb)
+
+    function go$copyFile (src, dest, flags, cb, startTime) {
       return fs$copyFile(src, dest, flags, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (typeof cb === 'function') cb.apply(this, arguments);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
         }
-      });
+      })
     }
   }
+
   var fs$readdir = fs.readdir;
   fs.readdir = readdir;
   var noReaddirOptionVersions = /^v[0-5]\./;
-  function readdir(path, options, cb) {
-    if (typeof options === 'function') cb = options, options = null;
-    var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
-      return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
-    } : function go$readdir(path, options, cb, startTime) {
-      return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
-    };
-    return go$readdir(path, options, cb);
-    function fs$readdirCallback(path, options, cb, startTime) {
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      };
+
+    return go$readdir(path, options, cb)
+
+    function fs$readdirCallback (path, options, cb, startTime) {
       return function (err, files) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (files && files.sort) files.sort();
-          if (typeof cb === 'function') cb.call(this, err, files);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ]);
+        else {
+          if (files && files.sort)
+            files.sort();
+
+          if (typeof cb === 'function')
+            cb.call(this, err, files);
         }
-      };
+      }
     }
   }
+
   if (process.version.substr(0, 4) === 'v0.8') {
     var legStreams = legacy(fs);
     ReadStream = legStreams.ReadStream;
     WriteStream = legStreams.WriteStream;
   }
+
   var fs$ReadStream = fs.ReadStream;
   if (fs$ReadStream) {
     ReadStream.prototype = Object.create(fs$ReadStream.prototype);
     ReadStream.prototype.open = ReadStream$open;
   }
+
   var fs$WriteStream = fs.WriteStream;
   if (fs$WriteStream) {
     WriteStream.prototype = Object.create(fs$WriteStream.prototype);
     WriteStream.prototype.open = WriteStream$open;
   }
+
   Object.defineProperty(fs, 'ReadStream', {
     get: function () {
-      return ReadStream;
+      return ReadStream
     },
     set: function (val) {
       ReadStream = val;
@@ -797,7 +897,7 @@ function patch(fs) {
   });
   Object.defineProperty(fs, 'WriteStream', {
     get: function () {
-      return WriteStream;
+      return WriteStream
     },
     set: function (val) {
       WriteStream = val;
@@ -810,7 +910,7 @@ function patch(fs) {
   var FileReadStream = ReadStream;
   Object.defineProperty(fs, 'FileReadStream', {
     get: function () {
-      return FileReadStream;
+      return FileReadStream
     },
     set: function (val) {
       FileReadStream = val;
@@ -821,7 +921,7 @@ function patch(fs) {
   var FileWriteStream = WriteStream;
   Object.defineProperty(fs, 'FileWriteStream', {
     get: function () {
-      return FileWriteStream;
+      return FileWriteStream
     },
     set: function (val) {
       FileWriteStream = val;
@@ -829,14 +929,21 @@ function patch(fs) {
     enumerable: true,
     configurable: true
   });
-  function ReadStream(path, options) {
-    if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
   }
-  function ReadStream$open() {
+
+  function ReadStream$open () {
     var that = this;
     open(that.path, that.flags, that.mode, function (err, fd) {
       if (err) {
-        if (that.autoClose) that.destroy();
+        if (that.autoClose)
+          that.destroy();
+
         that.emit('error', err);
       } else {
         that.fd = fd;
@@ -845,10 +952,15 @@ function patch(fs) {
       }
     });
   }
-  function WriteStream(path, options) {
-    if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
   }
-  function WriteStream$open() {
+
+  function WriteStream$open () {
     var that = this;
     open(that.path, that.flags, that.mode, function (err, fd) {
       if (err) {
@@ -860,28 +972,39 @@ function patch(fs) {
       }
     });
   }
-  function createReadStream(path, options) {
-    return new fs.ReadStream(path, options);
+
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
   }
-  function createWriteStream(path, options) {
-    return new fs.WriteStream(path, options);
+
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
   }
+
   var fs$open = fs.open;
   fs.open = open;
-  function open(path, flags, mode, cb) {
-    if (typeof mode === 'function') cb = mode, mode = null;
-    return go$open(path, flags, mode, cb);
-    function go$open(path, flags, mode, cb, startTime) {
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null;
+
+    return go$open(path, flags, mode, cb)
+
+    function go$open (path, flags, mode, cb, startTime) {
       return fs$open(path, flags, mode, function (err, fd) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);else {
-          if (typeof cb === 'function') cb.apply(this, arguments);
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
         }
-      });
+      })
     }
   }
-  return fs;
+
+  return fs
 }
-function enqueue(elem) {
+
+function enqueue (elem) {
   debug('ENQUEUE', elem[0].name, elem[1]);
   fs$g[gracefulQueue].push(elem);
   retry();
@@ -893,7 +1016,7 @@ var retryTimer;
 // reset the startTime and lastTime to now
 // this resets the start of the 60 second overall timeout as well as the
 // delay between attempts so that we'll retry these jobs sooner
-function resetQueue() {
+function resetQueue () {
   var now = Date.now();
   for (var i = 0; i < fs$g[gracefulQueue].length; ++i) {
     // entries that are only a length of 2 are from an older version, don't
@@ -906,11 +1029,15 @@ function resetQueue() {
   // call retry to make sure we're actively processing the queue
   retry();
 }
-function retry() {
+
+function retry () {
   // clear the timer and remove it to help prevent unintended concurrency
   clearTimeout(retryTimer);
   retryTimer = undefined;
-  if (fs$g[gracefulQueue].length === 0) return;
+
+  if (fs$g[gracefulQueue].length === 0)
+    return
+
   var elem = fs$g[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
@@ -928,7 +1055,8 @@ function retry() {
     // it's been more than 60 seconds total, bail now
     debug('TIMEOUT', fn.name, args);
     var cb = args.pop();
-    if (typeof cb === 'function') cb.call(null, err);
+    if (typeof cb === 'function')
+      cb.call(null, err);
   } else {
     // the amount of time between the last attempt and right now
     var sinceAttempt = Date.now() - lastTime;
@@ -956,172 +1084,198 @@ function retry() {
 }
 
 (function (exports) {
-
-  // This is adapted from https://github.com/normalize/mz
-  // Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
-  const u = universalify$1.fromCallback;
-  const fs = gracefulFs;
-  const api = ['access', 'appendFile', 'chmod', 'chown', 'close', 'copyFile', 'fchmod', 'fchown', 'fdatasync', 'fstat', 'fsync', 'ftruncate', 'futimes', 'lchmod', 'lchown', 'link', 'lstat', 'mkdir', 'mkdtemp', 'open', 'opendir', 'readdir', 'readFile', 'readlink', 'realpath', 'rename', 'rm', 'rmdir', 'stat', 'symlink', 'truncate', 'unlink', 'utimes', 'writeFile'].filter(key => {
-    // Some commands are not available on some systems. Ex:
-    // fs.cp was added in Node.js v16.7.0
-    // fs.lchown is not available on at least some Linux
-    return typeof fs[key] === 'function';
-  });
-
-  // Export cloned fs:
-  Object.assign(exports, fs);
-
-  // Universalify async methods:
-  api.forEach(method => {
-    exports[method] = u(fs[method]);
-  });
-
-  // We differ from mz/fs in that we still ship the old, broken, fs.exists()
-  // since we are a drop-in replacement for the native module
-  exports.exists = function (filename, callback) {
-    if (typeof callback === 'function') {
-      return fs.exists(filename, callback);
-    }
-    return new Promise(resolve => {
-      return fs.exists(filename, resolve);
-    });
-  };
-
-  // fs.read(), fs.write(), fs.readv(), & fs.writev() need special treatment due to multiple callback args
-
-  exports.read = function (fd, buffer, offset, length, position, callback) {
-    if (typeof callback === 'function') {
-      return fs.read(fd, buffer, offset, length, position, callback);
-    }
-    return new Promise((resolve, reject) => {
-      fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
-        if (err) return reject(err);
-        resolve({
-          bytesRead,
-          buffer
-        });
-      });
-    });
-  };
-
-  // Function signature can be
-  // fs.write(fd, buffer[, offset[, length[, position]]], callback)
-  // OR
-  // fs.write(fd, string[, position[, encoding]], callback)
-  // We need to handle both cases, so we use ...args
-  exports.write = function (fd, buffer, ...args) {
-    if (typeof args[args.length - 1] === 'function') {
-      return fs.write(fd, buffer, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
-        if (err) return reject(err);
-        resolve({
-          bytesWritten,
-          buffer
-        });
-      });
-    });
-  };
-
-  // Function signature is
-  // s.readv(fd, buffers[, position], callback)
-  // We need to handle the optional arg, so we use ...args
-  exports.readv = function (fd, buffers, ...args) {
-    if (typeof args[args.length - 1] === 'function') {
-      return fs.readv(fd, buffers, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
-        if (err) return reject(err);
-        resolve({
-          bytesRead,
-          buffers
-        });
-      });
-    });
-  };
-
-  // Function signature is
-  // s.writev(fd, buffers[, position], callback)
-  // We need to handle the optional arg, so we use ...args
-  exports.writev = function (fd, buffers, ...args) {
-    if (typeof args[args.length - 1] === 'function') {
-      return fs.writev(fd, buffers, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
-        if (err) return reject(err);
-        resolve({
-          bytesWritten,
-          buffers
-        });
-      });
-    });
-  };
-
-  // fs.realpath.native sometimes not available if fs is monkey-patched
-  if (typeof fs.realpath.native === 'function') {
-    exports.realpath.native = u(fs.realpath.native);
-  } else {
-    process.emitWarning('fs.realpath.native is not a function. Is fs being monkey-patched?', 'Warning', 'fs-extra-WARN0003');
-  }
-})(fs$h);
+	// This is adapted from https://github.com/normalize/mz
+	// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
+	const u = universalify$1.fromCallback;
+	const fs = gracefulFs;
+
+	const api = [
+	  'access',
+	  'appendFile',
+	  'chmod',
+	  'chown',
+	  'close',
+	  'copyFile',
+	  'fchmod',
+	  'fchown',
+	  'fdatasync',
+	  'fstat',
+	  'fsync',
+	  'ftruncate',
+	  'futimes',
+	  'lchmod',
+	  'lchown',
+	  'link',
+	  'lstat',
+	  'mkdir',
+	  'mkdtemp',
+	  'open',
+	  'opendir',
+	  'readdir',
+	  'readFile',
+	  'readlink',
+	  'realpath',
+	  'rename',
+	  'rm',
+	  'rmdir',
+	  'stat',
+	  'symlink',
+	  'truncate',
+	  'unlink',
+	  'utimes',
+	  'writeFile'
+	].filter(key => {
+	  // Some commands are not available on some systems. Ex:
+	  // fs.cp was added in Node.js v16.7.0
+	  // fs.lchown is not available on at least some Linux
+	  return typeof fs[key] === 'function'
+	});
+
+	// Export cloned fs:
+	Object.assign(exports, fs);
+
+	// Universalify async methods:
+	api.forEach(method => {
+	  exports[method] = u(fs[method]);
+	});
+
+	// We differ from mz/fs in that we still ship the old, broken, fs.exists()
+	// since we are a drop-in replacement for the native module
+	exports.exists = function (filename, callback) {
+	  if (typeof callback === 'function') {
+	    return fs.exists(filename, callback)
+	  }
+	  return new Promise(resolve => {
+	    return fs.exists(filename, resolve)
+	  })
+	};
+
+	// fs.read(), fs.write(), fs.readv(), & fs.writev() need special treatment due to multiple callback args
+
+	exports.read = function (fd, buffer, offset, length, position, callback) {
+	  if (typeof callback === 'function') {
+	    return fs.read(fd, buffer, offset, length, position, callback)
+	  }
+	  return new Promise((resolve, reject) => {
+	    fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
+	      if (err) return reject(err)
+	      resolve({ bytesRead, buffer });
+	    });
+	  })
+	};
+
+	// Function signature can be
+	// fs.write(fd, buffer[, offset[, length[, position]]], callback)
+	// OR
+	// fs.write(fd, string[, position[, encoding]], callback)
+	// We need to handle both cases, so we use ...args
+	exports.write = function (fd, buffer, ...args) {
+	  if (typeof args[args.length - 1] === 'function') {
+	    return fs.write(fd, buffer, ...args)
+	  }
+
+	  return new Promise((resolve, reject) => {
+	    fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
+	      if (err) return reject(err)
+	      resolve({ bytesWritten, buffer });
+	    });
+	  })
+	};
+
+	// Function signature is
+	// s.readv(fd, buffers[, position], callback)
+	// We need to handle the optional arg, so we use ...args
+	exports.readv = function (fd, buffers, ...args) {
+	  if (typeof args[args.length - 1] === 'function') {
+	    return fs.readv(fd, buffers, ...args)
+	  }
+
+	  return new Promise((resolve, reject) => {
+	    fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
+	      if (err) return reject(err)
+	      resolve({ bytesRead, buffers });
+	    });
+	  })
+	};
+
+	// Function signature is
+	// s.writev(fd, buffers[, position], callback)
+	// We need to handle the optional arg, so we use ...args
+	exports.writev = function (fd, buffers, ...args) {
+	  if (typeof args[args.length - 1] === 'function') {
+	    return fs.writev(fd, buffers, ...args)
+	  }
+
+	  return new Promise((resolve, reject) => {
+	    fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
+	      if (err) return reject(err)
+	      resolve({ bytesWritten, buffers });
+	    });
+	  })
+	};
+
+	// fs.realpath.native sometimes not available if fs is monkey-patched
+	if (typeof fs.realpath.native === 'function') {
+	  exports.realpath.native = u(fs.realpath.native);
+	} else {
+	  process.emitWarning(
+	    'fs.realpath.native is not a function. Is fs being monkey-patched?',
+	    'Warning', 'fs-extra-WARN0003'
+	  );
+	}
+} (fs$h));
 
 var makeDir$1 = {};
 
 var utils$1 = {};
 
-const path$b = require$$1__default["default"];
+const path$b = require$$1;
 
 // https://github.com/nodejs/node/issues/8987
 // https://github.com/libuv/libuv/pull/1088
-utils$1.checkPath = function checkPath(pth) {
+utils$1.checkPath = function checkPath (pth) {
   if (process.platform === 'win32') {
     const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path$b.parse(pth).root, ''));
+
     if (pathHasInvalidWinCharacters) {
       const error = new Error(`Path contains invalid characters: ${pth}`);
       error.code = 'EINVAL';
-      throw error;
+      throw error
     }
   }
 };
 
 const fs$f = fs$h;
-const {
-  checkPath
-} = utils$1;
+const { checkPath } = utils$1;
+
 const getMode = options => {
-  const defaults = {
-    mode: 0o777
-  };
-  if (typeof options === 'number') return options;
-  return {
-    ...defaults,
-    ...options
-  }.mode;
+  const defaults = { mode: 0o777 };
+  if (typeof options === 'number') return options
+  return ({ ...defaults, ...options }).mode
 };
+
 makeDir$1.makeDir = async (dir, options) => {
   checkPath(dir);
+
   return fs$f.mkdir(dir, {
     mode: getMode(options),
     recursive: true
-  });
+  })
 };
+
 makeDir$1.makeDirSync = (dir, options) => {
   checkPath(dir);
+
   return fs$f.mkdirSync(dir, {
     mode: getMode(options),
     recursive: true
-  });
+  })
 };
 
 const u$a = universalify$1.fromPromise;
-const {
-  makeDir: _makeDir,
-  makeDirSync
-} = makeDir$1;
+const { makeDir: _makeDir, makeDirSync } = makeDir$1;
 const makeDir = u$a(_makeDir);
+
 var mkdirs$2 = {
   mkdirs: makeDir,
   mkdirsSync: makeDirSync,
@@ -1134,19 +1288,22 @@ var mkdirs$2 = {
 
 const u$9 = universalify$1.fromPromise;
 const fs$e = fs$h;
-function pathExists$6(path) {
-  return fs$e.access(path).then(() => true).catch(() => false);
+
+function pathExists$6 (path) {
+  return fs$e.access(path).then(() => true).catch(() => false)
 }
+
 var pathExists_1 = {
   pathExists: u$9(pathExists$6),
   pathExistsSync: fs$e.existsSync
 };
 
 const fs$d = gracefulFs;
-function utimesMillis$1(path, atime, mtime, callback) {
+
+function utimesMillis$1 (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
   fs$d.open(path, 'r+', (err, fd) => {
-    if (err) return callback(err);
+    if (err) return callback(err)
     fs$d.futimes(fd, atime, mtime, futimesErr => {
       fs$d.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
@@ -1154,178 +1311,162 @@ function utimesMillis$1(path, atime, mtime, callback) {
     });
   });
 }
-function utimesMillisSync$1(path, atime, mtime) {
+
+function utimesMillisSync$1 (path, atime, mtime) {
   const fd = fs$d.openSync(path, 'r+');
   fs$d.futimesSync(fd, atime, mtime);
-  return fs$d.closeSync(fd);
+  return fs$d.closeSync(fd)
 }
+
 var utimes = {
   utimesMillis: utimesMillis$1,
   utimesMillisSync: utimesMillisSync$1
 };
 
 const fs$c = fs$h;
-const path$a = require$$1__default["default"];
-const util = require$$4__default["default"];
-function getStats$2(src, dest, opts) {
-  const statFunc = opts.dereference ? file => fs$c.stat(file, {
-    bigint: true
-  }) : file => fs$c.lstat(file, {
-    bigint: true
-  });
-  return Promise.all([statFunc(src), statFunc(dest).catch(err => {
-    if (err.code === 'ENOENT') return null;
-    throw err;
-  })]).then(([srcStat, destStat]) => ({
-    srcStat,
-    destStat
-  }));
-}
-function getStatsSync(src, dest, opts) {
+const path$a = require$$1;
+const util = require$$4;
+
+function getStats$2 (src, dest, opts) {
+  const statFunc = opts.dereference
+    ? (file) => fs$c.stat(file, { bigint: true })
+    : (file) => fs$c.lstat(file, { bigint: true });
+  return Promise.all([
+    statFunc(src),
+    statFunc(dest).catch(err => {
+      if (err.code === 'ENOENT') return null
+      throw err
+    })
+  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
+}
+
+function getStatsSync (src, dest, opts) {
   let destStat;
-  const statFunc = opts.dereference ? file => fs$c.statSync(file, {
-    bigint: true
-  }) : file => fs$c.lstatSync(file, {
-    bigint: true
-  });
+  const statFunc = opts.dereference
+    ? (file) => fs$c.statSync(file, { bigint: true })
+    : (file) => fs$c.lstatSync(file, { bigint: true });
   const srcStat = statFunc(src);
   try {
     destStat = statFunc(dest);
   } catch (err) {
-    if (err.code === 'ENOENT') return {
-      srcStat,
-      destStat: null
-    };
-    throw err;
+    if (err.code === 'ENOENT') return { srcStat, destStat: null }
+    throw err
   }
-  return {
-    srcStat,
-    destStat
-  };
+  return { srcStat, destStat }
 }
-function checkPaths(src, dest, funcName, opts, cb) {
+
+function checkPaths (src, dest, funcName, opts, cb) {
   util.callbackify(getStats$2)(src, dest, opts, (err, stats) => {
-    if (err) return cb(err);
-    const {
-      srcStat,
-      destStat
-    } = stats;
+    if (err) return cb(err)
+    const { srcStat, destStat } = stats;
+
     if (destStat) {
       if (areIdentical$2(srcStat, destStat)) {
         const srcBaseName = path$a.basename(src);
         const destBaseName = path$a.basename(dest);
-        if (funcName === 'move' && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-          return cb(null, {
-            srcStat,
-            destStat,
-            isChangingCase: true
-          });
+        if (funcName === 'move' &&
+          srcBaseName !== destBaseName &&
+          srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+          return cb(null, { srcStat, destStat, isChangingCase: true })
         }
-        return cb(new Error('Source and destination must not be the same.'));
+        return cb(new Error('Source and destination must not be the same.'))
       }
       if (srcStat.isDirectory() && !destStat.isDirectory()) {
-        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
+        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
       }
       if (!srcStat.isDirectory() && destStat.isDirectory()) {
-        return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`));
+        return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`))
       }
     }
+
     if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-      return cb(new Error(errMsg(src, dest, funcName)));
+      return cb(new Error(errMsg(src, dest, funcName)))
     }
-    return cb(null, {
-      srcStat,
-      destStat
-    });
+    return cb(null, { srcStat, destStat })
   });
 }
-function checkPathsSync(src, dest, funcName, opts) {
-  const {
-    srcStat,
-    destStat
-  } = getStatsSync(src, dest, opts);
+
+function checkPathsSync (src, dest, funcName, opts) {
+  const { srcStat, destStat } = getStatsSync(src, dest, opts);
+
   if (destStat) {
     if (areIdentical$2(srcStat, destStat)) {
       const srcBaseName = path$a.basename(src);
       const destBaseName = path$a.basename(dest);
-      if (funcName === 'move' && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-        return {
-          srcStat,
-          destStat,
-          isChangingCase: true
-        };
+      if (funcName === 'move' &&
+        srcBaseName !== destBaseName &&
+        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true }
       }
-      throw new Error('Source and destination must not be the same.');
+      throw new Error('Source and destination must not be the same.')
     }
     if (srcStat.isDirectory() && !destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
     }
     if (!srcStat.isDirectory() && destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
     }
   }
+
   if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-    throw new Error(errMsg(src, dest, funcName));
+    throw new Error(errMsg(src, dest, funcName))
   }
-  return {
-    srcStat,
-    destStat
-  };
+  return { srcStat, destStat }
 }
 
 // recursively check if dest parent is a subdirectory of src.
 // It works for all file types including symlinks since it
 // checks the src and dest inodes. It starts from the deepest
 // parent and stops once it reaches the src parent or the root path.
-function checkParentPaths(src, srcStat, dest, funcName, cb) {
+function checkParentPaths (src, srcStat, dest, funcName, cb) {
   const srcParent = path$a.resolve(path$a.dirname(src));
   const destParent = path$a.resolve(path$a.dirname(dest));
-  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return cb();
-  fs$c.stat(destParent, {
-    bigint: true
-  }, (err, destStat) => {
+  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return cb()
+  fs$c.stat(destParent, { bigint: true }, (err, destStat) => {
     if (err) {
-      if (err.code === 'ENOENT') return cb();
-      return cb(err);
+      if (err.code === 'ENOENT') return cb()
+      return cb(err)
     }
     if (areIdentical$2(srcStat, destStat)) {
-      return cb(new Error(errMsg(src, dest, funcName)));
+      return cb(new Error(errMsg(src, dest, funcName)))
     }
-    return checkParentPaths(src, srcStat, destParent, funcName, cb);
+    return checkParentPaths(src, srcStat, destParent, funcName, cb)
   });
 }
-function checkParentPathsSync(src, srcStat, dest, funcName) {
+
+function checkParentPathsSync (src, srcStat, dest, funcName) {
   const srcParent = path$a.resolve(path$a.dirname(src));
   const destParent = path$a.resolve(path$a.dirname(dest));
-  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return;
+  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return
   let destStat;
   try {
-    destStat = fs$c.statSync(destParent, {
-      bigint: true
-    });
+    destStat = fs$c.statSync(destParent, { bigint: true });
   } catch (err) {
-    if (err.code === 'ENOENT') return;
-    throw err;
+    if (err.code === 'ENOENT') return
+    throw err
   }
   if (areIdentical$2(srcStat, destStat)) {
-    throw new Error(errMsg(src, dest, funcName));
+    throw new Error(errMsg(src, dest, funcName))
   }
-  return checkParentPathsSync(src, srcStat, destParent, funcName);
+  return checkParentPathsSync(src, srcStat, destParent, funcName)
 }
-function areIdentical$2(srcStat, destStat) {
-  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+
+function areIdentical$2 (srcStat, destStat) {
+  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
 }
 
 // return true if dest is a subdir of src, otherwise false.
 // It only checks the path strings.
-function isSrcSubdir(src, dest) {
+function isSrcSubdir (src, dest) {
   const srcArr = path$a.resolve(src).split(path$a.sep).filter(i => i);
   const destArr = path$a.resolve(dest).split(path$a.sep).filter(i => i);
-  return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
+  return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)
 }
-function errMsg(src, dest, funcName) {
-  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+
+function errMsg (src, dest, funcName) {
+  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
 }
+
 var stat$4 = {
   checkPaths,
   checkPathsSync,
@@ -1336,313 +1477,367 @@ var stat$4 = {
 };
 
 const fs$b = gracefulFs;
-const path$9 = require$$1__default["default"];
+const path$9 = require$$1;
 const mkdirs$1 = mkdirs$2.mkdirs;
 const pathExists$5 = pathExists_1.pathExists;
 const utimesMillis = utimes.utimesMillis;
 const stat$3 = stat$4;
-function copy$2(src, dest, opts, cb) {
+
+function copy$2 (src, dest, opts, cb) {
   if (typeof opts === 'function' && !cb) {
     cb = opts;
     opts = {};
   } else if (typeof opts === 'function') {
-    opts = {
-      filter: opts
-    };
+    opts = { filter: opts };
   }
+
   cb = cb || function () {};
   opts = opts || {};
+
   opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
   opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
 
   // Warn about using preserveTimestamps on 32-bit node
   if (opts.preserveTimestamps && process.arch === 'ia32') {
-    process.emitWarning('Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' + '\tsee https://github.com/jprichardson/node-fs-extra/issues/269', 'Warning', 'fs-extra-WARN0001');
+    process.emitWarning(
+      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+      'Warning', 'fs-extra-WARN0001'
+    );
   }
+
   stat$3.checkPaths(src, dest, 'copy', opts, (err, stats) => {
-    if (err) return cb(err);
-    const {
-      srcStat,
-      destStat
-    } = stats;
+    if (err) return cb(err)
+    const { srcStat, destStat } = stats;
     stat$3.checkParentPaths(src, srcStat, dest, 'copy', err => {
-      if (err) return cb(err);
+      if (err) return cb(err)
       runFilter(src, dest, opts, (err, include) => {
-        if (err) return cb(err);
-        if (!include) return cb();
+        if (err) return cb(err)
+        if (!include) return cb()
+
         checkParentDir(destStat, src, dest, opts, cb);
       });
     });
   });
 }
-function checkParentDir(destStat, src, dest, opts, cb) {
+
+function checkParentDir (destStat, src, dest, opts, cb) {
   const destParent = path$9.dirname(dest);
   pathExists$5(destParent, (err, dirExists) => {
-    if (err) return cb(err);
-    if (dirExists) return getStats$1(destStat, src, dest, opts, cb);
+    if (err) return cb(err)
+    if (dirExists) return getStats$1(destStat, src, dest, opts, cb)
     mkdirs$1(destParent, err => {
-      if (err) return cb(err);
-      return getStats$1(destStat, src, dest, opts, cb);
+      if (err) return cb(err)
+      return getStats$1(destStat, src, dest, opts, cb)
     });
   });
 }
-function runFilter(src, dest, opts, cb) {
-  if (!opts.filter) return cb(null, true);
-  Promise.resolve(opts.filter(src, dest)).then(include => cb(null, include), error => cb(error));
+
+function runFilter (src, dest, opts, cb) {
+  if (!opts.filter) return cb(null, true)
+  Promise.resolve(opts.filter(src, dest))
+    .then(include => cb(null, include), error => cb(error));
 }
-function getStats$1(destStat, src, dest, opts, cb) {
+
+function getStats$1 (destStat, src, dest, opts, cb) {
   const stat = opts.dereference ? fs$b.stat : fs$b.lstat;
   stat(src, (err, srcStat) => {
-    if (err) return cb(err);
-    if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts, cb);else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts, cb);else if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts, cb);else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`));else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`));
-    return cb(new Error(`Unknown file: ${src}`));
+    if (err) return cb(err)
+
+    if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts, cb)
+    else if (srcStat.isFile() ||
+             srcStat.isCharacterDevice() ||
+             srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts, cb)
+    else if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts, cb)
+    else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))
+    else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))
+    return cb(new Error(`Unknown file: ${src}`))
   });
 }
-function onFile$1(srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return copyFile$1(srcStat, src, dest, opts, cb);
-  return mayCopyFile$1(srcStat, src, dest, opts, cb);
+
+function onFile$1 (srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return copyFile$1(srcStat, src, dest, opts, cb)
+  return mayCopyFile$1(srcStat, src, dest, opts, cb)
 }
-function mayCopyFile$1(srcStat, src, dest, opts, cb) {
+
+function mayCopyFile$1 (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
     fs$b.unlink(dest, err => {
-      if (err) return cb(err);
-      return copyFile$1(srcStat, src, dest, opts, cb);
+      if (err) return cb(err)
+      return copyFile$1(srcStat, src, dest, opts, cb)
     });
   } else if (opts.errorOnExist) {
-    return cb(new Error(`'${dest}' already exists`));
-  } else return cb();
+    return cb(new Error(`'${dest}' already exists`))
+  } else return cb()
 }
-function copyFile$1(srcStat, src, dest, opts, cb) {
+
+function copyFile$1 (srcStat, src, dest, opts, cb) {
   fs$b.copyFile(src, dest, err => {
-    if (err) return cb(err);
-    if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
-    return setDestMode$1(dest, srcStat.mode, cb);
+    if (err) return cb(err)
+    if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
+    return setDestMode$1(dest, srcStat.mode, cb)
   });
 }
-function handleTimestampsAndMode(srcMode, src, dest, cb) {
+
+function handleTimestampsAndMode (srcMode, src, dest, cb) {
   // Make sure the file is writable before setting the timestamp
   // otherwise open fails with EPERM when invoked with 'r+'
   // (through utimes call)
   if (fileIsNotWritable$1(srcMode)) {
     return makeFileWritable$1(dest, srcMode, err => {
-      if (err) return cb(err);
-      return setDestTimestampsAndMode(srcMode, src, dest, cb);
-    });
+      if (err) return cb(err)
+      return setDestTimestampsAndMode(srcMode, src, dest, cb)
+    })
   }
-  return setDestTimestampsAndMode(srcMode, src, dest, cb);
+  return setDestTimestampsAndMode(srcMode, src, dest, cb)
 }
-function fileIsNotWritable$1(srcMode) {
-  return (srcMode & 0o200) === 0;
+
+function fileIsNotWritable$1 (srcMode) {
+  return (srcMode & 0o200) === 0
 }
-function makeFileWritable$1(dest, srcMode, cb) {
-  return setDestMode$1(dest, srcMode | 0o200, cb);
+
+function makeFileWritable$1 (dest, srcMode, cb) {
+  return setDestMode$1(dest, srcMode | 0o200, cb)
 }
-function setDestTimestampsAndMode(srcMode, src, dest, cb) {
+
+function setDestTimestampsAndMode (srcMode, src, dest, cb) {
   setDestTimestamps$1(src, dest, err => {
-    if (err) return cb(err);
-    return setDestMode$1(dest, srcMode, cb);
+    if (err) return cb(err)
+    return setDestMode$1(dest, srcMode, cb)
   });
 }
-function setDestMode$1(dest, srcMode, cb) {
-  return fs$b.chmod(dest, srcMode, cb);
+
+function setDestMode$1 (dest, srcMode, cb) {
+  return fs$b.chmod(dest, srcMode, cb)
 }
-function setDestTimestamps$1(src, dest, cb) {
+
+function setDestTimestamps$1 (src, dest, cb) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
   fs$b.stat(src, (err, updatedSrcStat) => {
-    if (err) return cb(err);
-    return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
+    if (err) return cb(err)
+    return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
   });
 }
-function onDir$1(srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return mkDirAndCopy$1(srcStat.mode, src, dest, opts, cb);
-  return copyDir$1(src, dest, opts, cb);
+
+function onDir$1 (srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return mkDirAndCopy$1(srcStat.mode, src, dest, opts, cb)
+  return copyDir$1(src, dest, opts, cb)
 }
-function mkDirAndCopy$1(srcMode, src, dest, opts, cb) {
+
+function mkDirAndCopy$1 (srcMode, src, dest, opts, cb) {
   fs$b.mkdir(dest, err => {
-    if (err) return cb(err);
+    if (err) return cb(err)
     copyDir$1(src, dest, opts, err => {
-      if (err) return cb(err);
-      return setDestMode$1(dest, srcMode, cb);
+      if (err) return cb(err)
+      return setDestMode$1(dest, srcMode, cb)
     });
   });
 }
-function copyDir$1(src, dest, opts, cb) {
+
+function copyDir$1 (src, dest, opts, cb) {
   fs$b.readdir(src, (err, items) => {
-    if (err) return cb(err);
-    return copyDirItems(items, src, dest, opts, cb);
+    if (err) return cb(err)
+    return copyDirItems(items, src, dest, opts, cb)
   });
 }
-function copyDirItems(items, src, dest, opts, cb) {
+
+function copyDirItems (items, src, dest, opts, cb) {
   const item = items.pop();
-  if (!item) return cb();
-  return copyDirItem$1(items, item, src, dest, opts, cb);
+  if (!item) return cb()
+  return copyDirItem$1(items, item, src, dest, opts, cb)
 }
-function copyDirItem$1(items, item, src, dest, opts, cb) {
+
+function copyDirItem$1 (items, item, src, dest, opts, cb) {
   const srcItem = path$9.join(src, item);
   const destItem = path$9.join(dest, item);
   runFilter(srcItem, destItem, opts, (err, include) => {
-    if (err) return cb(err);
-    if (!include) return copyDirItems(items, src, dest, opts, cb);
+    if (err) return cb(err)
+    if (!include) return copyDirItems(items, src, dest, opts, cb)
+
     stat$3.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
-      if (err) return cb(err);
-      const {
-        destStat
-      } = stats;
+      if (err) return cb(err)
+      const { destStat } = stats;
       getStats$1(destStat, srcItem, destItem, opts, err => {
-        if (err) return cb(err);
-        return copyDirItems(items, src, dest, opts, cb);
+        if (err) return cb(err)
+        return copyDirItems(items, src, dest, opts, cb)
       });
     });
   });
 }
-function onLink$1(destStat, src, dest, opts, cb) {
+
+function onLink$1 (destStat, src, dest, opts, cb) {
   fs$b.readlink(src, (err, resolvedSrc) => {
-    if (err) return cb(err);
+    if (err) return cb(err)
     if (opts.dereference) {
       resolvedSrc = path$9.resolve(process.cwd(), resolvedSrc);
     }
+
     if (!destStat) {
-      return fs$b.symlink(resolvedSrc, dest, cb);
+      return fs$b.symlink(resolvedSrc, dest, cb)
     } else {
       fs$b.readlink(dest, (err, resolvedDest) => {
         if (err) {
           // dest exists and is a regular file or directory,
           // Windows may throw UNKNOWN error. If dest already exists,
           // fs throws error anyway, so no need to guard against it here.
-          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$b.symlink(resolvedSrc, dest, cb);
-          return cb(err);
+          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$b.symlink(resolvedSrc, dest, cb)
+          return cb(err)
         }
         if (opts.dereference) {
           resolvedDest = path$9.resolve(process.cwd(), resolvedDest);
         }
         if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
-          return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
+          return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
         }
 
         // do not 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 (stat$3.isSrcSubdir(resolvedDest, resolvedSrc)) {
-          return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
+          return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
         }
-        return copyLink$1(resolvedSrc, dest, cb);
+        return copyLink$1(resolvedSrc, dest, cb)
       });
     }
   });
 }
-function copyLink$1(resolvedSrc, dest, cb) {
+
+function copyLink$1 (resolvedSrc, dest, cb) {
   fs$b.unlink(dest, err => {
-    if (err) return cb(err);
-    return fs$b.symlink(resolvedSrc, dest, cb);
+    if (err) return cb(err)
+    return fs$b.symlink(resolvedSrc, dest, cb)
   });
 }
+
 var copy_1 = copy$2;
 
 const fs$a = gracefulFs;
-const path$8 = require$$1__default["default"];
+const path$8 = require$$1;
 const mkdirsSync$1 = mkdirs$2.mkdirsSync;
 const utimesMillisSync = utimes.utimesMillisSync;
 const stat$2 = stat$4;
-function copySync$1(src, dest, opts) {
+
+function copySync$1 (src, dest, opts) {
   if (typeof opts === 'function') {
-    opts = {
-      filter: opts
-    };
+    opts = { filter: opts };
   }
+
   opts = opts || {};
   opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
   opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
 
   // Warn about using preserveTimestamps on 32-bit node
   if (opts.preserveTimestamps && process.arch === 'ia32') {
-    process.emitWarning('Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' + '\tsee https://github.com/jprichardson/node-fs-extra/issues/269', 'Warning', 'fs-extra-WARN0002');
+    process.emitWarning(
+      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+      'Warning', 'fs-extra-WARN0002'
+    );
   }
-  const {
-    srcStat,
-    destStat
-  } = stat$2.checkPathsSync(src, dest, 'copy', opts);
+
+  const { srcStat, destStat } = stat$2.checkPathsSync(src, dest, 'copy', opts);
   stat$2.checkParentPathsSync(src, srcStat, dest, 'copy');
-  if (opts.filter && !opts.filter(src, dest)) return;
+  if (opts.filter && !opts.filter(src, dest)) return
   const destParent = path$8.dirname(dest);
   if (!fs$a.existsSync(destParent)) mkdirsSync$1(destParent);
-  return getStats(destStat, src, dest, opts);
+  return getStats(destStat, src, dest, opts)
 }
-function getStats(destStat, src, dest, opts) {
+
+function getStats (destStat, src, dest, opts) {
   const statSync = opts.dereference ? fs$a.statSync : fs$a.lstatSync;
   const srcStat = statSync(src);
-  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
-  throw new Error(`Unknown file: ${src}`);
+
+  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
+  else if (srcStat.isFile() ||
+           srcStat.isCharacterDevice() ||
+           srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
+  else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
+  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
+  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
+  throw new Error(`Unknown file: ${src}`)
 }
-function onFile(srcStat, destStat, src, dest, opts) {
-  if (!destStat) return copyFile(srcStat, src, dest, opts);
-  return mayCopyFile(srcStat, src, dest, opts);
+
+function onFile (srcStat, destStat, src, dest, opts) {
+  if (!destStat) return copyFile(srcStat, src, dest, opts)
+  return mayCopyFile(srcStat, src, dest, opts)
 }
-function mayCopyFile(srcStat, src, dest, opts) {
+
+function mayCopyFile (srcStat, src, dest, opts) {
   if (opts.overwrite) {
     fs$a.unlinkSync(dest);
-    return copyFile(srcStat, src, dest, opts);
+    return copyFile(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
-    throw new Error(`'${dest}' already exists`);
+    throw new Error(`'${dest}' already exists`)
   }
 }
-function copyFile(srcStat, src, dest, opts) {
+
+function copyFile (srcStat, src, dest, opts) {
   fs$a.copyFileSync(src, dest);
   if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
-  return setDestMode(dest, srcStat.mode);
+  return setDestMode(dest, srcStat.mode)
 }
-function handleTimestamps(srcMode, src, dest) {
+
+function handleTimestamps (srcMode, src, dest) {
   // Make sure the file is writable before setting the timestamp
   // otherwise open fails with EPERM when invoked with 'r+'
   // (through utimes call)
   if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
-  return setDestTimestamps(src, dest);
+  return setDestTimestamps(src, dest)
 }
-function fileIsNotWritable(srcMode) {
-  return (srcMode & 0o200) === 0;
+
+function fileIsNotWritable (srcMode) {
+  return (srcMode & 0o200) === 0
 }
-function makeFileWritable(dest, srcMode) {
-  return setDestMode(dest, srcMode | 0o200);
+
+function makeFileWritable (dest, srcMode) {
+  return setDestMode(dest, srcMode | 0o200)
 }
-function setDestMode(dest, srcMode) {
-  return fs$a.chmodSync(dest, srcMode);
+
+function setDestMode (dest, srcMode) {
+  return fs$a.chmodSync(dest, srcMode)
 }
-function setDestTimestamps(src, dest) {
+
+function setDestTimestamps (src, dest) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
   const updatedSrcStat = fs$a.statSync(src);
-  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
 }
-function onDir(srcStat, destStat, src, dest, opts) {
-  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
-  return copyDir(src, dest, opts);
+
+function onDir (srcStat, destStat, src, dest, opts) {
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
+  return copyDir(src, dest, opts)
 }
-function mkDirAndCopy(srcMode, src, dest, opts) {
+
+function mkDirAndCopy (srcMode, src, dest, opts) {
   fs$a.mkdirSync(dest);
   copyDir(src, dest, opts);
-  return setDestMode(dest, srcMode);
+  return setDestMode(dest, srcMode)
 }
-function copyDir(src, dest, opts) {
+
+function copyDir (src, dest, opts) {
   fs$a.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts));
 }
-function copyDirItem(item, src, dest, opts) {
+
+function copyDirItem (item, src, dest, opts) {
   const srcItem = path$8.join(src, item);
   const destItem = path$8.join(dest, item);
-  if (opts.filter && !opts.filter(srcItem, destItem)) return;
-  const {
-    destStat
-  } = stat$2.checkPathsSync(srcItem, destItem, 'copy', opts);
-  return getStats(destStat, srcItem, destItem, opts);
+  if (opts.filter && !opts.filter(srcItem, destItem)) return
+  const { destStat } = stat$2.checkPathsSync(srcItem, destItem, 'copy', opts);
+  return getStats(destStat, srcItem, destItem, opts)
 }
-function onLink(destStat, src, dest, opts) {
+
+function onLink (destStat, src, dest, opts) {
   let resolvedSrc = fs$a.readlinkSync(src);
   if (opts.dereference) {
     resolvedSrc = path$8.resolve(process.cwd(), resolvedSrc);
   }
+
   if (!destStat) {
-    return fs$a.symlinkSync(resolvedSrc, dest);
+    return fs$a.symlinkSync(resolvedSrc, dest)
   } else {
     let resolvedDest;
     try {
@@ -1651,29 +1846,31 @@ function onLink(destStat, src, dest, opts) {
       // dest exists and is a regular file or directory,
       // Windows may throw UNKNOWN error. If dest already exists,
       // fs throws error anyway, so no need to guard against it here.
-      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$a.symlinkSync(resolvedSrc, dest);
-      throw err;
+      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$a.symlinkSync(resolvedSrc, dest)
+      throw err
     }
     if (opts.dereference) {
       resolvedDest = path$8.resolve(process.cwd(), resolvedDest);
     }
     if (stat$2.isSrcSubdir(resolvedSrc, resolvedDest)) {
-      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
     }
 
     // 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 (stat$2.isSrcSubdir(resolvedDest, resolvedSrc)) {
-      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
-    return copyLink(resolvedSrc, dest);
+    return copyLink(resolvedSrc, dest)
   }
 }
-function copyLink(resolvedSrc, dest) {
+
+function copyLink (resolvedSrc, dest) {
   fs$a.unlinkSync(dest);
-  return fs$a.symlinkSync(resolvedSrc, dest);
+  return fs$a.symlinkSync(resolvedSrc, dest)
 }
+
 var copySync_1 = copySync$1;
 
 const u$8 = universalify$1.fromCallback;
@@ -1684,18 +1881,15 @@ var copy$1 = {
 
 const fs$9 = gracefulFs;
 const u$7 = universalify$1.fromCallback;
-function remove$2(path, callback) {
-  fs$9.rm(path, {
-    recursive: true,
-    force: true
-  }, callback);
-}
-function removeSync$1(path) {
-  fs$9.rmSync(path, {
-    recursive: true,
-    force: true
-  });
+
+function remove$2 (path, callback) {
+  fs$9.rm(path, { recursive: true, force: true }, callback);
 }
+
+function removeSync$1 (path) {
+  fs$9.rmSync(path, { recursive: true, force: true });
+}
+
 var remove_1 = {
   remove: u$7(remove$2),
   removeSync: removeSync$1
@@ -1703,30 +1897,35 @@ var remove_1 = {
 
 const u$6 = universalify$1.fromPromise;
 const fs$8 = fs$h;
-const path$7 = require$$1__default["default"];
+const path$7 = require$$1;
 const mkdir$3 = mkdirs$2;
 const remove$1 = remove_1;
-const emptyDir = u$6(async function emptyDir(dir) {
+
+const emptyDir = u$6(async function emptyDir (dir) {
   let items;
   try {
     items = await fs$8.readdir(dir);
   } catch {
-    return mkdir$3.mkdirs(dir);
+    return mkdir$3.mkdirs(dir)
   }
-  return Promise.all(items.map(item => remove$1.remove(path$7.join(dir, item))));
+
+  return Promise.all(items.map(item => remove$1.remove(path$7.join(dir, item))))
 });
-function emptyDirSync(dir) {
+
+function emptyDirSync (dir) {
   let items;
   try {
     items = fs$8.readdirSync(dir);
   } catch {
-    return mkdir$3.mkdirsSync(dir);
+    return mkdir$3.mkdirsSync(dir)
   }
+
   items.forEach(item => {
     item = path$7.join(dir, item);
     remove$1.removeSync(item);
   });
 }
+
 var empty = {
   emptyDirSync,
   emptydirSync: emptyDirSync,
@@ -1735,47 +1934,52 @@ var empty = {
 };
 
 const u$5 = universalify$1.fromCallback;
-const path$6 = require$$1__default["default"];
+const path$6 = require$$1;
 const fs$7 = gracefulFs;
 const mkdir$2 = mkdirs$2;
-function createFile$1(file, callback) {
-  function makeFile() {
+
+function createFile$1 (file, callback) {
+  function makeFile () {
     fs$7.writeFile(file, '', err => {
-      if (err) return callback(err);
+      if (err) return callback(err)
       callback();
     });
   }
-  fs$7.stat(file, (err, stats) => {
-    // eslint-disable-line handle-callback-err
-    if (!err && stats.isFile()) return callback();
+
+  fs$7.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+    if (!err && stats.isFile()) return callback()
     const dir = path$6.dirname(file);
     fs$7.stat(dir, (err, stats) => {
       if (err) {
         // if the directory doesn't exist, make it
         if (err.code === 'ENOENT') {
           return mkdir$2.mkdirs(dir, err => {
-            if (err) return callback(err);
+            if (err) return callback(err)
             makeFile();
-          });
+          })
         }
-        return callback(err);
+        return callback(err)
       }
-      if (stats.isDirectory()) makeFile();else {
+
+      if (stats.isDirectory()) makeFile();
+      else {
         // parent is not a directory
         // This is just to cause an internal ENOTDIR error to be thrown
         fs$7.readdir(dir, err => {
-          if (err) return callback(err);
+          if (err) return callback(err)
         });
       }
     });
   });
 }
-function createFileSync$1(file) {
+
+function createFileSync$1 (file) {
   let stats;
   try {
     stats = fs$7.statSync(file);
   } catch {}
-  if (stats && stats.isFile()) return;
+  if (stats && stats.isFile()) return
+
   const dir = path$6.dirname(file);
   try {
     if (!fs$7.statSync(dir).isDirectory()) {
@@ -1785,73 +1989,82 @@ function createFileSync$1(file) {
     }
   } catch (err) {
     // If the stat call above failed because the directory doesn't exist, create it
-    if (err && err.code === 'ENOENT') mkdir$2.mkdirsSync(dir);else throw err;
+    if (err && err.code === 'ENOENT') mkdir$2.mkdirsSync(dir);
+    else throw err
   }
+
   fs$7.writeFileSync(file, '');
 }
+
 var file = {
   createFile: u$5(createFile$1),
   createFileSync: createFileSync$1
 };
 
 const u$4 = universalify$1.fromCallback;
-const path$5 = require$$1__default["default"];
+const path$5 = require$$1;
 const fs$6 = gracefulFs;
 const mkdir$1 = mkdirs$2;
 const pathExists$4 = pathExists_1.pathExists;
-const {
-  areIdentical: areIdentical$1
-} = stat$4;
-function createLink$1(srcpath, dstpath, callback) {
-  function makeLink(srcpath, dstpath) {
+const { areIdentical: areIdentical$1 } = stat$4;
+
+function createLink$1 (srcpath, dstpath, callback) {
+  function makeLink (srcpath, dstpath) {
     fs$6.link(srcpath, dstpath, err => {
-      if (err) return callback(err);
+      if (err) return callback(err)
       callback(null);
     });
   }
+
   fs$6.lstat(dstpath, (_, dstStat) => {
     fs$6.lstat(srcpath, (err, srcStat) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink');
-        return callback(err);
+        return callback(err)
       }
-      if (dstStat && areIdentical$1(srcStat, dstStat)) return callback(null);
+      if (dstStat && areIdentical$1(srcStat, dstStat)) return callback(null)
+
       const dir = path$5.dirname(dstpath);
       pathExists$4(dir, (err, dirExists) => {
-        if (err) return callback(err);
-        if (dirExists) return makeLink(srcpath, dstpath);
+        if (err) return callback(err)
+        if (dirExists) return makeLink(srcpath, dstpath)
         mkdir$1.mkdirs(dir, err => {
-          if (err) return callback(err);
+          if (err) return callback(err)
           makeLink(srcpath, dstpath);
         });
       });
     });
   });
 }
-function createLinkSync$1(srcpath, dstpath) {
+
+function createLinkSync$1 (srcpath, dstpath) {
   let dstStat;
   try {
     dstStat = fs$6.lstatSync(dstpath);
   } catch {}
+
   try {
     const srcStat = fs$6.lstatSync(srcpath);
-    if (dstStat && areIdentical$1(srcStat, dstStat)) return;
+    if (dstStat && areIdentical$1(srcStat, dstStat)) return
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
-    throw err;
+    throw err
   }
+
   const dir = path$5.dirname(dstpath);
   const dirExists = fs$6.existsSync(dir);
-  if (dirExists) return fs$6.linkSync(srcpath, dstpath);
+  if (dirExists) return fs$6.linkSync(srcpath, dstpath)
   mkdir$1.mkdirsSync(dir);
-  return fs$6.linkSync(srcpath, dstpath);
+
+  return fs$6.linkSync(srcpath, dstpath)
 }
+
 var link = {
   createLink: u$4(createLink$1),
   createLinkSync: createLinkSync$1
 };
 
-const path$4 = require$$1__default["default"];
+const path$4 = require$$1;
 const fs$5 = gracefulFs;
 const pathExists$3 = pathExists_1.pathExists;
 
@@ -1877,52 +2090,53 @@ const pathExists$3 = pathExists_1.pathExists;
  * the ability to pass in `relative to current working direcotry` paths.
  */
 
-function symlinkPaths$1(srcpath, dstpath, callback) {
+function symlinkPaths$1 (srcpath, dstpath, callback) {
   if (path$4.isAbsolute(srcpath)) {
-    return fs$5.lstat(srcpath, err => {
+    return fs$5.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureSymlink');
-        return callback(err);
+        return callback(err)
       }
       return callback(null, {
         toCwd: srcpath,
         toDst: srcpath
-      });
-    });
+      })
+    })
   } else {
     const dstdir = path$4.dirname(dstpath);
     const relativeToDst = path$4.join(dstdir, srcpath);
     return pathExists$3(relativeToDst, (err, exists) => {
-      if (err) return callback(err);
+      if (err) return callback(err)
       if (exists) {
         return callback(null, {
           toCwd: relativeToDst,
           toDst: srcpath
-        });
+        })
       } else {
-        return fs$5.lstat(srcpath, err => {
+        return fs$5.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace('lstat', 'ensureSymlink');
-            return callback(err);
+            return callback(err)
           }
           return callback(null, {
             toCwd: srcpath,
             toDst: path$4.relative(dstdir, srcpath)
-          });
-        });
+          })
+        })
       }
-    });
+    })
   }
 }
-function symlinkPathsSync$1(srcpath, dstpath) {
+
+function symlinkPathsSync$1 (srcpath, dstpath) {
   let exists;
   if (path$4.isAbsolute(srcpath)) {
     exists = fs$5.existsSync(srcpath);
-    if (!exists) throw new Error('absolute srcpath does not exist');
+    if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       toCwd: srcpath,
       toDst: srcpath
-    };
+    }
   } else {
     const dstdir = path$4.dirname(dstpath);
     const relativeToDst = path$4.join(dstdir, srcpath);
@@ -1931,95 +2145,109 @@ function symlinkPathsSync$1(srcpath, dstpath) {
       return {
         toCwd: relativeToDst,
         toDst: srcpath
-      };
+      }
     } else {
       exists = fs$5.existsSync(srcpath);
-      if (!exists) throw new Error('relative srcpath does not exist');
+      if (!exists) throw new Error('relative srcpath does not exist')
       return {
         toCwd: srcpath,
         toDst: path$4.relative(dstdir, srcpath)
-      };
+      }
     }
   }
 }
+
 var symlinkPaths_1 = {
   symlinkPaths: symlinkPaths$1,
   symlinkPathsSync: symlinkPathsSync$1
 };
 
 const fs$4 = 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);
+
+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$4.lstat(srcpath, (err, stats) => {
-    if (err) return callback(null, 'file');
-    type = stats && stats.isDirectory() ? 'dir' : 'file';
+    if (err) return callback(null, 'file')
+    type = (stats && stats.isDirectory()) ? 'dir' : 'file';
     callback(null, type);
   });
 }
-function symlinkTypeSync$1(srcpath, type) {
+
+function symlinkTypeSync$1 (srcpath, type) {
   let stats;
-  if (type) return type;
+
+  if (type) return type
   try {
     stats = fs$4.lstatSync(srcpath);
   } catch {
-    return 'file';
+    return 'file'
   }
-  return stats && stats.isDirectory() ? 'dir' : 'file';
+  return (stats && stats.isDirectory()) ? 'dir' : 'file'
 }
+
 var symlinkType_1 = {
   symlinkType: symlinkType$1,
   symlinkTypeSync: symlinkTypeSync$1
 };
 
 const u$3 = universalify$1.fromCallback;
-const path$3 = require$$1__default["default"];
+const path$3 = require$$1;
 const fs$3 = fs$h;
 const _mkdirs = mkdirs$2;
 const mkdirs = _mkdirs.mkdirs;
 const mkdirsSync = _mkdirs.mkdirsSync;
+
 const _symlinkPaths = symlinkPaths_1;
 const symlinkPaths = _symlinkPaths.symlinkPaths;
 const symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
+
 const _symlinkType = symlinkType_1;
 const symlinkType = _symlinkType.symlinkType;
 const symlinkTypeSync = _symlinkType.symlinkTypeSync;
+
 const pathExists$2 = pathExists_1.pathExists;
-const {
-  areIdentical
-} = stat$4;
-function createSymlink$1(srcpath, dstpath, type, callback) {
-  callback = typeof type === 'function' ? type : callback;
-  type = typeof type === 'function' ? false : type;
+
+const { areIdentical } = stat$4;
+
+function createSymlink$1 (srcpath, dstpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback;
+  type = (typeof type === 'function') ? false : type;
+
   fs$3.lstat(dstpath, (err, stats) => {
     if (!err && stats.isSymbolicLink()) {
-      Promise.all([fs$3.stat(srcpath), fs$3.stat(dstpath)]).then(([srcStat, dstStat]) => {
-        if (areIdentical(srcStat, dstStat)) return callback(null);
+      Promise.all([
+        fs$3.stat(srcpath),
+        fs$3.stat(dstpath)
+      ]).then(([srcStat, dstStat]) => {
+        if (areIdentical(srcStat, dstStat)) return callback(null)
         _createSymlink(srcpath, dstpath, type, callback);
       });
     } else _createSymlink(srcpath, dstpath, type, callback);
   });
 }
-function _createSymlink(srcpath, dstpath, type, callback) {
+
+function _createSymlink (srcpath, dstpath, type, callback) {
   symlinkPaths(srcpath, dstpath, (err, relative) => {
-    if (err) return callback(err);
+    if (err) return callback(err)
     srcpath = relative.toDst;
     symlinkType(relative.toCwd, type, (err, type) => {
-      if (err) return callback(err);
+      if (err) return callback(err)
       const dir = path$3.dirname(dstpath);
       pathExists$2(dir, (err, dirExists) => {
-        if (err) return callback(err);
-        if (dirExists) return fs$3.symlink(srcpath, dstpath, type, callback);
+        if (err) return callback(err)
+        if (dirExists) return fs$3.symlink(srcpath, dstpath, type, callback)
         mkdirs(dir, err => {
-          if (err) return callback(err);
+          if (err) return callback(err)
           fs$3.symlink(srcpath, dstpath, type, callback);
         });
       });
     });
   });
 }
-function createSymlinkSync$1(srcpath, dstpath, type) {
+
+function createSymlinkSync$1 (srcpath, dstpath, type) {
   let stats;
   try {
     stats = fs$3.lstatSync(dstpath);
@@ -2027,34 +2255,28 @@ function createSymlinkSync$1(srcpath, dstpath, type) {
   if (stats && stats.isSymbolicLink()) {
     const srcStat = fs$3.statSync(srcpath);
     const dstStat = fs$3.statSync(dstpath);
-    if (areIdentical(srcStat, dstStat)) return;
+    if (areIdentical(srcStat, dstStat)) return
   }
+
   const relative = symlinkPathsSync(srcpath, dstpath);
   srcpath = relative.toDst;
   type = symlinkTypeSync(relative.toCwd, type);
   const dir = path$3.dirname(dstpath);
   const exists = fs$3.existsSync(dir);
-  if (exists) return fs$3.symlinkSync(srcpath, dstpath, type);
+  if (exists) return fs$3.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$3.symlinkSync(srcpath, dstpath, type);
+  return fs$3.symlinkSync(srcpath, dstpath, type)
 }
+
 var symlink = {
   createSymlink: u$3(createSymlink$1),
   createSymlinkSync: createSymlinkSync$1
 };
 
-const {
-  createFile,
-  createFileSync
-} = file;
-const {
-  createLink,
-  createLinkSync
-} = link;
-const {
-  createSymlink,
-  createSymlinkSync
-} = symlink;
+const { createFile, createFileSync } = file;
+const { createLink, createLinkSync } = link;
+const { createSymlink, createSymlinkSync } = symlink;
+
 var ensure = {
   // file
   createFile,
@@ -2073,103 +2295,112 @@ var ensure = {
   ensureSymlinkSync: createSymlinkSync
 };
 
-function stringify$3(obj, {
-  EOL = '\n',
-  finalEOL = true,
-  replacer = null,
-  spaces
-} = {}) {
+function stringify$3 (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
   const EOF = finalEOL ? EOL : '';
   const str = JSON.stringify(obj, replacer, spaces);
-  return str.replace(/\n/g, EOL) + EOF;
+
+  return str.replace(/\n/g, EOL) + EOF
 }
-function stripBom$1(content) {
+
+function stripBom$1 (content) {
   // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
   if (Buffer.isBuffer(content)) content = content.toString('utf8');
-  return content.replace(/^\uFEFF/, '');
+  return content.replace(/^\uFEFF/, '')
 }
-var utils = {
-  stringify: stringify$3,
-  stripBom: stripBom$1
-};
+
+var utils = { stringify: stringify$3, stripBom: stripBom$1 };
 
 let _fs;
 try {
   _fs = gracefulFs;
 } catch (_) {
-  _fs = require$$0__default$2["default"];
+  _fs = require$$0$2;
 }
 const universalify = universalify$1;
-const {
-  stringify: stringify$2,
-  stripBom
-} = utils;
-async function _readFile(file, options = {}) {
+const { stringify: stringify$2, stripBom } = utils;
+
+async function _readFile (file, options = {}) {
   if (typeof options === 'string') {
-    options = {
-      encoding: options
-    };
+    options = { encoding: options };
   }
+
   const fs = options.fs || _fs;
+
   const shouldThrow = 'throws' in options ? options.throws : true;
+
   let data = await universalify.fromCallback(fs.readFile)(file, options);
+
   data = stripBom(data);
+
   let obj;
   try {
     obj = JSON.parse(data, options ? options.reviver : null);
   } catch (err) {
     if (shouldThrow) {
       err.message = `${file}: ${err.message}`;
-      throw err;
+      throw err
     } else {
-      return null;
+      return null
     }
   }
-  return obj;
+
+  return obj
 }
+
 const readFile = universalify.fromPromise(_readFile);
-function readFileSync(file, options = {}) {
+
+function readFileSync (file, options = {}) {
   if (typeof options === 'string') {
-    options = {
-      encoding: options
-    };
+    options = { encoding: options };
   }
+
   const fs = options.fs || _fs;
+
   const shouldThrow = 'throws' in options ? options.throws : true;
+
   try {
     let content = fs.readFileSync(file, options);
     content = stripBom(content);
-    return JSON.parse(content, options.reviver);
+    return JSON.parse(content, options.reviver)
   } catch (err) {
     if (shouldThrow) {
       err.message = `${file}: ${err.message}`;
-      throw err;
+      throw err
     } else {
-      return null;
+      return null
     }
   }
 }
-async function _writeFile(file, obj, options = {}) {
+
+async function _writeFile (file, obj, options = {}) {
   const fs = options.fs || _fs;
+
   const str = stringify$2(obj, options);
+
   await universalify.fromCallback(fs.writeFile)(file, str, options);
 }
+
 const writeFile = universalify.fromPromise(_writeFile);
-function writeFileSync(file, obj, options = {}) {
+
+function writeFileSync (file, obj, options = {}) {
   const fs = options.fs || _fs;
+
   const str = stringify$2(obj, options);
   // not sure if fs.writeFileSync returns anything, but just in case
-  return fs.writeFileSync(file, str, options);
+  return fs.writeFileSync(file, str, options)
 }
+
 const jsonfile$1 = {
   readFile,
   readFileSync,
   writeFile,
   writeFileSync
 };
+
 var jsonfile_1 = jsonfile$1;
 
 const jsonFile$1 = jsonfile_1;
+
 var jsonfile = {
   // jsonfile exports
   readJson: jsonFile$1.readFile,
@@ -2180,63 +2411,68 @@ var jsonfile = {
 
 const u$2 = universalify$1.fromCallback;
 const fs$2 = gracefulFs;
-const path$2 = require$$1__default["default"];
+const path$2 = require$$1;
 const mkdir = mkdirs$2;
 const pathExists$1 = pathExists_1.pathExists;
-function outputFile$1(file, data, encoding, callback) {
+
+function outputFile$1 (file, data, encoding, callback) {
   if (typeof encoding === 'function') {
     callback = encoding;
     encoding = 'utf8';
   }
+
   const dir = path$2.dirname(file);
   pathExists$1(dir, (err, itDoes) => {
-    if (err) return callback(err);
-    if (itDoes) return fs$2.writeFile(file, data, encoding, callback);
+    if (err) return callback(err)
+    if (itDoes) return fs$2.writeFile(file, data, encoding, callback)
+
     mkdir.mkdirs(dir, err => {
-      if (err) return callback(err);
+      if (err) return callback(err)
+
       fs$2.writeFile(file, data, encoding, callback);
     });
   });
 }
-function outputFileSync$1(file, ...args) {
+
+function outputFileSync$1 (file, ...args) {
   const dir = path$2.dirname(file);
   if (fs$2.existsSync(dir)) {
-    return fs$2.writeFileSync(file, ...args);
+    return fs$2.writeFileSync(file, ...args)
   }
   mkdir.mkdirsSync(dir);
   fs$2.writeFileSync(file, ...args);
 }
+
 var outputFile_1 = {
   outputFile: u$2(outputFile$1),
   outputFileSync: outputFileSync$1
 };
 
-const {
-  stringify: stringify$1
-} = utils;
-const {
-  outputFile
-} = outputFile_1;
-async function outputJson(file, data, options = {}) {
+const { stringify: stringify$1 } = utils;
+const { outputFile } = outputFile_1;
+
+async function outputJson (file, data, options = {}) {
   const str = stringify$1(data, options);
+
   await outputFile(file, str, options);
 }
+
 var outputJson_1 = outputJson;
 
-const {
-  stringify
-} = utils;
-const {
-  outputFileSync
-} = outputFile_1;
-function outputJsonSync(file, data, options) {
+const { stringify } = utils;
+const { outputFileSync } = outputFile_1;
+
+function outputJsonSync (file, data, options) {
   const str = stringify(data, options);
+
   outputFileSync(file, str, options);
 }
+
 var outputJsonSync_1 = outputJsonSync;
 
 const u$1 = universalify$1.fromPromise;
 const jsonFile = jsonfile;
+
 jsonFile.outputJson = u$1(outputJson_1);
 jsonFile.outputJsonSync = outputJsonSync_1;
 // aliases
@@ -2246,123 +2482,134 @@ jsonFile.writeJSON = jsonFile.writeJson;
 jsonFile.writeJSONSync = jsonFile.writeJsonSync;
 jsonFile.readJSON = jsonFile.readJson;
 jsonFile.readJSONSync = jsonFile.readJsonSync;
+
 var json = jsonFile;
 
 const fs$1 = gracefulFs;
-const path$1 = require$$1__default["default"];
+const path$1 = require$$1;
 const copy = copy$1.copy;
 const remove = remove_1.remove;
 const mkdirp = mkdirs$2.mkdirp;
 const pathExists = pathExists_1.pathExists;
 const stat$1 = stat$4;
-function move$1(src, dest, opts, cb) {
+
+function move$1 (src, dest, opts, cb) {
   if (typeof opts === 'function') {
     cb = opts;
     opts = {};
   }
+
   opts = opts || {};
+
   const overwrite = opts.overwrite || opts.clobber || false;
+
   stat$1.checkPaths(src, dest, 'move', opts, (err, stats) => {
-    if (err) return cb(err);
-    const {
-      srcStat,
-      isChangingCase = false
-    } = stats;
+    if (err) return cb(err)
+    const { srcStat, isChangingCase = false } = stats;
     stat$1.checkParentPaths(src, srcStat, dest, 'move', err => {
-      if (err) return cb(err);
-      if (isParentRoot$1(dest)) return doRename$1(src, dest, overwrite, isChangingCase, cb);
+      if (err) return cb(err)
+      if (isParentRoot$1(dest)) return doRename$1(src, dest, overwrite, isChangingCase, cb)
       mkdirp(path$1.dirname(dest), err => {
-        if (err) return cb(err);
-        return doRename$1(src, dest, overwrite, isChangingCase, cb);
+        if (err) return cb(err)
+        return doRename$1(src, dest, overwrite, isChangingCase, cb)
       });
     });
   });
 }
-function isParentRoot$1(dest) {
+
+function isParentRoot$1 (dest) {
   const parent = path$1.dirname(dest);
   const parsedPath = path$1.parse(parent);
-  return parsedPath.root === parent;
+  return parsedPath.root === parent
 }
-function doRename$1(src, dest, overwrite, isChangingCase, cb) {
-  if (isChangingCase) return rename$1(src, dest, overwrite, cb);
+
+function doRename$1 (src, dest, overwrite, isChangingCase, cb) {
+  if (isChangingCase) return rename$1(src, dest, overwrite, cb)
   if (overwrite) {
     return remove(dest, err => {
-      if (err) return cb(err);
-      return rename$1(src, dest, overwrite, cb);
-    });
+      if (err) return cb(err)
+      return rename$1(src, dest, overwrite, cb)
+    })
   }
   pathExists(dest, (err, destExists) => {
-    if (err) return cb(err);
-    if (destExists) return cb(new Error('dest already exists.'));
-    return rename$1(src, dest, overwrite, cb);
+    if (err) return cb(err)
+    if (destExists) return cb(new Error('dest already exists.'))
+    return rename$1(src, dest, overwrite, cb)
   });
 }
-function rename$1(src, dest, overwrite, cb) {
+
+function rename$1 (src, dest, overwrite, cb) {
   fs$1.rename(src, dest, err => {
-    if (!err) return cb();
-    if (err.code !== 'EXDEV') return cb(err);
-    return moveAcrossDevice$1(src, dest, overwrite, cb);
+    if (!err) return cb()
+    if (err.code !== 'EXDEV') return cb(err)
+    return moveAcrossDevice$1(src, dest, overwrite, cb)
   });
 }
-function moveAcrossDevice$1(src, dest, overwrite, cb) {
+
+function moveAcrossDevice$1 (src, dest, overwrite, cb) {
   const opts = {
     overwrite,
     errorOnExist: true
   };
   copy(src, dest, opts, err => {
-    if (err) return cb(err);
-    return remove(src, cb);
+    if (err) return cb(err)
+    return remove(src, cb)
   });
 }
+
 var move_1 = move$1;
 
 const fs = gracefulFs;
-const path = require$$1__default["default"];
+const path = require$$1;
 const copySync = copy$1.copySync;
 const removeSync = remove_1.removeSync;
 const mkdirpSync = mkdirs$2.mkdirpSync;
 const stat = stat$4;
-function moveSync(src, dest, opts) {
+
+function moveSync (src, dest, opts) {
   opts = opts || {};
   const overwrite = opts.overwrite || opts.clobber || false;
-  const {
-    srcStat,
-    isChangingCase = false
-  } = stat.checkPathsSync(src, dest, 'move', opts);
+
+  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts);
   stat.checkParentPathsSync(src, srcStat, dest, 'move');
   if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest));
-  return doRename(src, dest, overwrite, isChangingCase);
+  return doRename(src, dest, overwrite, isChangingCase)
 }
-function isParentRoot(dest) {
+
+function isParentRoot (dest) {
   const parent = path.dirname(dest);
   const parsedPath = path.parse(parent);
-  return parsedPath.root === parent;
+  return parsedPath.root === parent
 }
-function doRename(src, dest, overwrite, isChangingCase) {
-  if (isChangingCase) return rename(src, dest, overwrite);
+
+function doRename (src, dest, overwrite, isChangingCase) {
+  if (isChangingCase) return rename(src, dest, overwrite)
   if (overwrite) {
     removeSync(dest);
-    return rename(src, dest, overwrite);
+    return rename(src, dest, overwrite)
   }
-  if (fs.existsSync(dest)) throw new Error('dest already exists.');
-  return rename(src, dest, overwrite);
+  if (fs.existsSync(dest)) throw new Error('dest already exists.')
+  return rename(src, dest, overwrite)
 }
-function rename(src, dest, overwrite) {
+
+function rename (src, dest, overwrite) {
   try {
     fs.renameSync(src, dest);
   } catch (err) {
-    if (err.code !== 'EXDEV') throw err;
-    return moveAcrossDevice(src, dest, overwrite);
+    if (err.code !== 'EXDEV') throw err
+    return moveAcrossDevice(src, dest, overwrite)
   }
 }
-function moveAcrossDevice(src, dest, overwrite) {
+
+function moveAcrossDevice (src, dest, overwrite) {
   const opts = {
     overwrite,
     errorOnExist: true
   };
   copySync(src, dest, opts);
-  return removeSync(src);
+  return removeSync(src)
 }
+
 var moveSync_1 = moveSync;
 
 const u = universalify$1.fromCallback;
@@ -2386,9 +2633,9 @@ var lib = {
   ...remove_1
 };
 
-function ownKeys(object, enumerableOnly) { var keys = _Object$keys__default["default"](object); if (_Object$getOwnPropertySymbols__default["default"]) { var symbols = _Object$getOwnPropertySymbols__default["default"](object); enumerableOnly && (symbols = _filterInstanceProperty__default["default"](symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor__default["default"](object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var _context8, _context9; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty__default["default"](_context8 = ownKeys(Object(source), !0)).call(_context8, function (key) { _defineProperty__default["default"](target, key, source[key]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](target, _Object$getOwnPropertyDescriptors__default["default"](source)) : _forEachInstanceProperty__default["default"](_context9 = ownKeys(Object(source))).call(_context9, function (key) { _Object$defineProperty__default["default"](target, key, _Object$getOwnPropertyDescriptor__default["default"](source, key)); }); } return target; }
-var ProjectState = /*#__PURE__*/_createClass__default["default"](
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var _context8, _context9; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context8 = ownKeys(Object(source), !0)).call(_context8, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context9 = ownKeys(Object(source))).call(_context9, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+var ProjectState = /*#__PURE__*/_createClass(
 /**
  * This will be resolved or rejected once all the tasks associated with this
  * project finish.
@@ -2408,12 +2655,12 @@ var ProjectState = /*#__PURE__*/_createClass__default["default"](
 
 function ProjectState() {
   var _this = this;
-  _classCallCheck__default["default"](this, ProjectState);
-  _defineProperty__default["default"](this, "promise", void 0);
-  _defineProperty__default["default"](this, "resolve", void 0);
-  _defineProperty__default["default"](this, "reject", void 0);
-  _defineProperty__default["default"](this, "stage", "pending");
-  this.promise = new _Promise__default["default"](function (resolve, reject) {
+  _classCallCheck(this, ProjectState);
+  _defineProperty(this, "promise", void 0);
+  _defineProperty(this, "resolve", void 0);
+  _defineProperty(this, "reject", void 0);
+  _defineProperty(this, "stage", "pending");
+  this.promise = new _Promise(function (resolve, reject) {
     _this.resolve = resolve;
     _this.reject = reject;
   });
@@ -2427,7 +2674,7 @@ function ProjectState() {
 function logError(title, details) {
   var _context;
   var wrappedDetails = details != null ? "\n".concat(details instanceof Error ? details.message : details) : "";
-  process.stderr.write(_concatInstanceProperty__default["default"](_context = "\n==> ".concat(title)).call(_context, wrappedDetails, "\n"));
+  process.stderr.write(_concatInstanceProperty(_context = "\n==> ".concat(title)).call(_context, wrappedDetails, "\n"));
 }
 /**
  * @param title
@@ -2436,7 +2683,7 @@ function logError(title, details) {
 function logInfo(title, details) {
   var _context2;
   var wrappedDetails = details ? ":\n".concat(details) : "";
-  process.stdout.write(_concatInstanceProperty__default["default"](_context2 = "\n==> ".concat(title)).call(_context2, wrappedDetails, "\n"));
+  process.stdout.write(_concatInstanceProperty(_context2 = "\n==> ".concat(title)).call(_context2, wrappedDetails, "\n"));
 }
 /**
  * @param cwd
@@ -2476,25 +2723,25 @@ function createSpawner(logDir, getState) {
     var id = nextId++;
     var getHeaderLines = function getHeaderLines() {
       var _context3;
-      return _concatInstanceProperty__default["default"](_context3 = ["time: " + new Date().toISOString(), "id: " + id, "cwd: " + cwd, "cmd: " + _mapInstanceProperty__default["default"](cmd).call(cmd, function (word) {
-        return _JSON$stringify__default["default"](word);
-      }).join(" "), "states:"]).call(_context3, _toConsumableArray__default["default"](getState()));
+      return _concatInstanceProperty(_context3 = ["time: " + new Date().toISOString(), "id: " + id, "cwd: " + cwd, "cmd: " + _mapInstanceProperty(cmd).call(cmd, function (word) {
+        return _JSON$stringify(word);
+      }).join(" "), "states:"]).call(_context3, _toConsumableArray(getState()));
     };
     var getLogMessage = function getLogMessage() {
       var _context4;
-      return _mapInstanceProperty__default["default"](_context4 = getHeaderLines()).call(_context4, function (line) {
+      return _mapInstanceProperty(_context4 = getHeaderLines()).call(_context4, function (line) {
         return "  " + line;
       }).join("\n");
     };
     logInfo("Start", getLogMessage());
-    return new _Promise__default["default"](function (resolve, reject) {
+    return new _Promise(function (resolve, reject) {
       var _context5;
-      var commandLogPath = require$$1.join(logDir, [require$$1.basename(cwd).replace(/[^a-zA-Z0-9]+/g, "-"), cmd.join("-").replace(/[^a-zA-Z0-9]+/g, "-"), "id-" + _padStartInstanceProperty__default["default"](_context5 = "" + id).call(_context5, 3, "0"), "log"].join("."));
+      var commandLogPath = require$$1.join(logDir, [require$$1.basename(cwd).replace(/[^a-zA-Z0-9]+/g, "-"), cmd.join("-").replace(/[^a-zA-Z0-9]+/g, "-"), "id-" + _padStartInstanceProperty(_context5 = "" + id).call(_context5, 3, "0"), "log"].join("."));
       var logStream = lib.createWriteStream(commandLogPath, {
         flags: "a"
       });
       logStream.write(getHeaderLines().join("\n") + "\n\n");
-      var child = node_child_process.spawn(cmd[0], _sliceInstanceProperty__default["default"](cmd).call(cmd, 1), {
+      var child = node_child_process.spawn(cmd[0], _sliceInstanceProperty(cmd).call(cmd, 1), {
         cwd: cwd,
         env: _objectSpread(_objectSpread({}, process.env), {}, {
           VIS_INTEROP: "1"
@@ -2510,7 +2757,7 @@ function createSpawner(logDir, getState) {
        * @param code - The code or other kind of status to append.
        */
       function addStatusCodeToFilename(code) {
-        var newPath = _sliceInstanceProperty__default["default"](commandLogPath).call(commandLogPath, 0, -4) + ".status-" + code + ".log";
+        var newPath = _sliceInstanceProperty(commandLogPath).call(commandLogPath, 0, -4) + ".status-" + code + ".log";
         lib.rename(commandLogPath, newPath).catch(function (error) {
           console.error("Failed to rename log file to ".concat(newPath, "."), error);
         });
@@ -2520,13 +2767,13 @@ function createSpawner(logDir, getState) {
         if (failed) ; else if (code !== 0) {
           var _context6;
           logError("Fail", getLogMessage());
-          var errorMessage = _concatInstanceProperty__default["default"](_context6 = "".concat(_mapInstanceProperty__default["default"](cmd).call(cmd, function (word) {
+          var errorMessage = _concatInstanceProperty(_context6 = "".concat(_mapInstanceProperty(cmd).call(cmd, function (word) {
             return "\"".concat(word, "\"");
           }).join(" "), ": exited with ")).call(_context6, code, ".");
           logStream.end(function () {
-            _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee() {
+            _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
               var commandOutput;
-              return _regeneratorRuntime__default["default"].wrap(function _callee$(_context7) {
+              return _regeneratorRuntime.wrap(function _callee$(_context7) {
                 while (1) switch (_context7.prev = _context7.next) {
                   case 0:
                     commandOutput = "";
@@ -2570,8 +2817,8 @@ function createSpawner(logDir, getState) {
   };
 }
 
-function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof _Symbol__default["default"] !== "undefined" && _getIteratorMethod__default["default"](o) || o["@@iterator"]; if (!it) { if (_Array$isArray__default["default"](o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray$1(o, minLen) { var _context33; if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = _sliceInstanceProperty__default["default"](_context33 = Object.prototype.toString.call(o)).call(_context33, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from__default["default"](o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && _getIteratorMethod(o) || o["@@iterator"]; if (!it) { if (_Array$isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray$1(o, minLen) { var _context33; if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = _sliceInstanceProperty(_context33 = Object.prototype.toString.call(o)).call(_context33, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
 function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 // Remove all temporary files on process exit.
 tmp.setGracefulCleanup();
@@ -2585,8 +2832,8 @@ function prepareTmpDir(_x) {
  * @param projectName
  */
 function _prepareTmpDir() {
-  _prepareTmpDir = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee(tmpPath) {
-    return _regeneratorRuntime__default["default"].wrap(function _callee$(_context) {
+  _prepareTmpDir = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(tmpPath) {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
           if (!tmpPath) {
@@ -2635,8 +2882,8 @@ function copyTarball(_x2, _x3) {
  * @param cwd
  */
 function _copyTarball() {
-  _copyTarball = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee2(data, projectName) {
-    return _regeneratorRuntime__default["default"].wrap(function _callee2$(_context2) {
+  _copyTarball = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data, projectName) {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
           _context2.next = 2;
@@ -2657,14 +2904,14 @@ function getPackageDeps(_x4) {
  * @param projectName
  */
 function _getPackageDeps() {
-  _getPackageDeps = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee3(cwd) {
+  _getPackageDeps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(cwd) {
     var _context3;
     var packageJSONPath, packageJSON;
-    return _regeneratorRuntime__default["default"].wrap(function _callee3$(_context4) {
+    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
         case 0:
           _context4.next = 2;
-          return findUp__default["default"]("package.json", {
+          return findUp("package.json", {
             cwd: cwd
           });
         case 2:
@@ -2681,7 +2928,7 @@ function _getPackageDeps() {
         case 8:
           _context4.t1 = _context4.sent;
           packageJSON = _context4.t0.parse.call(_context4.t0, _context4.t1);
-          return _context4.abrupt("return", _toConsumableArray__default["default"](new _Set__default["default"](_concatInstanceProperty__default["default"](_context3 = []).call(_context3, _toConsumableArray__default["default"](_Object$keys__default["default"](packageJSON.dependencies || {})), _toConsumableArray__default["default"](_Object$keys__default["default"](packageJSON.devDependencies || {})), _toConsumableArray__default["default"](_Object$keys__default["default"](packageJSON.peerDependencies || {}))))));
+          return _context4.abrupt("return", _toConsumableArray(new _Set(_concatInstanceProperty(_context3 = []).call(_context3, _toConsumableArray(_Object$keys(packageJSON.dependencies || {})), _toConsumableArray(_Object$keys(packageJSON.devDependencies || {})), _toConsumableArray(_Object$keys(packageJSON.peerDependencies || {}))))));
         case 11:
         case "end":
           return _context4.stop();
@@ -2699,15 +2946,15 @@ function getPackageLocalDeps(_x5, _x6) {
  * @param projectName
  */
 function _getPackageLocalDeps() {
-  _getPackageLocalDeps = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee4(data, projectName) {
+  _getPackageLocalDeps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data, projectName) {
     var _context5;
     var projectPaths, tmpReposResolve, cwd;
-    return _regeneratorRuntime__default["default"].wrap(function _callee4$(_context6) {
+    return _regeneratorRuntime.wrap(function _callee4$(_context6) {
       while (1) switch (_context6.prev = _context6.next) {
         case 0:
           projectPaths = data.projectPaths, tmpReposResolve = data.tmpReposResolve;
           cwd = tmpReposResolve(projectName);
-          _context6.t0 = _filterInstanceProperty__default["default"];
+          _context6.t0 = _filterInstanceProperty;
           _context6.next = 5;
           return getPackageDeps(cwd);
         case 5:
@@ -2731,9 +2978,9 @@ function clone(_x7, _x8, _x9) {
  * @param deps
  */
 function _clone() {
-  _clone = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee5(spawn, data, projectName) {
+  _clone = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(spawn, data, projectName) {
     var failCommand, projectPaths, tmpReposResolve, cwd, projectPath;
-    return _regeneratorRuntime__default["default"].wrap(function _callee5$(_context7) {
+    return _regeneratorRuntime.wrap(function _callee5$(_context7) {
       while (1) switch (_context7.prev = _context7.next) {
         case 0:
           failCommand = data.failCommand, projectPaths = data.projectPaths, tmpReposResolve = data.tmpReposResolve;
@@ -2776,14 +3023,14 @@ function updatePackageDepVersions(_x10, _x11) {
  * @param projectName
  */
 function _updatePackageDepVersions() {
-  _updatePackageDepVersions = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee6(cwd, deps) {
+  _updatePackageDepVersions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(cwd, deps) {
     var _context8, _packageJSON$dependen, _context9, _packageJSON$devDepen, _context10, _packageJSON$peerDepe;
     var packageJSONPath, packageJSON;
-    return _regeneratorRuntime__default["default"].wrap(function _callee6$(_context11) {
+    return _regeneratorRuntime.wrap(function _callee6$(_context11) {
       while (1) switch (_context11.prev = _context11.next) {
         case 0:
           _context11.next = 2;
-          return findUp__default["default"]("package.json", {
+          return findUp("package.json", {
             cwd: cwd
           });
         case 2:
@@ -2800,23 +3047,23 @@ function _updatePackageDepVersions() {
         case 8:
           _context11.t1 = _context11.sent;
           packageJSON = _context11.t0.parse.call(_context11.t0, _context11.t1);
-          _forEachInstanceProperty__default["default"](_context8 = _Object$keys__default["default"]((_packageJSON$dependen = packageJSON.dependencies) !== null && _packageJSON$dependen !== void 0 ? _packageJSON$dependen : {})).call(_context8, function (key) {
+          _forEachInstanceProperty(_context8 = _Object$keys((_packageJSON$dependen = packageJSON.dependencies) !== null && _packageJSON$dependen !== void 0 ? _packageJSON$dependen : {})).call(_context8, function (key) {
             if (Object.prototype.hasOwnProperty.call(deps, key)) {
               packageJSON.dependencies[key] = "file:" + deps[key];
             }
           });
-          _forEachInstanceProperty__default["default"](_context9 = _Object$keys__default["default"]((_packageJSON$devDepen = packageJSON.devDependencies) !== null && _packageJSON$devDepen !== void 0 ? _packageJSON$devDepen : {})).call(_context9, function (key) {
+          _forEachInstanceProperty(_context9 = _Object$keys((_packageJSON$devDepen = packageJSON.devDependencies) !== null && _packageJSON$devDepen !== void 0 ? _packageJSON$devDepen : {})).call(_context9, function (key) {
             if (Object.prototype.hasOwnProperty.call(deps, key)) {
               packageJSON.devDependencies[key] = "file:" + deps[key];
             }
           });
-          _forEachInstanceProperty__default["default"](_context10 = _Object$keys__default["default"]((_packageJSON$peerDepe = packageJSON.peerDependencies) !== null && _packageJSON$peerDepe !== void 0 ? _packageJSON$peerDepe : {})).call(_context10, function (key) {
+          _forEachInstanceProperty(_context10 = _Object$keys((_packageJSON$peerDepe = packageJSON.peerDependencies) !== null && _packageJSON$peerDepe !== void 0 ? _packageJSON$peerDepe : {})).call(_context10, function (key) {
             if (Object.prototype.hasOwnProperty.call(deps, key)) {
               packageJSON.peerDependencies[key] = "file:" + deps[key];
             }
           });
           _context11.next = 15;
-          return lib.writeFile(packageJSONPath, _JSON$stringify__default["default"](packageJSON, undefined, 4));
+          return lib.writeFile(packageJSONPath, _JSON$stringify(packageJSON, undefined, 4));
         case 15:
         case "end":
           return _context11.stop();
@@ -2832,17 +3079,17 @@ function buildTestPack(_x12, _x13, _x14) {
  * @param data
  */
 function _buildTestPack() {
-  _buildTestPack = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee7(spawn, data, projectName) {
+  _buildTestPack = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(spawn, data, projectName) {
     var _context12;
     var failCommand, packageScripts, tmpReposResolve, cwd, packageLockPath, _iterator, _step, _step$value, packageName, scriptName, skipIfMissing;
-    return _regeneratorRuntime__default["default"].wrap(function _callee7$(_context13) {
+    return _regeneratorRuntime.wrap(function _callee7$(_context13) {
       while (1) switch (_context13.prev = _context13.next) {
         case 0:
           failCommand = data.failCommand, packageScripts = data.packageScripts, tmpReposResolve = data.tmpReposResolve;
           cwd = tmpReposResolve(projectName);
           _context13.t0 = updatePackageDepVersions;
           _context13.t1 = cwd;
-          _context13.t2 = _reduceInstanceProperty__default["default"];
+          _context13.t2 = _reduceInstanceProperty;
           _context13.next = 7;
           return getPackageLocalDeps(data, projectName);
         case 7:
@@ -2850,12 +3097,12 @@ function _buildTestPack() {
           _context13.t4 = (0, _context13.t2)(_context13.t3).call(_context12, function (acc, key) {
             acc[key] = getTarballPath(data, key);
             return acc;
-          }, _Object$create__default["default"](null));
+          }, _Object$create(null));
           _context13.next = 11;
           return (0, _context13.t0)(_context13.t1, _context13.t4);
         case 11:
           _context13.next = 13;
-          return findUp__default["default"]("package-lock.json", {
+          return findUp("package-lock.json", {
             cwd: cwd
           });
         case 13:
@@ -2953,9 +3200,9 @@ function checkTmpPath(_x15) {
  * @param root0.tmpPath
  */
 function _checkTmpPath() {
-  _checkTmpPath = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee8(data) {
+  _checkTmpPath = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(data) {
     var tmpDir;
-    return _regeneratorRuntime__default["default"].wrap(function _callee8$(_context14) {
+    return _regeneratorRuntime.wrap(function _callee8$(_context14) {
       while (1) switch (_context14.prev = _context14.next) {
         case 0:
           tmpDir = data.tmpRootResolve();
@@ -2980,20 +3227,20 @@ function test(_x16) {
   return _test.apply(this, arguments);
 }
 function _test() {
-  _test = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee11(_ref2) {
+  _test = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(_ref2) {
     var _context18;
     var failCommand, logsToStdout, packageScripts, projectPaths, tmpPath, data, projectStatuses, getStages, _context21, _context22, _context26, _context27, spawn, allSucceeded, _iterator3, _step3, _step3$value, projectName, promise, _context28, _context29, _context30, _context31;
-    return _regeneratorRuntime__default["default"].wrap(function _callee11$(_context32) {
+    return _regeneratorRuntime.wrap(function _callee11$(_context32) {
       while (1) switch (_context32.prev = _context32.next) {
         case 0:
           getStages = function _getStages() {
             var _context19;
-            return _mapInstanceProperty__default["default"](_context19 = _toConsumableArray__default["default"](projectStatuses)).call(_context19, function (_ref3) {
+            return _mapInstanceProperty(_context19 = _toConsumableArray(projectStatuses)).call(_context19, function (_ref3) {
               var _context20;
-              var _ref4 = _slicedToArray__default["default"](_ref3, 2),
+              var _ref4 = _slicedToArray(_ref3, 2),
                 key = _ref4[0],
                 stage = _ref4[1].stage;
-              return _concatInstanceProperty__default["default"](_context20 = "  ".concat(key, ": ")).call(_context20, stage);
+              return _concatInstanceProperty(_context20 = "  ".concat(key, ": ")).call(_context20, stage);
             });
           };
           failCommand = _ref2.failCommand, logsToStdout = _ref2.logsToStdout, packageScripts = _ref2.packageScripts, projectPaths = _ref2.projectPaths, tmpPath = _ref2.tmpPath;
@@ -3005,7 +3252,7 @@ function _test() {
           logInfo("Skipping interop test.");
           return _context32.abrupt("return", true);
         case 5:
-          _context32.t0 = _Object$freeze__default["default"];
+          _context32.t0 = _Object$freeze;
           _context32.t1 = failCommand;
           _context32.t2 = packageScripts;
           _context32.t3 = projectPaths;
@@ -3018,21 +3265,21 @@ function _test() {
             for (var _len = arguments.length, paths = new Array(_len), _key = 0; _key < _len; _key++) {
               paths[_key] = arguments[_key];
             }
-            return require$$1.resolve.apply(void 0, _concatInstanceProperty__default["default"](_context15 = [data.tmpDir.name, "logs"]).call(_context15, paths));
+            return require$$1.resolve.apply(void 0, _concatInstanceProperty(_context15 = [data.tmpDir.name, "logs"]).call(_context15, paths));
           };
           _context32.t6 = function tmpReposResolve() {
             var _context16;
             for (var _len2 = arguments.length, paths = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
               paths[_key2] = arguments[_key2];
             }
-            return require$$1.resolve.apply(void 0, _concatInstanceProperty__default["default"](_context16 = [data.tmpDir.name, "repos"]).call(_context16, paths));
+            return require$$1.resolve.apply(void 0, _concatInstanceProperty(_context16 = [data.tmpDir.name, "repos"]).call(_context16, paths));
           };
           _context32.t7 = function tmpRootResolve() {
             var _context17;
             for (var _len3 = arguments.length, paths = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
               paths[_key3] = arguments[_key3];
             }
-            return require$$1.resolve.apply(void 0, _concatInstanceProperty__default["default"](_context17 = [data.tmpDir.name]).call(_context17, paths));
+            return require$$1.resolve.apply(void 0, _concatInstanceProperty(_context17 = [data.tmpDir.name]).call(_context17, paths));
           };
           _context32.t8 = process.cwd();
           _context32.t9 = {
@@ -3046,7 +3293,7 @@ function _test() {
             visDevUtilsPath: _context32.t8
           };
           data = (0, _context32.t0)(_context32.t9);
-          projectStatuses = new _Map__default["default"](_mapInstanceProperty__default["default"](_context18 = _Object$keys__default["default"](data.projectPaths)).call(_context18, function (project) {
+          projectStatuses = new _Map(_mapInstanceProperty(_context18 = _Object$keys(data.projectPaths)).call(_context18, function (project) {
             return [project, new ProjectState()];
           }));
           /**
@@ -3058,25 +3305,25 @@ function _test() {
           return checkTmpPath(data);
         case 23:
           _context32.next = 25;
-          return _Promise__default["default"].all(_mapInstanceProperty__default["default"](_context21 = ["repos", "logs"]).call(_context21, function (dir) {
+          return _Promise.all(_mapInstanceProperty(_context21 = ["repos", "logs"]).call(_context21, function (dir) {
             return lib.mkdir(require$$1.resolve(data.tmpDir.name, dir));
           }));
         case 25:
           logInfo("Begin", getStages().join("\n"));
           _context32.next = 28;
-          return _Promise__default["default"].all(_mapInstanceProperty__default["default"](_context22 = _toConsumableArray__default["default"](projectStatuses)).call(_context22, /*#__PURE__*/function () {
-            var _ref6 = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee10(_ref5) {
+          return _Promise.all(_mapInstanceProperty(_context22 = _toConsumableArray(projectStatuses)).call(_context22, /*#__PURE__*/function () {
+            var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(_ref5) {
               var _ref7, projectName, state, projectPath, stats, failedDeps, localDeps, _iterator2, _step2, localDep, depStatus, _context24;
-              return _regeneratorRuntime__default["default"].wrap(function _callee10$(_context25) {
+              return _regeneratorRuntime.wrap(function _callee10$(_context25) {
                 while (1) switch (_context25.prev = _context25.next) {
                   case 0:
-                    _ref7 = _slicedToArray__default["default"](_ref5, 2), projectName = _ref7[0], state = _ref7[1];
+                    _ref7 = _slicedToArray(_ref5, 2), projectName = _ref7[0], state = _ref7[1];
                     _context25.prev = 1;
                     state.stage = "preparing";
                     projectPath = data.projectPaths[projectName];
                     _context25.next = 6;
-                    return _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee9() {
-                      return _regeneratorRuntime__default["default"].wrap(function _callee9$(_context23) {
+                    return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+                      return _regeneratorRuntime.wrap(function _callee9$(_context23) {
                         while (1) switch (_context23.prev = _context23.next) {
                           case 0:
                             _context23.prev = 0;
@@ -3183,7 +3430,7 @@ function _test() {
                   case 60:
                     _context25.prev = 60;
                     _context25.t2 = _context25["catch"](1);
-                    logError(_concatInstanceProperty__default["default"](_context24 = "Fail ".concat(projectName, " (")).call(_context24, state.stage, "):"), getStages().join("\n"));
+                    logError(_concatInstanceProperty(_context24 = "Fail ".concat(projectName, " (")).call(_context24, state.stage, "):"), getStages().join("\n"));
                     state.reject(_context25.t2 instanceof Error ? _context25.t2 : new Error("" + _context25.t2));
                   case 64:
                   case "end":
@@ -3196,9 +3443,9 @@ function _test() {
             };
           }()));
         case 28:
-          _context32.t10 = _everyInstanceProperty__default["default"];
+          _context32.t10 = _everyInstanceProperty;
           _context32.next = 31;
-          return _Promise__default["default"].allSettled(_mapInstanceProperty__default["default"](_context27 = _toConsumableArray__default["default"](_valuesInstanceProperty__default["default"](projectStatuses).call(projectStatuses))).call(_context27, function (status) {
+          return _Promise.allSettled(_mapInstanceProperty(_context27 = _toConsumableArray(_valuesInstanceProperty(projectStatuses).call(projectStatuses))).call(_context27, function (status) {
             return status.promise;
           }));
         case 31:
@@ -3227,7 +3474,7 @@ function _test() {
             _context32.next = 55;
             break;
           }
-          _step3$value = _slicedToArray__default["default"](_step3.value, 2), projectName = _step3$value[0], promise = _step3$value[1].promise;
+          _step3$value = _slicedToArray(_step3.value, 2), projectName = _step3$value[0], promise = _step3$value[1].promise;
           _context32.prev = 45;
           _context32.next = 48;
           return promise;
@@ -3259,11 +3506,11 @@ function _test() {
           }
           logInfo("Outputs");
           _context32.t14 = process.stdout;
-          _context32.t15 = _concatInstanceProperty__default["default"](_context28 = [""]);
+          _context32.t15 = _concatInstanceProperty(_context28 = [""]);
           _context32.t16 = _context28;
-          _context32.t17 = _toConsumableArray__default["default"];
-          _context32.t18 = _Promise__default["default"];
-          _context32.t19 = _mapInstanceProperty__default["default"];
+          _context32.t17 = _toConsumableArray;
+          _context32.t18 = _Promise;
+          _context32.t19 = _mapInstanceProperty;
           _context32.next = 73;
           return lib.readdir(data.tmpLogsResolve());
         case 73:
@@ -3277,7 +3524,7 @@ function _test() {
           _context32.t22 = _context32.sent;
           _context32.t23 = (0, _context32.t17)(_context32.t22);
           _context32.t24 = [""];
-          _context32.t25 = _context32.t15.call.call(_context32.t15, _context32.t16, _context32.t23, _context32.t24).join("\n\n" + _repeatInstanceProperty__default["default"](_context30 = _repeatInstanceProperty__default["default"](_context31 = "-").call(_context31, 80) + "\n").call(_context30, 2) + "\n");
+          _context32.t25 = _context32.t15.call.call(_context32.t15, _context32.t16, _context32.t23, _context32.t24).join("\n\n" + _repeatInstanceProperty(_context30 = _repeatInstanceProperty(_context31 = "-").call(_context31, 80) + "\n").call(_context30, 2) + "\n");
           _context32.t14.write.call(_context32.t14, _context32.t25);
         case 82:
           execFail(data.tmpDir.name, failCommand, "Allow the state to be inspected in debug mode before the data is lost.");
@@ -3292,13 +3539,13 @@ function _test() {
 }
 
 var _context, _context2;
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof _Symbol__default["default"] !== "undefined" && _getIteratorMethod__default["default"](o) || o["@@iterator"]; if (!it) { if (_Array$isArray__default["default"](o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { var _context3; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty__default["default"](_context3 = Object.prototype.toString.call(o)).call(_context3, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from__default["default"](o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && _getIteratorMethod(o) || o["@@iterator"]; if (!it) { if (_Array$isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { var _context3; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context3 = Object.prototype.toString.call(o)).call(_context3, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 var argv = parseArguments();
-var projectPaths = _reduceInstanceProperty__default["default"](_context = _mapInstanceProperty__default["default"](_context2 = argv["project"]).call(_context2, function (raw) {
+var projectPaths = _reduceInstanceProperty(_context = _mapInstanceProperty(_context2 = argv["project"]).call(_context2, function (raw) {
   var _raw$split = raw.split(" ", 2),
-    _raw$split2 = _slicedToArray__default["default"](_raw$split, 2),
+    _raw$split2 = _slicedToArray(_raw$split, 2),
     name = _raw$split2[0],
     path = _raw$split2[1];
   if (typeof name === "string" && typeof path === "string") {
@@ -3314,14 +3561,14 @@ var projectPaths = _reduceInstanceProperty__default["default"](_context = _mapIn
     process.exit(1);
   }
 })).call(_context, function (acc, _ref) {
-  var _ref2 = _slicedToArray__default["default"](_ref, 2),
+  var _ref2 = _slicedToArray(_ref, 2),
     name = _ref2[0],
     path = _ref2[1];
   acc[name] = path;
   return acc;
 }, {});
 var rawPackageScriptArg = argv["package-script"];
-var packageScripts = _flatMapInstanceProperty__default["default"](rawPackageScriptArg).call(rawPackageScriptArg, function (raw) {
+var packageScripts = _flatMapInstanceProperty(rawPackageScriptArg).call(rawPackageScriptArg, function (raw) {
   var packageScripts = [];
   var packageName = null;
   var _iterator = _createForOfIteratorHelper(raw.split(" ")),
@@ -3329,11 +3576,11 @@ var packageScripts = _flatMapInstanceProperty__default["default"](rawPackageScri
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var part = _step.value;
-      var mode = _sliceInstanceProperty__default["default"](part).call(part, -1);
+      var mode = _sliceInstanceProperty(part).call(part, -1);
       if (mode === "?" || mode === "!") {
         packageScripts.push({
           packageName: packageName,
-          scriptName: _sliceInstanceProperty__default["default"](part).call(part, 0, -1),
+          scriptName: _sliceInstanceProperty(part).call(part, 0, -1),
           skipIfMissing: mode === "?"
         });
       } else {