@andersbakken/fisk 3.5.6 → 3.6.0

package/dist/VM_runtime.js

@@ -0,0 +1,4040 @@
+'use strict';
+
+var EventEmitter = require('events');
+var assert$1 = require('assert');
+var child_process = require('child_process');
+var require$$1 = require('fs');
+var require$$0 = require('constants');
+var require$$0$1 = require('stream');
+var require$$4 = require('util');
+var path$j = require('path');
+var require$$1$1 = require('os');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert$1);
+var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
+var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$j);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var libExports = {};
+var lib = {
+  get exports(){ return libExports; },
+  set exports(v){ libExports = v; },
+};
+
+var fs$k = {};
+
+var universalify = {};
+
+universalify.fromCallback = function (fn) {
+  return Object.defineProperty(function () {
+    if (typeof arguments[arguments.length - 1] === 'function') fn.apply(this, arguments);
+    else {
+      return new Promise((resolve, reject) => {
+        arguments[arguments.length] = (err, res) => {
+          if (err) return reject(err)
+          resolve(res);
+        };
+        arguments.length++;
+        fn.apply(this, arguments);
+      })
+    }
+  }, 'name', { value: fn.name })
+};
+
+universalify.fromPromise = function (fn) {
+  return Object.defineProperty(function () {
+    const cb = arguments[arguments.length - 1];
+    if (typeof cb !== 'function') return fn.apply(this, arguments)
+    else fn.apply(this, arguments).then(r => cb(null, r), cb);
+  }, 'name', { value: fn.name })
+};
+
+var constants = require$$0__default["default"];
+
+var origCwd = process.cwd;
+var cwd = null;
+
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process);
+  return cwd
+};
+try {
+  process.cwd();
+} catch (er) {}
+
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir;
+  process.chdir = function (d) {
+    cwd = null;
+    chdir.call(process, d);
+  };
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+}
+
+var polyfills$1 = patch$1;
+
+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\./)) {
+    patchLchmod(fs);
+  }
+
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs);
+  }
+
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
+
+  fs.chown = chownFix(fs.chown);
+  fs.fchown = chownFix(fs.fchown);
+  fs.lchown = chownFix(fs.lchown);
+
+  fs.chmod = chmodFix(fs.chmod);
+  fs.fchmod = chmodFix(fs.fchmod);
+  fs.lchmod = chmodFix(fs.lchmod);
+
+  fs.chownSync = chownFixSync(fs.chownSync);
+  fs.fchownSync = chownFixSync(fs.fchownSync);
+  fs.lchownSync = chownFixSync(fs.lchownSync);
+
+  fs.chmodSync = chmodFixSync(fs.chmodSync);
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+
+  fs.stat = statFix(fs.stat);
+  fs.fstat = statFix(fs.fstat);
+  fs.lstat = statFix(fs.lstat);
+
+  fs.statSync = statFixSync(fs.statSync);
+  fs.fstatSync = statFixSync(fs.fstatSync);
+  fs.lstatSync = statFixSync(fs.lstatSync);
+
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (fs.chmod && !fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb);
+    };
+    fs.lchmodSync = function () {};
+  }
+  if (fs.chown && !fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb);
+    };
+    fs.lchownSync = function () {};
+  }
+
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
+
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now();
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er);
+              });
+            }, backoff);
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er);
+        });
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+      return rename
+    })(fs.rename);
+  }
+
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback;
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0;
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++;
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments);
+        };
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
+
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+    return read
+  })(fs.read);
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0;
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++;
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync);
+
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err);
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2);
+          });
+        });
+      });
+    };
+
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true;
+      var ret;
+      try {
+        ret = fs.fchmodSync(fd, mode);
+        threw = false;
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd);
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd);
+        }
+      }
+      return ret
+    };
+  }
+
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er);
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2);
+            });
+          });
+        });
+      };
+
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK);
+        var ret;
+        var threw = true;
+        try {
+          ret = fs.futimesSync(fd, at, mt);
+          threw = false;
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd);
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd);
+          }
+        }
+        return ret
+      };
+
+    } else if (fs.futimes) {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
+      fs.lutimesSync = function () {};
+    }
+  }
+
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null;
+        if (cb) cb.apply(this, arguments);
+      })
+    }
+  }
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null;
+        if (cb) cb.apply(this, arguments);
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options;
+        options = null;
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000;
+          if (stats.gid < 0) stats.gid += 0x100000000;
+        }
+        if (cb) cb.apply(this, arguments);
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target);
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000;
+        if (stats.gid < 0) stats.gid += 0x100000000;
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0;
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}
+
+var Stream = require$$0__default$1["default"].Stream;
+
+var legacyStreams = legacy$1;
+
+function legacy$1 (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
+
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
+    Stream.call(this);
+
+    var self = this;
+
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
+
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.encoding) this.setEncoding(this.encoding);
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
+
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
+
+      this.pos = this.start;
+    }
+
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
+
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
+
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    });
+  }
+
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
+    Stream.call(this);
+
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
+
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
+
+      this.pos = this.start;
+    }
+
+    this.busy = false;
+    this._queue = [];
+
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}
+
+var clone_1 = clone$1;
+
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+};
+
+function clone$1 (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
+}
+
+var fs$j = require$$1__default["default"];
+var polyfills = polyfills$1;
+var legacy = legacyStreams;
+var clone = clone_1;
+
+var util = require$$4__default["default"];
+
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue;
+var previousSymbol;
+
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue');
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous');
+} else {
+  gracefulQueue = '___graceful-fs.queue';
+  previousSymbol = '___graceful-fs.previous';
+}
+
+function noop () {}
+
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  });
+}
+
+var debug = noop;
+if (util.debuglog)
+  debug = util.debuglog('gfs4');
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments);
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
+    console.error(m);
+  };
+
+// Once time initialization
+if (!fs$j[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = commonjsGlobal[gracefulQueue] || [];
+  publishQueue(fs$j, queue);
+
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs$j.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs$j, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue();
+        }
+
+        if (typeof cb === 'function')
+          cb.apply(this, arguments);
+      })
+    }
+
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    });
+    return close
+  })(fs$j.close);
+
+  fs$j.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs$j, arguments);
+      resetQueue();
+    }
+
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    });
+    return closeSync
+  })(fs$j.closeSync);
+
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs$j[gracefulQueue]);
+      assert__default["default"].equal(fs$j[gracefulQueue].length, 0);
+    });
+  }
+}
+
+if (!commonjsGlobal[gracefulQueue]) {
+  publishQueue(commonjsGlobal, fs$j[gracefulQueue]);
+}
+
+var gracefulFs = patch(clone(fs$j));
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$j.__patched) {
+    gracefulFs = patch(fs$j);
+    fs$j.__patched = true;
+}
+
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs);
+  fs.gracefulify = patch;
+
+  fs.createReadStream = createReadStream;
+  fs.createWriteStream = createWriteStream;
+  var fs$readFile = fs.readFile;
+  fs.readFile = readFile;
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$readFile(path, options, cb)
+
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
+        }
+      })
+    }
+  }
+
+  var fs$writeFile = fs.writeFile;
+  fs.writeFile = writeFile;
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$writeFile(path, data, options, cb)
+
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
+        }
+      })
+    }
+  }
+
+  var fs$appendFile = fs.appendFile;
+  if (fs$appendFile)
+    fs.appendFile = appendFile;
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    return go$appendFile(path, data, options, cb)
+
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
+        }
+      })
+    }
+  }
+
+  var fs$copyFile = fs.copyFile;
+  if (fs$copyFile)
+    fs.copyFile = copyFile;
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags;
+      flags = 0;
+    }
+    return go$copyFile(src, dest, flags, cb)
+
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
+        }
+      })
+    }
+  }
+
+  var fs$readdir = fs.readdir;
+  fs.readdir = readdir;
+  var noReaddirOptionVersions = /^v[0-5]\./;
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null;
+
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      };
+
+    return go$readdir(path, options, cb)
+
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ]);
+        else {
+          if (files && files.sort)
+            files.sort();
+
+          if (typeof cb === 'function')
+            cb.call(this, err, files);
+        }
+      }
+    }
+  }
+
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs);
+    ReadStream = legStreams.ReadStream;
+    WriteStream = legStreams.WriteStream;
+  }
+
+  var fs$ReadStream = fs.ReadStream;
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+    ReadStream.prototype.open = ReadStream$open;
+  }
+
+  var fs$WriteStream = fs.WriteStream;
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+    WriteStream.prototype.open = WriteStream$open;
+  }
+
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  // legacy names
+  var FileReadStream = ReadStream;
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  var FileWriteStream = WriteStream;
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
+
+  function ReadStream$open () {
+    var that = this;
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy();
+
+        that.emit('error', err);
+      } else {
+        that.fd = fd;
+        that.emit('open', fd);
+        that.read();
+      }
+    });
+  }
+
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
+
+  function WriteStream$open () {
+    var that = this;
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy();
+        that.emit('error', err);
+      } else {
+        that.fd = fd;
+        that.emit('open', fd);
+      }
+    });
+  }
+
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
+
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
+
+  var fs$open = fs.open;
+  fs.open = open;
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null;
+
+    return go$open(path, flags, mode, cb)
+
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments);
+        }
+      })
+    }
+  }
+
+  return fs
+}
+
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1]);
+  fs$j[gracefulQueue].push(elem);
+  retry();
+}
+
+// keep track of the timeout between retry() calls
+var retryTimer;
+
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now();
+  for (var i = 0; i < fs$j[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs$j[gracefulQueue][i].length > 2) {
+      fs$j[gracefulQueue][i][3] = now; // startTime
+      fs$j[gracefulQueue][i][4] = now; // lastTime
+    }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry();
+}
+
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer);
+  retryTimer = undefined;
+
+  if (fs$j[gracefulQueue].length === 0)
+    return
+
+  var elem = fs$j[gracefulQueue].shift();
+  var fn = elem[0];
+  var args = elem[1];
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2];
+  var startTime = elem[3];
+  var lastTime = elem[4];
+
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args);
+    fn.apply(null, args);
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args);
+    var cb = args.pop();
+    if (typeof cb === 'function')
+      cb.call(null, err);
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime;
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1);
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100);
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args);
+      fn.apply(null, args.concat([startTime]));
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs$j[gracefulQueue].push(elem);
+    }
+  }
+
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0);
+  }
+}
+
+(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.fromCallback;
+	const fs = gracefulFs;
+
+	const api = [
+	  'access',
+	  'appendFile',
+	  'chmod',
+	  'chown',
+	  'close',
+	  'copyFile',
+	  'fchmod',
+	  'fchown',
+	  'fdatasync',
+	  'fstat',
+	  'fsync',
+	  'ftruncate',
+	  'futimes',
+	  'lchown',
+	  'link',
+	  'lstat',
+	  'mkdir',
+	  'mkdtemp',
+	  'open',
+	  'readFile',
+	  'readdir',
+	  'readlink',
+	  'realpath',
+	  'rename',
+	  'rmdir',
+	  'stat',
+	  'symlink',
+	  'truncate',
+	  'unlink',
+	  'utimes',
+	  'writeFile'
+	].filter(key => {
+	  // Some commands are not available on some systems. Ex:
+	  // fs.copyFile was added in Node.js v8.5.0
+	  // fs.mkdtemp was added in Node.js v5.10.0
+	  // fs.lchown is not available on at least some Linux
+	  return typeof fs[key] === 'function'
+	});
+
+	// Export all keys:
+	Object.keys(fs).forEach(key => {
+	  if (key === 'promises') {
+	    // fs.promises is a getter property that triggers ExperimentalWarning
+	    // Don't re-export it here, the getter is defined in "lib/index.js"
+	    return
+	  }
+	  exports[key] = fs[key];
+	});
+
+	// 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 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 });
+	    });
+	  })
+	};
+} (fs$k));
+
+const path$i = path__default["default"];
+
+// get drive on windows
+function getRootPath (p) {
+  p = path$i.normalize(path$i.resolve(p)).split(path$i.sep);
+  if (p.length > 0) return p[0]
+  return null
+}
+
+// http://stackoverflow.com/a/62888/10333 contains more accurate
+// TODO: expand to include the rest
+const INVALID_PATH_CHARS = /[<>:"|?*]/;
+
+function invalidWin32Path$2 (p) {
+  const rp = getRootPath(p);
+  p = p.replace(rp, '');
+  return INVALID_PATH_CHARS.test(p)
+}
+
+var win32 = {
+  getRootPath,
+  invalidWin32Path: invalidWin32Path$2
+};
+
+const fs$i = gracefulFs;
+const path$h = path__default["default"];
+const invalidWin32Path$1 = win32.invalidWin32Path;
+
+const o777$1 = parseInt('0777', 8);
+
+function mkdirs$2 (p, opts, callback, made) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  } else if (!opts || typeof opts !== 'object') {
+    opts = { mode: opts };
+  }
+
+  if (process.platform === 'win32' && invalidWin32Path$1(p)) {
+    const errInval = new Error(p + ' contains invalid WIN32 path characters.');
+    errInval.code = 'EINVAL';
+    return callback(errInval)
+  }
+
+  let mode = opts.mode;
+  const xfs = opts.fs || fs$i;
+
+  if (mode === undefined) {
+    mode = o777$1 & (~process.umask());
+  }
+  if (!made) made = null;
+
+  callback = callback || function () {};
+  p = path$h.resolve(p);
+
+  xfs.mkdir(p, mode, er => {
+    if (!er) {
+      made = made || p;
+      return callback(null, made)
+    }
+    switch (er.code) {
+      case 'ENOENT':
+        if (path$h.dirname(p) === p) return callback(er)
+        mkdirs$2(path$h.dirname(p), opts, (er, made) => {
+          if (er) callback(er, made);
+          else mkdirs$2(p, opts, callback, made);
+        });
+        break
+
+      // In the case of any other error, just see if there's a dir
+      // there already.  If so, then hooray!  If not, then something
+      // is borked.
+      default:
+        xfs.stat(p, (er2, stat) => {
+          // if the stat fails, then that's super weird.
+          // let the original error be the failure reason.
+          if (er2 || !stat.isDirectory()) callback(er, made);
+          else callback(null, made);
+        });
+        break
+    }
+  });
+}
+
+var mkdirs_1$1 = mkdirs$2;
+
+const fs$h = gracefulFs;
+const path$g = path__default["default"];
+const invalidWin32Path = win32.invalidWin32Path;
+
+const o777 = parseInt('0777', 8);
+
+function mkdirsSync$2 (p, opts, made) {
+  if (!opts || typeof opts !== 'object') {
+    opts = { mode: opts };
+  }
+
+  let mode = opts.mode;
+  const xfs = opts.fs || fs$h;
+
+  if (process.platform === 'win32' && invalidWin32Path(p)) {
+    const errInval = new Error(p + ' contains invalid WIN32 path characters.');
+    errInval.code = 'EINVAL';
+    throw errInval
+  }
+
+  if (mode === undefined) {
+    mode = o777 & (~process.umask());
+  }
+  if (!made) made = null;
+
+  p = path$g.resolve(p);
+
+  try {
+    xfs.mkdirSync(p, mode);
+    made = made || p;
+  } catch (err0) {
+    if (err0.code === 'ENOENT') {
+      if (path$g.dirname(p) === p) throw err0
+      made = mkdirsSync$2(path$g.dirname(p), opts, made);
+      mkdirsSync$2(p, opts, made);
+    } else {
+      // In the case of any other error, just see if there's a dir there
+      // already. If so, then hooray!  If not, then something is borked.
+      let stat;
+      try {
+        stat = xfs.statSync(p);
+      } catch (err1) {
+        throw err0
+      }
+      if (!stat.isDirectory()) throw err0
+    }
+  }
+
+  return made
+}
+
+var mkdirsSync_1 = mkdirsSync$2;
+
+const u$b = universalify.fromCallback;
+const mkdirs$1 = u$b(mkdirs_1$1);
+const mkdirsSync$1 = mkdirsSync_1;
+
+var mkdirs_1 = {
+  mkdirs: mkdirs$1,
+  mkdirsSync: mkdirsSync$1,
+  // alias
+  mkdirp: mkdirs$1,
+  mkdirpSync: mkdirsSync$1,
+  ensureDir: mkdirs$1,
+  ensureDirSync: mkdirsSync$1
+};
+
+const fs$g = gracefulFs;
+const os = require$$1__default$1["default"];
+const path$f = path__default["default"];
+
+// HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
+function hasMillisResSync () {
+  let tmpfile = path$f.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$f.join(os.tmpdir(), tmpfile);
+
+  // 550 millis past UNIX epoch
+  const d = new Date(1435410243862);
+  fs$g.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
+  const fd = fs$g.openSync(tmpfile, 'r+');
+  fs$g.futimesSync(fd, d, d);
+  fs$g.closeSync(fd);
+  return fs$g.statSync(tmpfile).mtime > 1435410243000
+}
+
+function hasMillisRes (callback) {
+  let tmpfile = path$f.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
+  tmpfile = path$f.join(os.tmpdir(), tmpfile);
+
+  // 550 millis past UNIX epoch
+  const d = new Date(1435410243862);
+  fs$g.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
+    if (err) return callback(err)
+    fs$g.open(tmpfile, 'r+', (err, fd) => {
+      if (err) return callback(err)
+      fs$g.futimes(fd, d, d, err => {
+        if (err) return callback(err)
+        fs$g.close(fd, err => {
+          if (err) return callback(err)
+          fs$g.stat(tmpfile, (err, stats) => {
+            if (err) return callback(err)
+            callback(null, stats.mtime > 1435410243000);
+          });
+        });
+      });
+    });
+  });
+}
+
+function timeRemoveMillis (timestamp) {
+  if (typeof timestamp === 'number') {
+    return Math.floor(timestamp / 1000) * 1000
+  } else if (timestamp instanceof Date) {
+    return new Date(Math.floor(timestamp.getTime() / 1000) * 1000)
+  } else {
+    throw new Error('fs-extra: timeRemoveMillis() unknown parameter type')
+  }
+}
+
+function utimesMillis (path, atime, mtime, callback) {
+  // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
+  fs$g.open(path, 'r+', (err, fd) => {
+    if (err) return callback(err)
+    fs$g.futimes(fd, atime, mtime, futimesErr => {
+      fs$g.close(fd, closeErr => {
+        if (callback) callback(futimesErr || closeErr);
+      });
+    });
+  });
+}
+
+function utimesMillisSync (path, atime, mtime) {
+  const fd = fs$g.openSync(path, 'r+');
+  fs$g.futimesSync(fd, atime, mtime);
+  return fs$g.closeSync(fd)
+}
+
+var utimes$1 = {
+  hasMillisRes,
+  hasMillisResSync,
+  timeRemoveMillis,
+  utimesMillis,
+  utimesMillisSync
+};
+
+/* eslint-disable node/no-deprecated-api */
+var buffer$1 = function (size) {
+  if (typeof Buffer.allocUnsafe === 'function') {
+    try {
+      return Buffer.allocUnsafe(size)
+    } catch (e) {
+      return new Buffer(size)
+    }
+  }
+  return new Buffer(size)
+};
+
+const fs$f = gracefulFs;
+const path$e = path__default["default"];
+const mkdirpSync$1 = mkdirs_1.mkdirsSync;
+const utimesSync = utimes$1.utimesMillisSync;
+
+const notExist$1 = Symbol('notExist');
+const existsReg$1 = Symbol('existsReg');
+
+function copySync$2 (src, dest, opts) {
+  if (typeof opts === 'function') {
+    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') {
+    console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+  }
+
+  const resolvedDest = checkPaths$1(src, dest);
+
+  if (opts.filter && !opts.filter(src, dest)) return
+
+  const destParent = path$e.dirname(dest);
+  if (!fs$f.existsSync(destParent)) mkdirpSync$1(destParent);
+  return startCopy$1(resolvedDest, src, dest, opts)
+}
+
+function startCopy$1 (resolvedDest, src, dest, opts) {
+  if (opts.filter && !opts.filter(src, dest)) return
+  return getStats$1(resolvedDest, src, dest, opts)
+}
+
+function getStats$1 (resolvedDest, src, dest, opts) {
+  const statSync = opts.dereference ? fs$f.statSync : fs$f.lstatSync;
+  const st = statSync(src);
+
+  if (st.isDirectory()) return onDir$1(st, resolvedDest, src, dest, opts)
+  else if (st.isFile() ||
+           st.isCharacterDevice() ||
+           st.isBlockDevice()) return onFile$1(st, resolvedDest, src, dest, opts)
+  else if (st.isSymbolicLink()) return onLink$1(resolvedDest, src, dest, opts)
+}
+
+function onFile$1 (srcStat, resolvedDest, src, dest, opts) {
+  if (resolvedDest === notExist$1) return copyFile$1(srcStat, src, dest, opts)
+  else if (resolvedDest === existsReg$1) return mayCopyFile$1(srcStat, src, dest, opts)
+  return mayCopyFile$1(srcStat, src, dest, opts)
+}
+
+function mayCopyFile$1 (srcStat, src, dest, opts) {
+  if (opts.overwrite) {
+    fs$f.unlinkSync(dest);
+    return copyFile$1(srcStat, src, dest, opts)
+  } else if (opts.errorOnExist) {
+    throw new Error(`'${dest}' already exists`)
+  }
+}
+
+function copyFile$1 (srcStat, src, dest, opts) {
+  if (typeof fs$f.copyFileSync === 'function') {
+    fs$f.copyFileSync(src, dest);
+    fs$f.chmodSync(dest, srcStat.mode);
+    if (opts.preserveTimestamps) {
+      return utimesSync(dest, srcStat.atime, srcStat.mtime)
+    }
+    return
+  }
+  return copyFileFallback$1(srcStat, src, dest, opts)
+}
+
+function copyFileFallback$1 (srcStat, src, dest, opts) {
+  const BUF_LENGTH = 64 * 1024;
+  const _buff = buffer$1(BUF_LENGTH);
+
+  const fdr = fs$f.openSync(src, 'r');
+  const fdw = fs$f.openSync(dest, 'w', srcStat.mode);
+  let pos = 0;
+
+  while (pos < srcStat.size) {
+    const bytesRead = fs$f.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$f.writeSync(fdw, _buff, 0, bytesRead);
+    pos += bytesRead;
+  }
+
+  if (opts.preserveTimestamps) fs$f.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+
+  fs$f.closeSync(fdr);
+  fs$f.closeSync(fdw);
+}
+
+function onDir$1 (srcStat, resolvedDest, src, dest, opts) {
+  if (resolvedDest === notExist$1) {
+    if (isSrcSubdir$3(src, dest)) {
+      throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`)
+    }
+    return mkDirAndCopy$1(srcStat, src, dest, opts)
+  } else if (resolvedDest === existsReg$1) {
+    if (isSrcSubdir$3(src, dest)) {
+      throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`)
+    }
+    return mayCopyDir$1(src, dest, opts)
+  }
+  return copyDir$1(src, dest, opts)
+}
+
+function mayCopyDir$1 (src, dest, opts) {
+  if (!fs$f.statSync(dest).isDirectory()) {
+    throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+  }
+  return copyDir$1(src, dest, opts)
+}
+
+function mkDirAndCopy$1 (srcStat, src, dest, opts) {
+  fs$f.mkdirSync(dest, srcStat.mode);
+  fs$f.chmodSync(dest, srcStat.mode);
+  return copyDir$1(src, dest, opts)
+}
+
+function copyDir$1 (src, dest, opts) {
+  fs$f.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
+}
+
+function copyDirItem$1 (item, src, dest, opts) {
+  const srcItem = path$e.join(src, item);
+  const destItem = path$e.join(dest, item);
+  const resolvedDest = checkPaths$1(srcItem, destItem);
+  return startCopy$1(resolvedDest, srcItem, destItem, opts)
+}
+
+function onLink$1 (resolvedDest, src, dest, opts) {
+  let resolvedSrc = fs$f.readlinkSync(src);
+
+  if (opts.dereference) {
+    resolvedSrc = path$e.resolve(process.cwd(), resolvedSrc);
+  }
+
+  if (resolvedDest === notExist$1 || resolvedDest === existsReg$1) {
+    // if dest already exists, fs throws error anyway,
+    // so no need to guard against it here.
+    return fs$f.symlinkSync(resolvedSrc, dest)
+  } else {
+    if (opts.dereference) {
+      resolvedDest = path$e.resolve(process.cwd(), resolvedDest);
+    }
+    if (pathsAreIdentical$1(resolvedSrc, resolvedDest)) return
+
+    // prevent copy if src is a subdir of dest since unlinking
+    // dest in this case would result in removing src contents
+    // and therefore a broken symlink would be created.
+    if (fs$f.statSync(dest).isDirectory() && isSrcSubdir$3(resolvedDest, resolvedSrc)) {
+      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
+    }
+    return copyLink$1(resolvedSrc, dest)
+  }
+}
+
+function copyLink$1 (resolvedSrc, dest) {
+  fs$f.unlinkSync(dest);
+  return fs$f.symlinkSync(resolvedSrc, dest)
+}
+
+// return true if dest is a subdir of src, otherwise false.
+// extract dest base dir and check if that is the same as src basename.
+function isSrcSubdir$3 (src, dest) {
+  const srcArray = path$e.resolve(src).split(path$e.sep);
+  const destArray = path$e.resolve(dest).split(path$e.sep);
+
+  return srcArray.reduce((acc, current, i) => {
+    return acc && destArray[i] === current
+  }, true)
+}
+
+// check if dest exists and is a symlink.
+function checkDest$1 (dest) {
+  let resolvedPath;
+  try {
+    resolvedPath = fs$f.readlinkSync(dest);
+  } catch (err) {
+    if (err.code === 'ENOENT') return notExist$1
+
+    // dest exists and is a regular file or directory, Windows may throw UNKNOWN error.
+    if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return existsReg$1
+
+    throw err
+  }
+  return resolvedPath // dest exists and is a symlink
+}
+
+function pathsAreIdentical$1 (src, dest) {
+  const os = process.platform;
+  const resolvedSrc = path$e.resolve(src);
+  const resolvedDest = path$e.resolve(dest);
+  // case-insensitive paths
+  if (os === 'darwin' || os === 'win32') {
+    return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
+  }
+  return resolvedSrc === resolvedDest
+}
+
+function checkPaths$1 (src, dest) {
+  const resolvedDest = checkDest$1(dest);
+  if (resolvedDest === notExist$1 || resolvedDest === existsReg$1) {
+    if (pathsAreIdentical$1(src, dest)) throw new Error('Source and destination must not be the same.')
+    return resolvedDest
+  } else {
+    // check resolved dest path if dest is a symlink
+    if (pathsAreIdentical$1(src, resolvedDest)) throw new Error('Source and destination must not be the same.')
+    return resolvedDest
+  }
+}
+
+var copySync_1 = copySync$2;
+
+var copySync$1 = {
+  copySync: copySync_1
+};
+
+const u$a = universalify.fromPromise;
+const fs$e = fs$k;
+
+function pathExists$8 (path) {
+  return fs$e.access(path).then(() => true).catch(() => false)
+}
+
+var pathExists_1 = {
+  pathExists: u$a(pathExists$8),
+  pathExistsSync: fs$e.existsSync
+};
+
+const fs$d = gracefulFs;
+const path$d = path__default["default"];
+const mkdirp$1 = mkdirs_1.mkdirs;
+const pathExists$7 = pathExists_1.pathExists;
+const utimes = utimes$1.utimesMillis;
+
+const notExist = Symbol('notExist');
+const existsReg = Symbol('existsReg');
+
+function copy$2 (src, dest, opts, cb) {
+  if (typeof opts === 'function' && !cb) {
+    cb = opts;
+    opts = {};
+  } else if (typeof opts === 'function') {
+    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') {
+    console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+  }
+
+  checkPaths(src, dest, (err, resolvedDest) => {
+    if (err) return cb(err)
+    if (opts.filter) return handleFilter(checkParentDir, resolvedDest, src, dest, opts, cb)
+    return checkParentDir(resolvedDest, src, dest, opts, cb)
+  });
+}
+
+function checkParentDir (resolvedDest, src, dest, opts, cb) {
+  const destParent = path$d.dirname(dest);
+  pathExists$7(destParent, (err, dirExists) => {
+    if (err) return cb(err)
+    if (dirExists) return startCopy(resolvedDest, src, dest, opts, cb)
+    mkdirp$1(destParent, err => {
+      if (err) return cb(err)
+      return startCopy(resolvedDest, src, dest, opts, cb)
+    });
+  });
+}
+
+function startCopy (resolvedDest, src, dest, opts, cb) {
+  if (opts.filter) return handleFilter(getStats, resolvedDest, src, dest, opts, cb)
+  return getStats(resolvedDest, src, dest, opts, cb)
+}
+
+function handleFilter (onInclude, resolvedDest, src, dest, opts, cb) {
+  Promise.resolve(opts.filter(src, dest)).then(include => {
+    if (include) {
+      if (resolvedDest) return onInclude(resolvedDest, src, dest, opts, cb)
+      return onInclude(src, dest, opts, cb)
+    }
+    return cb()
+  }, error => cb(error));
+}
+
+function getStats (resolvedDest, src, dest, opts, cb) {
+  const stat = opts.dereference ? fs$d.stat : fs$d.lstat;
+  stat(src, (err, st) => {
+    if (err) return cb(err)
+
+    if (st.isDirectory()) return onDir(st, resolvedDest, src, dest, opts, cb)
+    else if (st.isFile() ||
+             st.isCharacterDevice() ||
+             st.isBlockDevice()) return onFile(st, resolvedDest, src, dest, opts, cb)
+    else if (st.isSymbolicLink()) return onLink(resolvedDest, src, dest, opts, cb)
+  });
+}
+
+function onFile (srcStat, resolvedDest, src, dest, opts, cb) {
+  if (resolvedDest === notExist) return copyFile(srcStat, src, dest, opts, cb)
+  else if (resolvedDest === existsReg) return mayCopyFile(srcStat, src, dest, opts, cb)
+  return mayCopyFile(srcStat, src, dest, opts, cb)
+}
+
+function mayCopyFile (srcStat, src, dest, opts, cb) {
+  if (opts.overwrite) {
+    fs$d.unlink(dest, err => {
+      if (err) return cb(err)
+      return copyFile(srcStat, src, dest, opts, cb)
+    });
+  } else if (opts.errorOnExist) {
+    return cb(new Error(`'${dest}' already exists`))
+  } else return cb()
+}
+
+function copyFile (srcStat, src, dest, opts, cb) {
+  if (typeof fs$d.copyFile === 'function') {
+    return fs$d.copyFile(src, dest, err => {
+      if (err) return cb(err)
+      return setDestModeAndTimestamps(srcStat, dest, opts, cb)
+    })
+  }
+  return copyFileFallback(srcStat, src, dest, opts, cb)
+}
+
+function copyFileFallback (srcStat, src, dest, opts, cb) {
+  const rs = fs$d.createReadStream(src);
+  rs.on('error', err => cb(err)).once('open', () => {
+    const ws = fs$d.createWriteStream(dest, { mode: srcStat.mode });
+    ws.on('error', err => cb(err))
+      .on('open', () => rs.pipe(ws))
+      .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
+  });
+}
+
+function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
+  fs$d.chmod(dest, srcStat.mode, err => {
+    if (err) return cb(err)
+    if (opts.preserveTimestamps) {
+      return utimes(dest, srcStat.atime, srcStat.mtime, cb)
+    }
+    return cb()
+  });
+}
+
+function onDir (srcStat, resolvedDest, src, dest, opts, cb) {
+  if (resolvedDest === notExist) {
+    if (isSrcSubdir$2(src, dest)) {
+      return cb(new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`))
+    }
+    return mkDirAndCopy(srcStat, src, dest, opts, cb)
+  } else if (resolvedDest === existsReg) {
+    if (isSrcSubdir$2(src, dest)) {
+      return cb(new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`))
+    }
+    return mayCopyDir(src, dest, opts, cb)
+  }
+  return copyDir(src, dest, opts, cb)
+}
+
+function mayCopyDir (src, dest, opts, cb) {
+  fs$d.stat(dest, (err, st) => {
+    if (err) return cb(err)
+    if (!st.isDirectory()) {
+      return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
+    }
+    return copyDir(src, dest, opts, cb)
+  });
+}
+
+function mkDirAndCopy (srcStat, src, dest, opts, cb) {
+  fs$d.mkdir(dest, srcStat.mode, err => {
+    if (err) return cb(err)
+    fs$d.chmod(dest, srcStat.mode, err => {
+      if (err) return cb(err)
+      return copyDir(src, dest, opts, cb)
+    });
+  });
+}
+
+function copyDir (src, dest, opts, cb) {
+  fs$d.readdir(src, (err, items) => {
+    if (err) return cb(err)
+    return copyDirItems(items, src, dest, opts, cb)
+  });
+}
+
+function copyDirItems (items, src, dest, opts, cb) {
+  const item = items.pop();
+  if (!item) return cb()
+  return copyDirItem(items, item, src, dest, opts, cb)
+}
+
+function copyDirItem (items, item, src, dest, opts, cb) {
+  const srcItem = path$d.join(src, item);
+  const destItem = path$d.join(dest, item);
+  checkPaths(srcItem, destItem, (err, resolvedDest) => {
+    if (err) return cb(err)
+    startCopy(resolvedDest, srcItem, destItem, opts, err => {
+      if (err) return cb(err)
+      return copyDirItems(items, src, dest, opts, cb)
+    });
+  });
+}
+
+function onLink (resolvedDest, src, dest, opts, cb) {
+  fs$d.readlink(src, (err, resolvedSrc) => {
+    if (err) return cb(err)
+
+    if (opts.dereference) {
+      resolvedSrc = path$d.resolve(process.cwd(), resolvedSrc);
+    }
+
+    if (resolvedDest === notExist || resolvedDest === existsReg) {
+      // if dest already exists, fs throws error anyway,
+      // so no need to guard against it here.
+      return fs$d.symlink(resolvedSrc, dest, cb)
+    } else {
+      if (opts.dereference) {
+        resolvedDest = path$d.resolve(process.cwd(), resolvedDest);
+      }
+      if (pathsAreIdentical(resolvedSrc, resolvedDest)) return cb()
+
+      // prevent copy if src is a subdir of dest since unlinking
+      // dest in this case would result in removing src contents
+      // and therefore a broken symlink would be created.
+      fs$d.stat(dest, (err, st) => {
+        if (err) return cb(err)
+        if (st.isDirectory() && isSrcSubdir$2(resolvedDest, resolvedSrc)) {
+          return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
+        }
+        return copyLink(resolvedSrc, dest, cb)
+      });
+    }
+  });
+}
+
+function copyLink (resolvedSrc, dest, cb) {
+  fs$d.unlink(dest, err => {
+    if (err) return cb(err)
+    return fs$d.symlink(resolvedSrc, dest, cb)
+  });
+}
+
+// return true if dest is a subdir of src, otherwise false.
+// extract dest base dir and check if that is the same as src basename.
+function isSrcSubdir$2 (src, dest) {
+  const srcArray = path$d.resolve(src).split(path$d.sep);
+  const destArray = path$d.resolve(dest).split(path$d.sep);
+
+  return srcArray.reduce((acc, current, i) => {
+    return acc && destArray[i] === current
+  }, true)
+}
+
+// check if dest exists and is a symlink.
+function checkDest (dest, cb) {
+  fs$d.readlink(dest, (err, resolvedPath) => {
+    if (err) {
+      if (err.code === 'ENOENT') return cb(null, notExist)
+
+      // dest exists and is a regular file or directory, Windows may throw UNKNOWN error.
+      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return cb(null, existsReg)
+
+      return cb(err)
+    }
+    return cb(null, resolvedPath) // dest exists and is a symlink
+  });
+}
+
+function pathsAreIdentical (src, dest) {
+  const os = process.platform;
+  const resolvedSrc = path$d.resolve(src);
+  const resolvedDest = path$d.resolve(dest);
+  // case-insensitive paths
+  if (os === 'darwin' || os === 'win32') {
+    return resolvedSrc.toLowerCase() === resolvedDest.toLowerCase()
+  }
+  return resolvedSrc === resolvedDest
+}
+
+function checkPaths (src, dest, cb) {
+  checkDest(dest, (err, resolvedDest) => {
+    if (err) return cb(err)
+    if (resolvedDest === notExist || resolvedDest === existsReg) {
+      if (pathsAreIdentical(src, dest)) return cb(new Error('Source and destination must not be the same.'))
+      return cb(null, resolvedDest)
+    } else {
+      // check resolved dest path if dest is a symlink
+      if (pathsAreIdentical(src, resolvedDest)) return cb(new Error('Source and destination must not be the same.'))
+      return cb(null, resolvedDest)
+    }
+  });
+}
+
+var copy_1 = copy$2;
+
+const u$9 = universalify.fromCallback;
+var copy$1 = {
+  copy: u$9(copy_1)
+};
+
+const fs$c = gracefulFs;
+const path$c = path__default["default"];
+const assert = assert__default["default"];
+
+const isWindows = (process.platform === 'win32');
+
+function defaults (options) {
+  const methods = [
+    'unlink',
+    'chmod',
+    'stat',
+    'lstat',
+    'rmdir',
+    'readdir'
+  ];
+  methods.forEach(m => {
+    options[m] = options[m] || fs$c[m];
+    m = m + 'Sync';
+    options[m] = options[m] || fs$c[m];
+  });
+
+  options.maxBusyTries = options.maxBusyTries || 3;
+}
+
+function rimraf$1 (p, options, cb) {
+  let busyTries = 0;
+
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+
+  assert(p, 'rimraf: missing path');
+  assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string');
+  assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required');
+  assert(options, 'rimraf: invalid options argument provided');
+  assert.strictEqual(typeof options, 'object', 'rimraf: options should be object');
+
+  defaults(options);
+
+  rimraf_(p, options, function CB (er) {
+    if (er) {
+      if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
+          busyTries < options.maxBusyTries) {
+        busyTries++;
+        const time = busyTries * 100;
+        // try again, with the same exact callback as this one.
+        return setTimeout(() => rimraf_(p, options, CB), time)
+      }
+
+      // already gone
+      if (er.code === 'ENOENT') er = null;
+    }
+
+    cb(er);
+  });
+}
+
+// Two possible strategies.
+// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong.  However, there
+// are likely far more normal files in the world than directories.  This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow.  But until then, YAGNI.
+function rimraf_ (p, options, cb) {
+  assert(p);
+  assert(options);
+  assert(typeof cb === 'function');
+
+  // sunos lets the root user unlink directories, which is... weird.
+  // so we have to lstat here and make sure it's not a dir.
+  options.lstat(p, (er, st) => {
+    if (er && er.code === 'ENOENT') {
+      return cb(null)
+    }
+
+    // Windows can EPERM on stat.  Life is suffering.
+    if (er && er.code === 'EPERM' && isWindows) {
+      return fixWinEPERM(p, options, er, cb)
+    }
+
+    if (st && st.isDirectory()) {
+      return rmdir(p, options, er, cb)
+    }
+
+    options.unlink(p, er => {
+      if (er) {
+        if (er.code === 'ENOENT') {
+          return cb(null)
+        }
+        if (er.code === 'EPERM') {
+          return (isWindows)
+            ? fixWinEPERM(p, options, er, cb)
+            : rmdir(p, options, er, cb)
+        }
+        if (er.code === 'EISDIR') {
+          return rmdir(p, options, er, cb)
+        }
+      }
+      return cb(er)
+    });
+  });
+}
+
+function fixWinEPERM (p, options, er, cb) {
+  assert(p);
+  assert(options);
+  assert(typeof cb === 'function');
+  if (er) {
+    assert(er instanceof Error);
+  }
+
+  options.chmod(p, 0o666, er2 => {
+    if (er2) {
+      cb(er2.code === 'ENOENT' ? null : er);
+    } else {
+      options.stat(p, (er3, stats) => {
+        if (er3) {
+          cb(er3.code === 'ENOENT' ? null : er);
+        } else if (stats.isDirectory()) {
+          rmdir(p, options, er, cb);
+        } else {
+          options.unlink(p, cb);
+        }
+      });
+    }
+  });
+}
+
+function fixWinEPERMSync (p, options, er) {
+  let stats;
+
+  assert(p);
+  assert(options);
+  if (er) {
+    assert(er instanceof Error);
+  }
+
+  try {
+    options.chmodSync(p, 0o666);
+  } catch (er2) {
+    if (er2.code === 'ENOENT') {
+      return
+    } else {
+      throw er
+    }
+  }
+
+  try {
+    stats = options.statSync(p);
+  } catch (er3) {
+    if (er3.code === 'ENOENT') {
+      return
+    } else {
+      throw er
+    }
+  }
+
+  if (stats.isDirectory()) {
+    rmdirSync(p, options, er);
+  } else {
+    options.unlinkSync(p);
+  }
+}
+
+function rmdir (p, options, originalEr, cb) {
+  assert(p);
+  assert(options);
+  if (originalEr) {
+    assert(originalEr instanceof Error);
+  }
+  assert(typeof cb === 'function');
+
+  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+  // if we guessed wrong, and it's not a directory, then
+  // raise the original error.
+  options.rmdir(p, er => {
+    if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
+      rmkids(p, options, cb);
+    } else if (er && er.code === 'ENOTDIR') {
+      cb(originalEr);
+    } else {
+      cb(er);
+    }
+  });
+}
+
+function rmkids (p, options, cb) {
+  assert(p);
+  assert(options);
+  assert(typeof cb === 'function');
+
+  options.readdir(p, (er, files) => {
+    if (er) return cb(er)
+
+    let n = files.length;
+    let errState;
+
+    if (n === 0) return options.rmdir(p, cb)
+
+    files.forEach(f => {
+      rimraf$1(path$c.join(p, f), options, er => {
+        if (errState) {
+          return
+        }
+        if (er) return cb(errState = er)
+        if (--n === 0) {
+          options.rmdir(p, cb);
+        }
+      });
+    });
+  });
+}
+
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+function rimrafSync (p, options) {
+  let st;
+
+  options = options || {};
+  defaults(options);
+
+  assert(p, 'rimraf: missing path');
+  assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string');
+  assert(options, 'rimraf: missing options');
+  assert.strictEqual(typeof options, 'object', 'rimraf: options should be object');
+
+  try {
+    st = options.lstatSync(p);
+  } catch (er) {
+    if (er.code === 'ENOENT') {
+      return
+    }
+
+    // Windows can EPERM on stat.  Life is suffering.
+    if (er.code === 'EPERM' && isWindows) {
+      fixWinEPERMSync(p, options, er);
+    }
+  }
+
+  try {
+    // sunos lets the root user unlink directories, which is... weird.
+    if (st && st.isDirectory()) {
+      rmdirSync(p, options, null);
+    } else {
+      options.unlinkSync(p);
+    }
+  } catch (er) {
+    if (er.code === 'ENOENT') {
+      return
+    } else if (er.code === 'EPERM') {
+      return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+    } else if (er.code !== 'EISDIR') {
+      throw er
+    }
+    rmdirSync(p, options, er);
+  }
+}
+
+function rmdirSync (p, options, originalEr) {
+  assert(p);
+  assert(options);
+  if (originalEr) {
+    assert(originalEr instanceof Error);
+  }
+
+  try {
+    options.rmdirSync(p);
+  } catch (er) {
+    if (er.code === 'ENOTDIR') {
+      throw originalEr
+    } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
+      rmkidsSync(p, options);
+    } else if (er.code !== 'ENOENT') {
+      throw er
+    }
+  }
+}
+
+function rmkidsSync (p, options) {
+  assert(p);
+  assert(options);
+  options.readdirSync(p).forEach(f => rimrafSync(path$c.join(p, f), options));
+
+  // We only end up here once we got ENOTEMPTY at least once, and
+  // at this point, we are guaranteed to have removed all the kids.
+  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+  // try really hard to delete stuff on windows, because it has a
+  // PROFOUNDLY annoying habit of not closing handles promptly when
+  // files are deleted, resulting in spurious ENOTEMPTY errors.
+  const retries = isWindows ? 100 : 1;
+  let i = 0;
+  do {
+    let threw = true;
+    try {
+      const ret = options.rmdirSync(p, options);
+      threw = false;
+      return ret
+    } finally {
+      if (++i < retries && threw) continue // eslint-disable-line
+    }
+  } while (true)
+}
+
+var rimraf_1 = rimraf$1;
+rimraf$1.sync = rimrafSync;
+
+const u$8 = universalify.fromCallback;
+const rimraf = rimraf_1;
+
+var remove$2 = {
+  remove: u$8(rimraf),
+  removeSync: rimraf.sync
+};
+
+const u$7 = universalify.fromCallback;
+const fs$b = require$$1__default["default"];
+const path$b = path__default["default"];
+const mkdir$5 = mkdirs_1;
+const remove$1 = remove$2;
+
+const emptyDir = u$7(function emptyDir (dir, callback) {
+  callback = callback || function () {};
+  fs$b.readdir(dir, (err, items) => {
+    if (err) return mkdir$5.mkdirs(dir, callback)
+
+    items = items.map(item => path$b.join(dir, item));
+
+    deleteItem();
+
+    function deleteItem () {
+      const item = items.pop();
+      if (!item) return callback()
+      remove$1.remove(item, err => {
+        if (err) return callback(err)
+        deleteItem();
+      });
+    }
+  });
+});
+
+function emptyDirSync (dir) {
+  let items;
+  try {
+    items = fs$b.readdirSync(dir);
+  } catch (err) {
+    return mkdir$5.mkdirsSync(dir)
+  }
+
+  items.forEach(item => {
+    item = path$b.join(dir, item);
+    remove$1.removeSync(item);
+  });
+}
+
+var empty = {
+  emptyDirSync,
+  emptydirSync: emptyDirSync,
+  emptyDir,
+  emptydir: emptyDir
+};
+
+const u$6 = universalify.fromCallback;
+const path$a = path__default["default"];
+const fs$a = gracefulFs;
+const mkdir$4 = mkdirs_1;
+const pathExists$6 = pathExists_1.pathExists;
+
+function createFile (file, callback) {
+  function makeFile () {
+    fs$a.writeFile(file, '', err => {
+      if (err) return callback(err)
+      callback();
+    });
+  }
+
+  fs$a.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+    if (!err && stats.isFile()) return callback()
+    const dir = path$a.dirname(file);
+    pathExists$6(dir, (err, dirExists) => {
+      if (err) return callback(err)
+      if (dirExists) return makeFile()
+      mkdir$4.mkdirs(dir, err => {
+        if (err) return callback(err)
+        makeFile();
+      });
+    });
+  });
+}
+
+function createFileSync (file) {
+  let stats;
+  try {
+    stats = fs$a.statSync(file);
+  } catch (e) {}
+  if (stats && stats.isFile()) return
+
+  const dir = path$a.dirname(file);
+  if (!fs$a.existsSync(dir)) {
+    mkdir$4.mkdirsSync(dir);
+  }
+
+  fs$a.writeFileSync(file, '');
+}
+
+var file$1 = {
+  createFile: u$6(createFile),
+  createFileSync
+};
+
+const u$5 = universalify.fromCallback;
+const path$9 = path__default["default"];
+const fs$9 = gracefulFs;
+const mkdir$3 = mkdirs_1;
+const pathExists$5 = pathExists_1.pathExists;
+
+function createLink (srcpath, dstpath, callback) {
+  function makeLink (srcpath, dstpath) {
+    fs$9.link(srcpath, dstpath, err => {
+      if (err) return callback(err)
+      callback(null);
+    });
+  }
+
+  pathExists$5(dstpath, (err, destinationExists) => {
+    if (err) return callback(err)
+    if (destinationExists) return callback(null)
+    fs$9.lstat(srcpath, (err) => {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureLink');
+        return callback(err)
+      }
+
+      const dir = path$9.dirname(dstpath);
+      pathExists$5(dir, (err, dirExists) => {
+        if (err) return callback(err)
+        if (dirExists) return makeLink(srcpath, dstpath)
+        mkdir$3.mkdirs(dir, err => {
+          if (err) return callback(err)
+          makeLink(srcpath, dstpath);
+        });
+      });
+    });
+  });
+}
+
+function createLinkSync (srcpath, dstpath) {
+  const destinationExists = fs$9.existsSync(dstpath);
+  if (destinationExists) return undefined
+
+  try {
+    fs$9.lstatSync(srcpath);
+  } catch (err) {
+    err.message = err.message.replace('lstat', 'ensureLink');
+    throw err
+  }
+
+  const dir = path$9.dirname(dstpath);
+  const dirExists = fs$9.existsSync(dir);
+  if (dirExists) return fs$9.linkSync(srcpath, dstpath)
+  mkdir$3.mkdirsSync(dir);
+
+  return fs$9.linkSync(srcpath, dstpath)
+}
+
+var link$1 = {
+  createLink: u$5(createLink),
+  createLinkSync
+};
+
+const path$8 = path__default["default"];
+const fs$8 = gracefulFs;
+const pathExists$4 = pathExists_1.pathExists;
+
+/**
+ * Function that returns two types of paths, one relative to symlink, and one
+ * relative to the current working directory. Checks if path is absolute or
+ * relative. If the path is relative, this function checks if the path is
+ * relative to symlink or relative to current working directory. This is an
+ * initiative to find a smarter `srcpath` to supply when building symlinks.
+ * This allows you to determine which path to use out of one of three possible
+ * types of source paths. The first is an absolute path. This is detected by
+ * `path.isAbsolute()`. When an absolute path is provided, it is checked to
+ * see if it exists. If it does it's used, if not an error is returned
+ * (callback)/ thrown (sync). The other two options for `srcpath` are a
+ * relative url. By default Node's `fs.symlink` works by creating a symlink
+ * using `dstpath` and expects the `srcpath` to be relative to the newly
+ * created symlink. If you provide a `srcpath` that does not exist on the file
+ * system it results in a broken symlink. To minimize this, the function
+ * checks to see if the 'relative to symlink' source file exists, and if it
+ * does it will use it. If it does not, it checks if there's a file that
+ * exists that is relative to the current working directory, if does its used.
+ * This preserves the expectations of the original fs.symlink spec and adds
+ * the ability to pass in `relative to current working direcotry` paths.
+ */
+
+function symlinkPaths$1 (srcpath, dstpath, callback) {
+  if (path$8.isAbsolute(srcpath)) {
+    return fs$8.lstat(srcpath, (err) => {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureSymlink');
+        return callback(err)
+      }
+      return callback(null, {
+        'toCwd': srcpath,
+        'toDst': srcpath
+      })
+    })
+  } else {
+    const dstdir = path$8.dirname(dstpath);
+    const relativeToDst = path$8.join(dstdir, srcpath);
+    return pathExists$4(relativeToDst, (err, exists) => {
+      if (err) return callback(err)
+      if (exists) {
+        return callback(null, {
+          'toCwd': relativeToDst,
+          'toDst': srcpath
+        })
+      } else {
+        return fs$8.lstat(srcpath, (err) => {
+          if (err) {
+            err.message = err.message.replace('lstat', 'ensureSymlink');
+            return callback(err)
+          }
+          return callback(null, {
+            'toCwd': srcpath,
+            'toDst': path$8.relative(dstdir, srcpath)
+          })
+        })
+      }
+    })
+  }
+}
+
+function symlinkPathsSync$1 (srcpath, dstpath) {
+  let exists;
+  if (path$8.isAbsolute(srcpath)) {
+    exists = fs$8.existsSync(srcpath);
+    if (!exists) throw new Error('absolute srcpath does not exist')
+    return {
+      'toCwd': srcpath,
+      'toDst': srcpath
+    }
+  } else {
+    const dstdir = path$8.dirname(dstpath);
+    const relativeToDst = path$8.join(dstdir, srcpath);
+    exists = fs$8.existsSync(relativeToDst);
+    if (exists) {
+      return {
+        'toCwd': relativeToDst,
+        'toDst': srcpath
+      }
+    } else {
+      exists = fs$8.existsSync(srcpath);
+      if (!exists) throw new Error('relative srcpath does not exist')
+      return {
+        'toCwd': srcpath,
+        'toDst': path$8.relative(dstdir, srcpath)
+      }
+    }
+  }
+}
+
+var symlinkPaths_1 = {
+  symlinkPaths: symlinkPaths$1,
+  symlinkPathsSync: symlinkPathsSync$1
+};
+
+const fs$7 = gracefulFs;
+
+function symlinkType$1 (srcpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback;
+  type = (typeof type === 'function') ? false : type;
+  if (type) return callback(null, type)
+  fs$7.lstat(srcpath, (err, stats) => {
+    if (err) return callback(null, 'file')
+    type = (stats && stats.isDirectory()) ? 'dir' : 'file';
+    callback(null, type);
+  });
+}
+
+function symlinkTypeSync$1 (srcpath, type) {
+  let stats;
+
+  if (type) return type
+  try {
+    stats = fs$7.lstatSync(srcpath);
+  } catch (e) {
+    return 'file'
+  }
+  return (stats && stats.isDirectory()) ? 'dir' : 'file'
+}
+
+var symlinkType_1 = {
+  symlinkType: symlinkType$1,
+  symlinkTypeSync: symlinkTypeSync$1
+};
+
+const u$4 = universalify.fromCallback;
+const path$7 = path__default["default"];
+const fs$6 = gracefulFs;
+const _mkdirs = mkdirs_1;
+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$3 = pathExists_1.pathExists;
+
+function createSymlink (srcpath, dstpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback;
+  type = (typeof type === 'function') ? false : type;
+
+  pathExists$3(dstpath, (err, destinationExists) => {
+    if (err) return callback(err)
+    if (destinationExists) return callback(null)
+    symlinkPaths(srcpath, dstpath, (err, relative) => {
+      if (err) return callback(err)
+      srcpath = relative.toDst;
+      symlinkType(relative.toCwd, type, (err, type) => {
+        if (err) return callback(err)
+        const dir = path$7.dirname(dstpath);
+        pathExists$3(dir, (err, dirExists) => {
+          if (err) return callback(err)
+          if (dirExists) return fs$6.symlink(srcpath, dstpath, type, callback)
+          mkdirs(dir, err => {
+            if (err) return callback(err)
+            fs$6.symlink(srcpath, dstpath, type, callback);
+          });
+        });
+      });
+    });
+  });
+}
+
+function createSymlinkSync (srcpath, dstpath, type) {
+  const destinationExists = fs$6.existsSync(dstpath);
+  if (destinationExists) return undefined
+
+  const relative = symlinkPathsSync(srcpath, dstpath);
+  srcpath = relative.toDst;
+  type = symlinkTypeSync(relative.toCwd, type);
+  const dir = path$7.dirname(dstpath);
+  const exists = fs$6.existsSync(dir);
+  if (exists) return fs$6.symlinkSync(srcpath, dstpath, type)
+  mkdirsSync(dir);
+  return fs$6.symlinkSync(srcpath, dstpath, type)
+}
+
+var symlink$1 = {
+  createSymlink: u$4(createSymlink),
+  createSymlinkSync
+};
+
+const file = file$1;
+const link = link$1;
+const symlink = symlink$1;
+
+var ensure = {
+  // file
+  createFile: file.createFile,
+  createFileSync: file.createFileSync,
+  ensureFile: file.createFile,
+  ensureFileSync: file.createFileSync,
+  // link
+  createLink: link.createLink,
+  createLinkSync: link.createLinkSync,
+  ensureLink: link.createLink,
+  ensureLinkSync: link.createLinkSync,
+  // symlink
+  createSymlink: symlink.createSymlink,
+  createSymlinkSync: symlink.createSymlinkSync,
+  ensureSymlink: symlink.createSymlink,
+  ensureSymlinkSync: symlink.createSymlinkSync
+};
+
+var _fs;
+try {
+  _fs = gracefulFs;
+} catch (_) {
+  _fs = require$$1__default["default"];
+}
+
+function readFile (file, options, callback) {
+  if (callback == null) {
+    callback = options;
+    options = {};
+  }
+
+  if (typeof options === 'string') {
+    options = {encoding: options};
+  }
+
+  options = options || {};
+  var fs = options.fs || _fs;
+
+  var shouldThrow = true;
+  if ('throws' in options) {
+    shouldThrow = options.throws;
+  }
+
+  fs.readFile(file, options, function (err, data) {
+    if (err) return callback(err)
+
+    data = stripBom(data);
+
+    var obj;
+    try {
+      obj = JSON.parse(data, options ? options.reviver : null);
+    } catch (err2) {
+      if (shouldThrow) {
+        err2.message = file + ': ' + err2.message;
+        return callback(err2)
+      } else {
+        return callback(null, null)
+      }
+    }
+
+    callback(null, obj);
+  });
+}
+
+function readFileSync (file, options) {
+  options = options || {};
+  if (typeof options === 'string') {
+    options = {encoding: options};
+  }
+
+  var fs = options.fs || _fs;
+
+  var shouldThrow = true;
+  if ('throws' in options) {
+    shouldThrow = options.throws;
+  }
+
+  try {
+    var content = fs.readFileSync(file, options);
+    content = stripBom(content);
+    return JSON.parse(content, options.reviver)
+  } catch (err) {
+    if (shouldThrow) {
+      err.message = file + ': ' + err.message;
+      throw err
+    } else {
+      return null
+    }
+  }
+}
+
+function stringify (obj, options) {
+  var spaces;
+  var EOL = '\n';
+  if (typeof options === 'object' && options !== null) {
+    if (options.spaces) {
+      spaces = options.spaces;
+    }
+    if (options.EOL) {
+      EOL = options.EOL;
+    }
+  }
+
+  var str = JSON.stringify(obj, options ? options.replacer : null, spaces);
+
+  return str.replace(/\n/g, EOL) + EOL
+}
+
+function writeFile (file, obj, options, callback) {
+  if (callback == null) {
+    callback = options;
+    options = {};
+  }
+  options = options || {};
+  var fs = options.fs || _fs;
+
+  var str = '';
+  try {
+    str = stringify(obj, options);
+  } catch (err) {
+    // Need to return whether a callback was passed or not
+    if (callback) callback(err, null);
+    return
+  }
+
+  fs.writeFile(file, str, options, callback);
+}
+
+function writeFileSync (file, obj, options) {
+  options = options || {};
+  var fs = options.fs || _fs;
+
+  var str = stringify(obj, options);
+  // not sure if fs.writeFileSync returns anything, but just in case
+  return fs.writeFileSync(file, str, options)
+}
+
+function stripBom (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');
+  content = content.replace(/^\uFEFF/, '');
+  return content
+}
+
+var jsonfile$1 = {
+  readFile: readFile,
+  readFileSync: readFileSync,
+  writeFile: writeFile,
+  writeFileSync: writeFileSync
+};
+
+var jsonfile_1 = jsonfile$1;
+
+const u$3 = universalify.fromCallback;
+const jsonFile$3 = jsonfile_1;
+
+var jsonfile = {
+  // jsonfile exports
+  readJson: u$3(jsonFile$3.readFile),
+  readJsonSync: jsonFile$3.readFileSync,
+  writeJson: u$3(jsonFile$3.writeFile),
+  writeJsonSync: jsonFile$3.writeFileSync
+};
+
+const path$6 = path__default["default"];
+const mkdir$2 = mkdirs_1;
+const pathExists$2 = pathExists_1.pathExists;
+const jsonFile$2 = jsonfile;
+
+function outputJson (file, data, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  const dir = path$6.dirname(file);
+
+  pathExists$2(dir, (err, itDoes) => {
+    if (err) return callback(err)
+    if (itDoes) return jsonFile$2.writeJson(file, data, options, callback)
+
+    mkdir$2.mkdirs(dir, err => {
+      if (err) return callback(err)
+      jsonFile$2.writeJson(file, data, options, callback);
+    });
+  });
+}
+
+var outputJson_1 = outputJson;
+
+const fs$5 = gracefulFs;
+const path$5 = path__default["default"];
+const mkdir$1 = mkdirs_1;
+const jsonFile$1 = jsonfile;
+
+function outputJsonSync (file, data, options) {
+  const dir = path$5.dirname(file);
+
+  if (!fs$5.existsSync(dir)) {
+    mkdir$1.mkdirsSync(dir);
+  }
+
+  jsonFile$1.writeJsonSync(file, data, options);
+}
+
+var outputJsonSync_1 = outputJsonSync;
+
+const u$2 = universalify.fromCallback;
+const jsonFile = jsonfile;
+
+jsonFile.outputJson = u$2(outputJson_1);
+jsonFile.outputJsonSync = outputJsonSync_1;
+// aliases
+jsonFile.outputJSON = jsonFile.outputJson;
+jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+jsonFile.writeJSON = jsonFile.writeJson;
+jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+jsonFile.readJSON = jsonFile.readJson;
+jsonFile.readJSONSync = jsonFile.readJsonSync;
+
+var json = jsonFile;
+
+const fs$4 = gracefulFs;
+const path$4 = path__default["default"];
+const copySync = copySync$1.copySync;
+const removeSync = remove$2.removeSync;
+const mkdirpSync = mkdirs_1.mkdirsSync;
+const buffer = buffer$1;
+
+function moveSync (src, dest, options) {
+  options = options || {};
+  const overwrite = options.overwrite || options.clobber || false;
+
+  src = path$4.resolve(src);
+  dest = path$4.resolve(dest);
+
+  if (src === dest) return fs$4.accessSync(src)
+
+  if (isSrcSubdir$1(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
+
+  mkdirpSync(path$4.dirname(dest));
+  tryRenameSync();
+
+  function tryRenameSync () {
+    if (overwrite) {
+      try {
+        return fs$4.renameSync(src, dest)
+      } catch (err) {
+        if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'EPERM') {
+          removeSync(dest);
+          options.overwrite = false; // just overwriteed it, no need to do it again
+          return moveSync(src, dest, options)
+        }
+
+        if (err.code !== 'EXDEV') throw err
+        return moveSyncAcrossDevice(src, dest, overwrite)
+      }
+    } else {
+      try {
+        fs$4.linkSync(src, dest);
+        return fs$4.unlinkSync(src)
+      } catch (err) {
+        if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM' || err.code === 'ENOTSUP') {
+          return moveSyncAcrossDevice(src, dest, overwrite)
+        }
+        throw err
+      }
+    }
+  }
+}
+
+function moveSyncAcrossDevice (src, dest, overwrite) {
+  const stat = fs$4.statSync(src);
+
+  if (stat.isDirectory()) {
+    return moveDirSyncAcrossDevice(src, dest, overwrite)
+  } else {
+    return moveFileSyncAcrossDevice(src, dest, overwrite)
+  }
+}
+
+function moveFileSyncAcrossDevice (src, dest, overwrite) {
+  const BUF_LENGTH = 64 * 1024;
+  const _buff = buffer(BUF_LENGTH);
+
+  const flags = overwrite ? 'w' : 'wx';
+
+  const fdr = fs$4.openSync(src, 'r');
+  const stat = fs$4.fstatSync(fdr);
+  const fdw = fs$4.openSync(dest, flags, stat.mode);
+  let pos = 0;
+
+  while (pos < stat.size) {
+    const bytesRead = fs$4.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs$4.writeSync(fdw, _buff, 0, bytesRead);
+    pos += bytesRead;
+  }
+
+  fs$4.closeSync(fdr);
+  fs$4.closeSync(fdw);
+  return fs$4.unlinkSync(src)
+}
+
+function moveDirSyncAcrossDevice (src, dest, overwrite) {
+  const options = {
+    overwrite: false
+  };
+
+  if (overwrite) {
+    removeSync(dest);
+    tryCopySync();
+  } else {
+    tryCopySync();
+  }
+
+  function tryCopySync () {
+    copySync(src, dest, options);
+    return removeSync(src)
+  }
+}
+
+// return true if dest is a subdir of src, otherwise false.
+// extract dest base dir and check if that is the same as src basename
+function isSrcSubdir$1 (src, dest) {
+  try {
+    return fs$4.statSync(src).isDirectory() &&
+           src !== dest &&
+           dest.indexOf(src) > -1 &&
+           dest.split(path$4.dirname(src) + path$4.sep)[1].split(path$4.sep)[0] === path$4.basename(src)
+  } catch (e) {
+    return false
+  }
+}
+
+var moveSync_1 = {
+  moveSync
+};
+
+const u$1 = universalify.fromCallback;
+const fs$3 = gracefulFs;
+const path$3 = path__default["default"];
+const copy = copy$1.copy;
+const remove = remove$2.remove;
+const mkdirp = mkdirs_1.mkdirp;
+const pathExists$1 = pathExists_1.pathExists;
+
+function move (src, dest, opts, cb) {
+  if (typeof opts === 'function') {
+    cb = opts;
+    opts = {};
+  }
+
+  const overwrite = opts.overwrite || opts.clobber || false;
+
+  src = path$3.resolve(src);
+  dest = path$3.resolve(dest);
+
+  if (src === dest) return fs$3.access(src, cb)
+
+  fs$3.stat(src, (err, st) => {
+    if (err) return cb(err)
+
+    if (st.isDirectory() && isSrcSubdir(src, dest)) {
+      return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`))
+    }
+    mkdirp(path$3.dirname(dest), err => {
+      if (err) return cb(err)
+      return doRename(src, dest, overwrite, cb)
+    });
+  });
+}
+
+function doRename (src, dest, overwrite, cb) {
+  if (overwrite) {
+    return remove(dest, err => {
+      if (err) return cb(err)
+      return rename(src, dest, overwrite, cb)
+    })
+  }
+  pathExists$1(dest, (err, destExists) => {
+    if (err) return cb(err)
+    if (destExists) return cb(new Error('dest already exists.'))
+    return rename(src, dest, overwrite, cb)
+  });
+}
+
+function rename (src, dest, overwrite, cb) {
+  fs$3.rename(src, dest, err => {
+    if (!err) return cb()
+    if (err.code !== 'EXDEV') return cb(err)
+    return moveAcrossDevice(src, dest, overwrite, cb)
+  });
+}
+
+function moveAcrossDevice (src, dest, overwrite, cb) {
+  const opts = {
+    overwrite,
+    errorOnExist: true
+  };
+
+  copy(src, dest, opts, err => {
+    if (err) return cb(err)
+    return remove(src, cb)
+  });
+}
+
+function isSrcSubdir (src, dest) {
+  const srcArray = src.split(path$3.sep);
+  const destArray = dest.split(path$3.sep);
+
+  return srcArray.reduce((acc, current, i) => {
+    return acc && destArray[i] === current
+  }, true)
+}
+
+var move_1 = {
+  move: u$1(move)
+};
+
+const u = universalify.fromCallback;
+const fs$2 = gracefulFs;
+const path$2 = path__default["default"];
+const mkdir = mkdirs_1;
+const pathExists = pathExists_1.pathExists;
+
+function outputFile (file, data, encoding, callback) {
+  if (typeof encoding === 'function') {
+    callback = encoding;
+    encoding = 'utf8';
+  }
+
+  const dir = path$2.dirname(file);
+  pathExists(dir, (err, itDoes) => {
+    if (err) return callback(err)
+    if (itDoes) return fs$2.writeFile(file, data, encoding, callback)
+
+    mkdir.mkdirs(dir, err => {
+      if (err) return callback(err)
+
+      fs$2.writeFile(file, data, encoding, callback);
+    });
+  });
+}
+
+function outputFileSync (file, ...args) {
+  const dir = path$2.dirname(file);
+  if (fs$2.existsSync(dir)) {
+    return fs$2.writeFileSync(file, ...args)
+  }
+  mkdir.mkdirsSync(dir);
+  fs$2.writeFileSync(file, ...args);
+}
+
+var output = {
+  outputFile: u(outputFile),
+  outputFileSync
+};
+
+(function (module) {
+
+	module.exports = Object.assign(
+	  {},
+	  // Export promiseified graceful-fs:
+	  fs$k,
+	  // Export extra methods:
+	  copySync$1,
+	  copy$1,
+	  empty,
+	  ensure,
+	  json,
+	  mkdirs_1,
+	  moveSync_1,
+	  move_1,
+	  output,
+	  pathExists_1,
+	  remove$2
+	);
+
+	// Export fs.promises as a getter property so that we don't trigger
+	// ExperimentalWarning before fs.promises is actually accessed.
+	const fs = require$$1__default["default"];
+	if (Object.getOwnPropertyDescriptor(fs, 'promises')) {
+	  Object.defineProperty(module.exports, 'promises', {
+	    get () { return fs.promises }
+	  });
+	}
+} (lib));
+
+var fs$1 = libExports;
+
+class Compile extends EventEmitter__default["default"] {
+    constructor(args, argv0, dir, debug) {
+        super();
+        if (!args || !args.length || !dir || !argv0) {
+            console.error(argv0, args, dir);
+            throw new Error("Bad args");
+        }
+        const compiler = args.shift();
+        if (compiler === undefined) {
+            console.error(argv0, args, dir);
+            throw new Error("Bad args");
+        }
+        const isClang = compiler.indexOf("clang") !== -1;
+        let output;
+        let outputFileName;
+        let hasDashO = false;
+        let hasDashX = false;
+        let sourceFile;
+        for (let i = 0; i < args.length; ++i) {
+            // console.log(i, args[i]);
+            switch (args[i]) {
+                case "-o": {
+                    hasDashO = true;
+                    output = args[++i];
+                    outputFileName = path__default["default"].basename(output);
+                    args[i] = outputFileName;
+                    break;
+                }
+                case "-MF": {
+                    args.splice(i--, 2);
+                    break;
+                }
+                case "-MMD":
+                case "-MD":
+                case "-MM":
+                case "-M":
+                    args.splice(i--, 1);
+                    continue;
+                case "-MT":
+                    args.splice(i--, 2);
+                    continue;
+                case "-cxx-isystem":
+                case "-isysroot":
+                case "-isystem":
+                case "-I":
+                    args.splice(i--, 2);
+                    break;
+                case "-x":
+                    hasDashX = true;
+                    if (!isClang) {
+                        switch (args[++i]) {
+                            case "c":
+                                args[i] = "cpp-output";
+                                break;
+                            case "c++":
+                                args[i] = "c++-cpp-output";
+                                break;
+                            case "objective-c":
+                                args[i] = "objective-c-output";
+                                break;
+                            case "objective-c++":
+                                args[i] = "objective-c++-cpp-output";
+                                break;
+                        }
+                    }
+                    else {
+                        ++i;
+                    }
+                    break;
+                case "--param":
+                case "-G":
+                case "-T":
+                case "-V":
+                case "-Xanalyzer":
+                case "-Xassembler":
+                case "-Xclang":
+                case "-Xlinker":
+                case "-Xpreprocessor":
+                case "-arch":
+                case "-b":
+                case "-gcc-toolchain":
+                case "-imacros":
+                case "-imultilib":
+                case "-include":
+                case "-iprefix":
+                case "-ivfsoverlay":
+                case "-iwithprefix":
+                case "-iwithprefixbefore":
+                case "-target":
+                    ++i;
+                    break;
+                default:
+                    if (/^-mlinker-version=/.exec(args[i]) || /^-stdlib=/.exec(args[i])) {
+                        args.splice(i--, 1);
+                        break;
+                    }
+                    if (args[i][0] !== "-") {
+                        if (sourceFile) {
+                            console.log("Multiple source files", sourceFile, args[i]);
+                            throw new Error("More than one source file");
+                        }
+                        sourceFile = args[i];
+                        args[i] = path__default["default"].join(dir, "sourcefile");
+                    }
+                    break;
+            }
+        }
+        if (!sourceFile) {
+            throw new Error("No sourcefile");
+        }
+        if (!hasDashX) {
+            if (compiler.indexOf("g++") !== -1 || compiler.indexOf("c++") !== -1) {
+                args.unshift(isClang ? "c++" : "c++-cpp-output");
+            }
+            else {
+                switch (path__default["default"].extname(sourceFile)) {
+                    case ".C":
+                    case ".cc":
+                    case ".cpp":
+                    case ".CPP":
+                    case ".c++":
+                    case ".cp":
+                    case ".cxx":
+                        args.unshift(isClang ? "c++" : "c++-cpp-output");
+                        break;
+                    case ".ii":
+                        args.unshift("c++-cpp-output");
+                        break;
+                    case ".hh":
+                    case ".hpp":
+                    case ".H":
+                        args.unshift("c++-header");
+                        break;
+                    case ".h":
+                        args.unshift("c-header");
+                        break;
+                    case ".c":
+                        args.unshift(isClang ? "c" : "cpp-output");
+                        break;
+                    case ".i":
+                        args.unshift("cpp-output");
+                        break;
+                    case ".m":
+                    case ".mi":
+                        args.unshift(isClang ? "objective-c" : "objective-c-cpp-output");
+                        break;
+                    case ".s":
+                        args.unshift("assembler");
+                        break;
+                    case ".sx":
+                    case ".S":
+                        args.unshift("assembler-with-cpp");
+                        break;
+                    case ".mm":
+                    case ".M":
+                    case ".mii":
+                        args.unshift(isClang ? "objective-c++" : "objective-c++-cpp-output");
+                        break;
+                    default:
+                        throw new Error(`Can't determine source language for file: ${sourceFile}`);
+                }
+            }
+            args.unshift("-x");
+        }
+        if (!isClang) {
+            args.push("-fpreprocessed", "-fdirectives-only"); // this is not good for clang
+        }
+        else {
+            args.push("-Wno-stdlibcxx-not-found");
+        }
+        if (!hasDashO) {
+            const suffix = path__default["default"].extname(sourceFile);
+            outputFileName = output = sourceFile.substring(0, sourceFile.length - suffix.length) + ".o";
+            args.push("-o", outputFileName);
+        }
+        // debug = true;
+        if (debug) {
+            console.log("Calling", argv0, compiler, args.map((x) => '"' + x + '"').join(" "));
+        }
+        if (!fs$1.existsSync("/usr/bin/as")) {
+            this.emit("stderr", "as doesn't exist");
+        }
+        // const env = Object.assign({ TMPDIR: dir, TEMPDIR: dir, TEMP: dir }, process.env);
+        const proc = child_process__default["default"].spawn(compiler, args, {
+            /*env: env, */ cwd: dir // , maxBuffer: 1024 * 1024 * 16
+        });
+        this.proc = proc;
+        proc.stdout.setEncoding("utf8");
+        proc.stderr.setEncoding("utf8");
+        proc.stdout.on("data", (data) => {
+            this.emit("stdout", data);
+        });
+        proc.stderr.on("data", (data) => {
+            this.emit("stderr", data);
+        });
+        proc.on("error", (err) => {
+            this.emit("error", err);
+        });
+        proc.on("exit", (exitCode) => {
+            // try {
+            const files = [];
+            const addDir = (dir, prefix) => {
+                try {
+                    fs$1.readdirSync(dir).forEach((file) => {
+                        if (file === "sourcefile") {
+                            return;
+                        }
+                        try {
+                            assert__default["default"](output !== undefined, "Must have output");
+                            const stat = fs$1.statSync(path__default["default"].join(dir, file));
+                            if (stat.isDirectory()) {
+                                addDir(path__default["default"].join(dir, file), prefix ? prefix + file + "/" : file + "/");
+                            }
+                            else if (stat.isFile()) {
+                                if (file === outputFileName) {
+                                    files.push({ path: output, mapped: path__default["default"].join(prefix, file) });
+                                }
+                                else if (path__default["default"].extname(file) === ".gcno") {
+                                    // console.log("mapping", output, prefix, file);
+                                    files.push({
+                                        path: output.substring(0, output.length - 1) + "gcno",
+                                        mapped: path__default["default"].join(prefix, file)
+                                    });
+                                }
+                                else if (path__default["default"].extname(file) === ".gcda") {
+                                    files.push({
+                                        path: output.substring(0, output.length - 1) + "gcda",
+                                        mapped: path__default["default"].join(prefix, file)
+                                    });
+                                }
+                                else {
+                                    files.push({ path: path__default["default"].join(prefix, file) });
+                                }
+                                if (debug) {
+                                    console.log("Added file", file, files[files.length - 1]);
+                                }
+                            }
+                        }
+                        catch (err) {
+                            /* */
+                        }
+                    });
+                }
+                catch (err) {
+                    console.error("Got an error processing outputs for", sourceFile, err);
+                    assert__default["default"](sourceFile !== undefined, "Must have sourceFile");
+                    const errorExitEvent = {
+                        exitCode: 110,
+                        files: [],
+                        error: err.toString(),
+                        sourceFile
+                    };
+                    this.emit("exit", errorExitEvent);
+                }
+            };
+            if (exitCode === 0) {
+                addDir(dir, dir);
+            }
+            if (exitCode === null) {
+                exitCode = 111;
+            }
+            assert__default["default"](sourceFile !== undefined, "Must have sourceFile4");
+            const exitEvent = { exitCode, files, sourceFile };
+            this.emit("exit", exitEvent);
+        });
+    }
+    kill() {
+        this.proc.kill();
+    }
+}
+// let preproc = fs.readFileSync("/tmp/preproc");
+// let f = new Compile([ "/usr/bin/c++", "-Iclient", "-I3rdparty/json11", "-I3rdparty/wslay/lib/includes", "-I3rdparty/wslay/lib", "-I3rdparty/LUrlParser", "-I3rdparty/tiny-process-library", "-std=c++14", "-Wformat", "-Wall", "-g", "-MD", "-MT", "client/CMakeFiles/fiskc.dir/Config.cpp.o", "-MF", "client/CMakeFiles/fiskc.dir/Config.cpp.o.d", "-o", "client/CMakeFiles/fiskc.dir/Config.cpp.o", "-c", "client/Config.cpp" ], preproc);
+// f.on('stdout', (data) => {
+//     console.log("Got out", data.length);
+// });
+// f.on('stderr', (data) => {
+//     console.log("Got err", data.toString());
+// });
+// f.on('error', error => {
+//     console.log("Got error", error);
+// });
+// f.on('exit', event => {
+//     console.log("Got exit", event);
+// });
+module.exports = Compile;
+
+var posixExports = {};
+var posix$2 = {
+  get exports(){ return posixExports; },
+  set exports(v){ posixExports = v; },
+};
+
+var path$1 = path__default["default"];
+
+
+var IS_LINUX = require$$1__default$1["default"].platform() === 'linux';
+
+
+// Attempt to load the bindings module from various possible locations
+function load_extension() {
+    var ext_dirs = [
+        'build/bindings', 'build/Release', 'out/Release', 'Release',
+        'build/Debug', 'out/Debug',
+    ], i;
+    for (i in ext_dirs) {
+        try {
+            return require(path$1.join(__dirname, '../..', ext_dirs[i],
+                                      'posix.node'));
+
+        } catch (error) {
+            if (!/Cannot find module/.test(error.message)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error("unable to load the node-posix extension module");
+}
+
+var posix$1 = load_extension();
+
+var syslog_constants = {};
+posix$1.update_syslog_constants(syslog_constants);
+
+function syslog_const(value) {
+    if (syslog_constants[value] === undefined) {
+        throw new Error("invalid syslog constant value: " + value);
+    }
+
+    return syslog_constants[value];
+}
+
+function syslog_flags(option, prefix) {
+    prefix = prefix || "";
+    var opt = 0, key, flag;
+    for (key in option) {
+        flag = syslog_const(prefix + key); // checks all flags
+        opt |= option[key] ? flag : 0;
+    }
+    return opt;
+}
+
+posix$2.exports = {
+    getgid: process.getgid,
+    getuid: process.getuid,
+    setgid: process.setgid,
+    setuid: process.setuid,
+
+    chroot: posix$1.chroot,
+    closelog: posix$1.closelog,
+    getegid: posix$1.getegid,
+    geteuid: posix$1.geteuid,
+    getgrnam: posix$1.getgrnam,
+    getpgid: posix$1.getpgid,
+    setpgid: posix$1.setpgid,
+    getppid: posix$1.getppid,
+    getpwnam: posix$1.getpwnam,
+    getrlimit: posix$1.getrlimit,
+    setrlimit: posix$1.setrlimit,
+    setsid: posix$1.setsid,
+
+    openlog: function (ident, option, facility) {
+        return posix$1.openlog(ident, syslog_flags(option),
+                             syslog_const(facility));
+    },
+
+    syslog: function (priority, message) {
+        return posix$1.syslog(syslog_const(priority), message);
+    },
+
+    setlogmask: function (maskpri) {
+        var bits = posix$1.setlogmask(syslog_flags(maskpri, "mask_")), flags = {}, key;
+        for (key in syslog_constants) {
+            if (key.match("^mask_")) {
+                flags[key.substr(5, 10)] = (bits & syslog_constants[key])
+                    ? true : false;
+            }
+        }
+        return flags;
+    },
+
+    // http://pubs.opengroup.org/onlinepubs/007904875/functions/getpgrp.html
+    getpgrp: function () {
+        return posix$1.getpgid(0);
+    },
+
+    seteuid: function (euid) {
+        euid = (typeof (euid) === 'string') ? posix$1.getpwnam(euid).uid : euid;
+        return posix$1.seteuid(euid);
+    },
+
+    setreuid: function (ruid, euid) {
+        ruid = (typeof (ruid) === 'string') ? posix$1.getpwnam(ruid).uid : ruid;
+        euid = (typeof (euid) === 'string') ? posix$1.getpwnam(euid).uid : euid;
+        return posix$1.setreuid(ruid, euid);
+    },
+
+    setegid: function (egid) {
+        egid = (typeof (egid) === 'string') ? posix$1.getgrnam(egid).gid : egid;
+        return posix$1.setegid(egid);
+    },
+
+    setregid: function (rgid, egid) {
+        rgid = (typeof (rgid) === 'string') ? posix$1.getgrnam(rgid).gid : rgid;
+        egid = (typeof (egid) === 'string') ? posix$1.getgrnam(egid).gid : egid;
+        return posix$1.setregid(rgid, egid);
+    },
+
+    gethostname: posix$1.gethostname,
+    sethostname: posix$1.sethostname,
+};
+
+var swap_constants = {};
+
+function swap_const(value) {
+    var constant = swap_constants[value];
+    if (constant === undefined) {
+        throw "invalid swap constant value: " + value;
+    }
+
+    return constant;
+}
+
+function swap_flags(option) {
+    var opt = 0, key, flag;
+    for (key in option) {
+        flag = swap_const(key);  // checks all flags
+        opt |= option[key] ? flag : 0;
+    }
+    return opt;
+}
+
+
+if (IS_LINUX) {
+    posix$1.update_swap_constants(swap_constants);
+    posixExports.swapon = function (path, swapflags) {
+        return posix$1.swapon(path, swap_flags(swapflags));
+    };
+    posixExports.swapoff = posix$1.swapoff;
+}
+
+if ('initgroups' in posix$1) {
+    // initgroups is in SVr4 and 4.3BSD, not POSIX
+    posixExports.initgroups = function (user, group) {
+        var gid = (typeof (group) === 'string') ? posix$1.getgrnam(group).gid : group;
+        return posix$1.initgroups(user, gid);
+    };
+}
+
+/**
+ * Copyright (c) 2014, 2015, 2021 Tim Kuijsten
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+var fs = require$$1__default["default"];
+var path = path__default["default"];
+
+var posix = posixExports;
+
+/**
+ * Change the root directory of the current process. A normal user must be provided
+ * since changing root without dropping privileges makes no sense from a security
+ * point of view.
+ *
+ * @param {String} newRoot  The path to the new root directory for this process.
+ *        The whole path should be owned by the super user and may not be writable
+ *        by the group owner or others.
+ * @param {String|Number} user  The user to switch to after changing the root
+ *        directory. Can be either a name or an id.
+ * @param {String|Number} [group]  The group to switch to after changing the root
+ *        directory. Can be either a name or an id of any group the user belongs to
+ *        (see /etc/groups). Defaults to the users primary group (see /etc/passwd).
+ * @throw if any operation fails
+ */
+var chroot = function chroot(newRoot, user, group) {
+  if (typeof newRoot !== 'string') { throw new TypeError('newRoot must be a string'); }
+  if (typeof user !== 'string' && typeof user !== 'number') { throw new TypeError('user must be a string or a number'); }
+  if (typeof group !== 'undefined') {
+    if (typeof group !== 'string' && typeof group !== 'number') { throw new TypeError('group must be a string or a number'); }
+  }
+
+  if (!(newRoot.length > 0)) { throw new Error('newRoot must contain at least one character'); }
+  if (typeof user === 'string' && !(user.length > 0)) { throw new Error('user must contain at least one character'); }
+
+  if (process.getuid() !== 0 || posix.geteuid() !== 0) {
+    throw new Error('chroot must be called while running as root');
+  }
+
+  var pwd, grp, uid, gid;
+
+  // resolve user to a numeric id
+  try {
+    pwd = posix.getpwnam(user);
+  } catch(err) {
+    throw new Error('user not found: ' + user);
+  }
+
+  uid = pwd.uid;
+  gid = pwd.gid;
+
+  if (typeof group !== 'undefined') {
+    if (typeof group === 'number') {
+      gid = group;
+    } else {
+      // resolve group to a numeric id
+      try {
+        grp = posix.getgrnam(group);
+      } catch(err) {
+        throw new Error('group not found: ' + group);
+      }
+
+      gid = grp.gid;
+    }
+  }
+
+
+  if (typeof uid !== 'number') { throw new TypeError('could not resolve the user to a number'); }
+  if (typeof gid !== 'number') { throw new TypeError('could not resolve the group to a number'); }
+
+  if (!(uid > 0)) { throw new Error('new user can not have user id 0'); }
+  if (!(gid > 0)) { throw new Error('new group can not have group id 0'); }
+
+  // check permissions up to the original root of the file system
+  var rpath = newRoot = fs.realpathSync(newRoot);
+
+  var stats;
+  do {
+    stats = fs.statSync(rpath);
+    if (stats.uid !== 0 || (stats.mode & (fs.constants.S_IWGRP | fs.constants.S_IWOTH)) !== 0) {
+      throw new Error('bad chroot dir ' + rpath + ' owner: ' + stats.uid + ' or permissions: 0' + stats.mode.toString(8));
+    }
+    rpath = path.dirname(rpath);
+  } while (rpath !== '/');
+
+  try {
+    posix.chroot(newRoot);
+  } catch(err) {
+    throw new Error('changing root failed: ' + err.message);
+  }
+  process.chdir('/');
+
+  // PWD might be set in some environments and is part of POSIX
+  if (typeof process.env.PWD !== 'undefined') {
+    process.env.PWD = '/';
+  }
+
+  try {
+    if (typeof group === 'undefined') {
+      // change to the given user and all the groups that it is a member of
+      process.initgroups(uid, gid);
+    } else {
+      // change to the given user and the given group (not all groups the user is member of)
+      process.setgroups([gid]);
+    }
+  } catch(err) {
+    throw new Error('changing groups failed: ' + err.message);
+  }
+
+  process.setgid(gid);
+  process.setuid(uid);
+
+  // try to restore privileges
+  try {
+    posix.setreuid(-1, 0);
+  } catch(err) {
+    // double check real and effective ids of the user and group and supplemental groups
+    var ids = [process.getuid(), process.getgid(), posix.geteuid(), posix.getegid()];
+    Array.prototype.push.apply(ids, process.getgroups());
+
+    // if none of the ids is zero, privileges are successfully dropped 
+    if (!~ids.indexOf(0)) {
+      // success
+      return;
+    }
+  }
+
+  throw new Error('unable to drop privileges');
+};
+
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (isConstructorOrProto(o, key)) return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
+
+        var key = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key)) return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+
+function isConstructorOrProto (obj, key) {
+    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+}
+
+const argv = minimist(process.argv.slice(2));
+function send(message) {
+    try {
+        assert__default["default"](process.send, "Must have process.send");
+        process.send(message);
+    }
+    catch (err) {
+        console.error(`Couldn't send message ${message.type}. Going down`, err);
+        process.exit();
+    }
+}
+process.on("unhandledRejection", (reason, p) => {
+    send({ type: "error", message: `Unhandled rejection at: Promise ${p} reason: ${reason === null || reason === void 0 ? void 0 : reason.stack}` });
+    console.error("Unhandled rejection at: Promise", p, "reason:", reason === null || reason === void 0 ? void 0 : reason.stack);
+});
+process.on("uncaughtException", (err) => {
+    send({ type: "error", message: `Uncaught exception ${err.stack} ${err.toString()}` });
+    console.error("Uncaught exception", err);
+});
+// let pwd;
+try {
+    console.log("Chrooting to", argv.root);
+    chroot(argv.root, argv.user || "root");
+}
+catch (err) {
+    console.error("Changing root or user failed", err);
+    process.exit(1);
+}
+// if (pwd) {
+//     process.setgid(pwd.gid);
+//     process.setuid(pwd.uid);
+// }
+process.on("error", (error) => {
+    console.error(`Got process error ${error} ${JSON.stringify(argv)}. Going down`);
+    process.exit();
+});
+const libDirs = [];
+const mac = require$$1__default$1["default"].type() === "Darwin";
+function isLibrary(file) {
+    if (file === "ld.so.conf" || file === "ld.so.cache") {
+        return false;
+    }
+    const suffix = path__default["default"].extname(file);
+    if (mac) {
+        return suffix === ".dylib";
+    }
+    // console.log("got file", suffix, file);
+    if (suffix === ".so") {
+        return true;
+    }
+    return file.indexOf(".so.") !== -1;
+}
+function findLibraries(dir) {
+    const files = require$$1__default["default"].readdirSync(dir);
+    // console.log("findLibraries", dir, files.length);
+    let found = false;
+    files.forEach((file) => {
+        let stat;
+        try {
+            stat = require$$1__default["default"].statSync(path__default["default"].join(dir, file));
+        }
+        catch (err) {
+            console.error("Got error", err);
+            return;
+        }
+        if (stat.isDirectory()) {
+            findLibraries(path__default["default"].join(dir, file));
+        }
+        else if (!found && stat.isFile() && isLibrary(file)) {
+            found = true;
+            libDirs.push(dir);
+        }
+    });
+}
+findLibraries("/");
+if (argv.debug) {
+    console.log("Got lib directories", argv.root, libDirs);
+}
+if (libDirs.length) {
+    process.env[mac ? "DYLD_LIBRARY_PATH" : "LD_LIBRARY_PATH"] = libDirs.join(":");
+}
+setTimeout(() => {
+    // hack
+    try {
+        send({ type: "ready" });
+    }
+    catch (err) {
+        console.error("Couldn't send ready. Going down");
+        process.exit();
+    }
+}, 1000);
+const compiles = new Map();
+let destroying = false;
+process.on("message", (msg) => {
+    switch (msg.type) {
+        case "destroy":
+            if (!compiles.size) {
+                process.exit();
+            }
+            else {
+                destroying = true;
+            }
+            break;
+        case "setDebug":
+            if (msg.debug) {
+                argv.debug = true;
+            }
+            else {
+                delete argv.debug;
+            }
+            console.log("set debug to", msg.debug, "for", argv.root);
+            break;
+        case "cancel": {
+            const c = compiles.get(msg.id);
+            if (c) {
+                c.kill();
+            }
+            break;
+        }
+        case "compile":
+            try {
+                // console.log("compiling for );
+                if (argv.debug) {
+                    console.log("Creating new compile", msg.commandLine, msg.argv0, msg.dir);
+                }
+                const compile = new Compile(msg.commandLine, msg.argv0, msg.dir, argv.debug);
+                // console.log("running thing", msg.commandLine);
+                compile.on("stdout", (data) => send({ type: "compileStdOut", id: msg.id, data: data }));
+                compile.on("stderr", (data) => send({ type: "compileStdErr", id: msg.id, data: data }));
+                compile.on("exit", (event) => {
+                    compiles.delete(msg.id);
+                    if ("error" in event) {
+                        send({
+                            type: "compileFinished",
+                            success: false,
+                            error: event.error,
+                            id: msg.id,
+                            files: event.files,
+                            exitCode: event.exitCode,
+                            sourceFile: event.sourceFile
+                        });
+                    }
+                    else {
+                        send({
+                            type: "compileFinished",
+                            success: true,
+                            id: msg.id,
+                            files: event.files,
+                            exitCode: event.exitCode,
+                            sourceFile: event.sourceFile
+                        });
+                    }
+                    if (destroying && !compiles.size) {
+                        process.exit();
+                    }
+                });
+                compiles.set(msg.id, compile);
+            }
+            catch (err) {
+                compiles.delete(msg.id);
+                send({
+                    type: "compileFinished",
+                    success: false,
+                    id: msg.id,
+                    files: [],
+                    exitCode: -1,
+                    error: err.toString()
+                });
+            }
+            break;
+    }
+});
+//# sourceMappingURL=VM_runtime.js.map