@andersbakken/fisk 3.4.104 → 3.5.0

package/dist/fisk-daemon.js

@@ -1,4159 +0,0 @@
-'use strict';
-
-var EventEmitter = require('events');
-var fs = require('fs');
-var constants = require('constants');
-var require$$0 = require('stream');
-var util = require('util');
-var assert = require('assert');
-var path = require('path');
-var os = require('os');
-var net = require('net');
-var require$$0$1 = require('module');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var constants__default = /*#__PURE__*/_interopDefaultLegacy(constants);
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
-var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-var net__default = /*#__PURE__*/_interopDefaultLegacy(net);
-var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
-
-const Constants = {
-    // client codes
-    get AcquireCppSlot() {
-        return 1;
-    },
-    get AcquireCompileSlot() {
-        return 2;
-    },
-    get ReleaseCppSlot() {
-        return 3;
-    },
-    get ReleaseCompileSlot() {
-        return 4;
-    },
-    get JSON() {
-        return 5;
-    },
-    // daemon codes
-    get CppSlotAcquired() {
-        return 10;
-    },
-    get CompileSlotAcquired() {
-        return 11;
-    },
-    get JSONResponse() {
-        return 12;
-    }
-};
-
-class ClientBuffer {
-    constructor() {
-        this.buffers = [];
-        this.offset = 0;
-    }
-    write(buffer) {
-        this.buffers.push(buffer);
-        // console.log("write", buffer.length, this.buffers.length, this.available);
-    }
-    peek() {
-        if (!this.available) {
-            throw new Error("No data available");
-        }
-        return this.buffers[0][this.offset];
-    }
-    read(len) {
-        if (!len) {
-            throw new Error("Don't be a tool");
-        }
-        if (len > this.available) {
-            throw new Error("We don't have this many bytes available " + len + ">" + this.available);
-        }
-        // console.log("read", len, this.available);
-        let ret;
-        if (this.buffers[0].length - this.offset >= len) {
-            // buffers[0] is enough
-            const buf = this.buffers[0];
-            if (buf.length - this.offset === len) {
-                ret = this.offset ? buf.slice(this.offset) : buf;
-                this.offset = 0;
-                this.buffers.splice(0, 1);
-                return ret;
-            }
-            ret = buf.slice(this.offset, this.offset + len);
-            this.offset += len;
-            return ret;
-        }
-        ret = Buffer.allocUnsafe(len);
-        let retOffset = 0;
-        this.buffers[0].copy(ret, 0, this.offset);
-        retOffset += this.buffers[0].length - this.offset;
-        this.offset = 0;
-        this.buffers.splice(0, 1);
-        while (retOffset < len) {
-            const needed = len - retOffset;
-            const buf = this.buffers[0];
-            if (buf.length <= needed) {
-                this.buffers[0].copy(ret, retOffset);
-                retOffset += this.buffers[0].length;
-                this.buffers.splice(0, 1);
-            }
-            else {
-                this.buffers[0].copy(ret, retOffset, 0, needed);
-                retOffset += needed;
-                this.offset = needed;
-            }
-        }
-        return ret;
-    }
-    get available() {
-        return this.buffers.reduce((total, buf) => total + buf.length, 0) - this.offset;
-    }
-}
-
-class Compile extends EventEmitter__default["default"] {
-    constructor(conn, id, option) {
-        super();
-        this.debug = Boolean(option("debug"));
-        this.id = id;
-        this.connection = conn;
-        this.buffer = new ClientBuffer();
-        this.messageLength = 0;
-        this.pid = undefined;
-        this.connection.on("data", this._onData.bind(this));
-        this.connection.on("end", () => {
-            // console.log("connection ended", id);
-            this.emit("end");
-        });
-        this.connection.on("error", (err) => {
-            // console.log("connection error", id, err);
-            this.emit("error", err);
-        });
-    }
-    send(message) {
-        if (this.debug) {
-            console.log("Compile::send", message);
-        }
-        try {
-            if (typeof message === "number") {
-                this.connection.write(Buffer.from([message]));
-            }
-            else {
-                const msg = Buffer.from(JSON.stringify(message), "utf8");
-                const header = Buffer.allocUnsafe(5);
-                header.writeUInt8(Constants.JSONResponse, 0);
-                header.writeUInt32BE(msg.length, 1);
-                if (this.debug) {
-                    console.log("Compile::send header", header, Constants.JSONResponse);
-                }
-                this.connection.write(header);
-                this.connection.write(msg);
-            }
-        }
-        catch (err) {
-            console.error("Got error sending message", err);
-        }
-    }
-    _onData(data) {
-        // console.log("got data", data.length);
-        this.buffer.write(data);
-        let available = this.buffer.available;
-        if (this.debug) {
-            console.log("Compile::_onData", "id", this.id, "pid", this.pid, data, "available", available, this.messageLength);
-        }
-        if (!this.pid) {
-            if (available < 4) {
-                return;
-            }
-            const pidBuffer = this.buffer.read(4);
-            available -= 4;
-            this.pid = pidBuffer.readUInt32BE();
-            if (this.debug) {
-                console.log("Compile::_onData got pid", "id", this.id, "pid", this.pid);
-            }
-        }
-        const emit = (type) => {
-            if (this.debug) {
-                console.log("Compile::_onData::emit", type, available);
-            }
-            const read = this.buffer.read(1);
-            if (this.debug) {
-                console.log("Discarded", read);
-            }
-            --available;
-            this.emit(type);
-        };
-        while (available) {
-            if (!this.messageLength) {
-                if (this.debug) {
-                    console.log("peeking", this.buffer.peek());
-                }
-                switch (this.buffer.peek()) {
-                    case Constants.AcquireCppSlot:
-                        emit("acquireCppSlot");
-                        continue;
-                    case Constants.AcquireCompileSlot:
-                        emit("acquireCompileSlot");
-                        continue;
-                    case Constants.ReleaseCppSlot:
-                        emit("releaseCppSlot");
-                        continue;
-                    case Constants.ReleaseCompileSlot:
-                        emit("releaseCompileSlot");
-                        continue;
-                    case Constants.JSON:
-                        if (available < 5) {
-                            break;
-                        }
-                        this.buffer.read(1);
-                        this.messageLength = this.buffer.read(4).readUInt32BE();
-                        available -= 5;
-                        break;
-                    default:
-                        console.error("Bad data", this.buffer.peek(), "available", available);
-                        throw new Error("Got unexpected type " + this.buffer.peek());
-                }
-            }
-            if (!this.messageLength || this.messageLength > available) {
-                // console.log("Still waiting on data", this.messageLength, this.buffer.available);
-                break;
-            }
-            const raw = this.buffer.read(this.messageLength);
-            available -= this.messageLength;
-            this.messageLength = 0;
-            try {
-                const msg = JSON.parse(raw.toString("utf8"));
-                if (this.debug) {
-                    console.log("Got json message", msg);
-                }
-                // console.log("Got message", msg);
-                this.emit(msg.type, msg);
-            }
-            catch (err) {
-                console.error("Bad JSON received", err);
-                this.connection.destroy();
-                break;
-            }
-        }
-    }
-}
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire (target) {
-	throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
-}
-
-var 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 })
-};
-
-var 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 universalify = {
-	fromCallback: fromCallback,
-	fromPromise: fromPromise
-};
-
-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 = patch;
-
-function patch (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__default["default"].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__default["default"].O_WRONLY | constants__default["default"].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__default["default"].O_WRONLY | constants__default["default"].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__default["default"].hasOwnProperty("O_SYMLINK") && fs.futimes) {
-      fs.lutimes = function (path, at, mt, cb) {
-        fs.open(path, constants__default["default"].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__default["default"].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["default"].Stream;
-
-var legacyStreams = legacy;
-
-function legacy (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;
-
-var getPrototypeOf = Object.getPrototypeOf || function (obj) {
-  return obj.__proto__
-};
-
-function clone (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 gracefulFs = createCommonjsModule(function (module) {
-/* 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__default["default"].debuglog)
-  debug = util__default["default"].debuglog('gfs4');
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
-  debug = function() {
-    var m = util__default["default"].format.apply(util__default["default"], arguments);
-    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
-    console.error(m);
-  };
-
-// Once time initialization
-if (!fs__default["default"][gracefulQueue]) {
-  // This queue can be shared by multiple loaded instances
-  var queue = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs__default["default"], 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__default["default"].close = (function (fs$close) {
-    function close (fd, cb) {
-      return fs$close.call(fs__default["default"], 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__default["default"].close);
-
-  fs__default["default"].closeSync = (function (fs$closeSync) {
-    function closeSync (fd) {
-      // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs__default["default"], arguments);
-      resetQueue();
-    }
-
-    Object.defineProperty(closeSync, previousSymbol, {
-      value: fs$closeSync
-    });
-    return closeSync
-  })(fs__default["default"].closeSync);
-
-  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-    process.on('exit', function() {
-      debug(fs__default["default"][gracefulQueue]);
-      assert__default["default"].equal(fs__default["default"][gracefulQueue].length, 0);
-    });
-  }
-}
-
-if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs__default["default"][gracefulQueue]);
-}
-
-module.exports = patch(clone_1(fs__default["default"]));
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs__default["default"].__patched) {
-    module.exports = patch(fs__default["default"]);
-    fs__default["default"].__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 = legacyStreams(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__default["default"][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__default["default"][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__default["default"][gracefulQueue][i].length > 2) {
-      fs__default["default"][gracefulQueue][i][3] = now; // startTime
-      fs__default["default"][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__default["default"][gracefulQueue].length === 0)
-    return
-
-  var elem = fs__default["default"][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__default["default"][gracefulQueue].push(elem);
-    }
-  }
-
-  // schedule our next run if one isn't already scheduled
-  if (retryTimer === undefined) {
-    retryTimer = setTimeout(retry, 0);
-  }
-}
-});
-
-var fs_1 = createCommonjsModule(function (module, 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 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 gracefulFs[key] === 'function'
-});
-
-// Export all keys:
-Object.keys(gracefulFs).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] = gracefulFs[key];
-});
-
-// Universalify async methods:
-api.forEach(method => {
-  exports[method] = u(gracefulFs[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 gracefulFs.exists(filename, callback)
-  }
-  return new Promise(resolve => {
-    return gracefulFs.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 gracefulFs.read(fd, buffer, offset, length, position, callback)
-  }
-  return new Promise((resolve, reject) => {
-    gracefulFs.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 gracefulFs.write(fd, buffer, ...args)
-  }
-
-  return new Promise((resolve, reject) => {
-    gracefulFs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
-      if (err) return reject(err)
-      resolve({ bytesWritten, buffer });
-    });
-  })
-};
-});
-
-// get drive on windows
-function getRootPath (p) {
-  p = path__default["default"].normalize(path__default["default"].resolve(p)).split(path__default["default"].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 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 || gracefulFs;
-
-  if (mode === undefined) {
-    mode = o777$1 & (~process.umask());
-  }
-  if (!made) made = null;
-
-  callback = callback || function () {};
-  p = path__default["default"].resolve(p);
-
-  xfs.mkdir(p, mode, er => {
-    if (!er) {
-      made = made || p;
-      return callback(null, made)
-    }
-    switch (er.code) {
-      case 'ENOENT':
-        if (path__default["default"].dirname(p) === p) return callback(er)
-        mkdirs$2(path__default["default"].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 invalidWin32Path = win32.invalidWin32Path;
-
-const o777 = parseInt('0777', 8);
-
-function mkdirsSync$1 (p, opts, made) {
-  if (!opts || typeof opts !== 'object') {
-    opts = { mode: opts };
-  }
-
-  let mode = opts.mode;
-  const xfs = opts.fs || gracefulFs;
-
-  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__default["default"].resolve(p);
-
-  try {
-    xfs.mkdirSync(p, mode);
-    made = made || p;
-  } catch (err0) {
-    if (err0.code === 'ENOENT') {
-      if (path__default["default"].dirname(p) === p) throw err0
-      made = mkdirsSync$1(path__default["default"].dirname(p), opts, made);
-      mkdirsSync$1(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$1;
-
-const u$b = universalify.fromCallback;
-const mkdirs$1 = u$b(mkdirs_1$1);
-
-
-var mkdirs_1 = {
-  mkdirs: mkdirs$1,
-  mkdirsSync: mkdirsSync_1,
-  // alias
-  mkdirp: mkdirs$1,
-  mkdirpSync: mkdirsSync_1,
-  ensureDir: mkdirs$1,
-  ensureDirSync: mkdirsSync_1
-};
-
-// HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
-function hasMillisResSync () {
-  let tmpfile = path__default["default"].join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path__default["default"].join(os__default["default"].tmpdir(), tmpfile);
-
-  // 550 millis past UNIX epoch
-  const d = new Date(1435410243862);
-  gracefulFs.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141');
-  const fd = gracefulFs.openSync(tmpfile, 'r+');
-  gracefulFs.futimesSync(fd, d, d);
-  gracefulFs.closeSync(fd);
-  return gracefulFs.statSync(tmpfile).mtime > 1435410243000
-}
-
-function hasMillisRes (callback) {
-  let tmpfile = path__default["default"].join('millis-test' + Date.now().toString() + Math.random().toString().slice(2));
-  tmpfile = path__default["default"].join(os__default["default"].tmpdir(), tmpfile);
-
-  // 550 millis past UNIX epoch
-  const d = new Date(1435410243862);
-  gracefulFs.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
-    if (err) return callback(err)
-    gracefulFs.open(tmpfile, 'r+', (err, fd) => {
-      if (err) return callback(err)
-      gracefulFs.futimes(fd, d, d, err => {
-        if (err) return callback(err)
-        gracefulFs.close(fd, err => {
-          if (err) return callback(err)
-          gracefulFs.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)
-  gracefulFs.open(path, 'r+', (err, fd) => {
-    if (err) return callback(err)
-    gracefulFs.futimes(fd, atime, mtime, futimesErr => {
-      gracefulFs.close(fd, closeErr => {
-        if (callback) callback(futimesErr || closeErr);
-      });
-    });
-  });
-}
-
-function utimesMillisSync (path, atime, mtime) {
-  const fd = gracefulFs.openSync(path, 'r+');
-  gracefulFs.futimesSync(fd, atime, mtime);
-  return gracefulFs.closeSync(fd)
-}
-
-var utimes$1 = {
-  hasMillisRes,
-  hasMillisResSync,
-  timeRemoveMillis,
-  utimesMillis,
-  utimesMillisSync
-};
-
-/* eslint-disable node/no-deprecated-api */
-var buffer = function (size) {
-  if (typeof Buffer.allocUnsafe === 'function') {
-    try {
-      return Buffer.allocUnsafe(size)
-    } catch (e) {
-      return new Buffer(size)
-    }
-  }
-  return new Buffer(size)
-};
-
-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__default["default"].dirname(dest);
-  if (!gracefulFs.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 ? gracefulFs.statSync : gracefulFs.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) {
-    gracefulFs.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 gracefulFs.copyFileSync === 'function') {
-    gracefulFs.copyFileSync(src, dest);
-    gracefulFs.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(BUF_LENGTH);
-
-  const fdr = gracefulFs.openSync(src, 'r');
-  const fdw = gracefulFs.openSync(dest, 'w', srcStat.mode);
-  let pos = 0;
-
-  while (pos < srcStat.size) {
-    const bytesRead = gracefulFs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    gracefulFs.writeSync(fdw, _buff, 0, bytesRead);
-    pos += bytesRead;
-  }
-
-  if (opts.preserveTimestamps) gracefulFs.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-
-  gracefulFs.closeSync(fdr);
-  gracefulFs.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 (!gracefulFs.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) {
-  gracefulFs.mkdirSync(dest, srcStat.mode);
-  gracefulFs.chmodSync(dest, srcStat.mode);
-  return copyDir$1(src, dest, opts)
-}
-
-function copyDir$1 (src, dest, opts) {
-  gracefulFs.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
-}
-
-function copyDirItem$1 (item, src, dest, opts) {
-  const srcItem = path__default["default"].join(src, item);
-  const destItem = path__default["default"].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 = gracefulFs.readlinkSync(src);
-
-  if (opts.dereference) {
-    resolvedSrc = path__default["default"].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 gracefulFs.symlinkSync(resolvedSrc, dest)
-  } else {
-    if (opts.dereference) {
-      resolvedDest = path__default["default"].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 (gracefulFs.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) {
-  gracefulFs.unlinkSync(dest);
-  return gracefulFs.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__default["default"].resolve(src).split(path__default["default"].sep);
-  const destArray = path__default["default"].resolve(dest).split(path__default["default"].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 = gracefulFs.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__default["default"].resolve(src);
-  const resolvedDest = path__default["default"].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;
-
-
-function pathExists$8 (path) {
-  return fs_1.access(path).then(() => true).catch(() => false)
-}
-
-var pathExists_1 = {
-  pathExists: u$a(pathExists$8),
-  pathExistsSync: fs_1.existsSync
-};
-
-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__default["default"].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 ? gracefulFs.stat : gracefulFs.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) {
-    gracefulFs.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 gracefulFs.copyFile === 'function') {
-    return gracefulFs.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 = gracefulFs.createReadStream(src);
-  rs.on('error', err => cb(err)).once('open', () => {
-    const ws = gracefulFs.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) {
-  gracefulFs.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) {
-  gracefulFs.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) {
-  gracefulFs.mkdir(dest, srcStat.mode, err => {
-    if (err) return cb(err)
-    gracefulFs.chmod(dest, srcStat.mode, err => {
-      if (err) return cb(err)
-      return copyDir(src, dest, opts, cb)
-    });
-  });
-}
-
-function copyDir (src, dest, opts, cb) {
-  gracefulFs.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__default["default"].join(src, item);
-  const destItem = path__default["default"].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) {
-  gracefulFs.readlink(src, (err, resolvedSrc) => {
-    if (err) return cb(err)
-
-    if (opts.dereference) {
-      resolvedSrc = path__default["default"].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 gracefulFs.symlink(resolvedSrc, dest, cb)
-    } else {
-      if (opts.dereference) {
-        resolvedDest = path__default["default"].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.
-      gracefulFs.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) {
-  gracefulFs.unlink(dest, err => {
-    if (err) return cb(err)
-    return gracefulFs.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__default["default"].resolve(src).split(path__default["default"].sep);
-  const destArray = path__default["default"].resolve(dest).split(path__default["default"].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) {
-  gracefulFs.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__default["default"].resolve(src);
-  const resolvedDest = path__default["default"].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 isWindows = (process.platform === 'win32');
-
-function defaults (options) {
-  const methods = [
-    'unlink',
-    'chmod',
-    'stat',
-    'lstat',
-    'rmdir',
-    'readdir'
-  ];
-  methods.forEach(m => {
-    options[m] = options[m] || gracefulFs[m];
-    m = m + 'Sync';
-    options[m] = options[m] || gracefulFs[m];
-  });
-
-  options.maxBusyTries = options.maxBusyTries || 3;
-}
-
-function rimraf (p, options, cb) {
-  let busyTries = 0;
-
-  if (typeof options === 'function') {
-    cb = options;
-    options = {};
-  }
-
-  assert__default["default"](p, 'rimraf: missing path');
-  assert__default["default"].strictEqual(typeof p, 'string', 'rimraf: path should be a string');
-  assert__default["default"].strictEqual(typeof cb, 'function', 'rimraf: callback function required');
-  assert__default["default"](options, 'rimraf: invalid options argument provided');
-  assert__default["default"].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__default["default"](p);
-  assert__default["default"](options);
-  assert__default["default"](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__default["default"](p);
-  assert__default["default"](options);
-  assert__default["default"](typeof cb === 'function');
-  if (er) {
-    assert__default["default"](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__default["default"](p);
-  assert__default["default"](options);
-  if (er) {
-    assert__default["default"](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__default["default"](p);
-  assert__default["default"](options);
-  if (originalEr) {
-    assert__default["default"](originalEr instanceof Error);
-  }
-  assert__default["default"](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__default["default"](p);
-  assert__default["default"](options);
-  assert__default["default"](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(path__default["default"].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__default["default"](p, 'rimraf: missing path');
-  assert__default["default"].strictEqual(typeof p, 'string', 'rimraf: path should be a string');
-  assert__default["default"](options, 'rimraf: missing options');
-  assert__default["default"].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__default["default"](p);
-  assert__default["default"](options);
-  if (originalEr) {
-    assert__default["default"](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__default["default"](p);
-  assert__default["default"](options);
-  options.readdirSync(p).forEach(f => rimrafSync(path__default["default"].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;
-rimraf.sync = rimrafSync;
-
-const u$8 = universalify.fromCallback;
-
-
-var remove$1 = {
-  remove: u$8(rimraf_1),
-  removeSync: rimraf_1.sync
-};
-
-const u$7 = universalify.fromCallback;
-
-
-
-
-
-const emptyDir = u$7(function emptyDir (dir, callback) {
-  callback = callback || function () {};
-  fs__default["default"].readdir(dir, (err, items) => {
-    if (err) return mkdirs_1.mkdirs(dir, callback)
-
-    items = items.map(item => path__default["default"].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__default["default"].readdirSync(dir);
-  } catch (err) {
-    return mkdirs_1.mkdirsSync(dir)
-  }
-
-  items.forEach(item => {
-    item = path__default["default"].join(dir, item);
-    remove$1.removeSync(item);
-  });
-}
-
-var empty = {
-  emptyDirSync,
-  emptydirSync: emptyDirSync,
-  emptyDir,
-  emptydir: emptyDir
-};
-
-const u$6 = universalify.fromCallback;
-
-
-
-const pathExists$6 = pathExists_1.pathExists;
-
-function createFile (file, callback) {
-  function makeFile () {
-    gracefulFs.writeFile(file, '', err => {
-      if (err) return callback(err)
-      callback();
-    });
-  }
-
-  gracefulFs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
-    if (!err && stats.isFile()) return callback()
-    const dir = path__default["default"].dirname(file);
-    pathExists$6(dir, (err, dirExists) => {
-      if (err) return callback(err)
-      if (dirExists) return makeFile()
-      mkdirs_1.mkdirs(dir, err => {
-        if (err) return callback(err)
-        makeFile();
-      });
-    });
-  });
-}
-
-function createFileSync (file) {
-  let stats;
-  try {
-    stats = gracefulFs.statSync(file);
-  } catch (e) {}
-  if (stats && stats.isFile()) return
-
-  const dir = path__default["default"].dirname(file);
-  if (!gracefulFs.existsSync(dir)) {
-    mkdirs_1.mkdirsSync(dir);
-  }
-
-  gracefulFs.writeFileSync(file, '');
-}
-
-var file = {
-  createFile: u$6(createFile),
-  createFileSync
-};
-
-const u$5 = universalify.fromCallback;
-
-
-
-const pathExists$5 = pathExists_1.pathExists;
-
-function createLink (srcpath, dstpath, callback) {
-  function makeLink (srcpath, dstpath) {
-    gracefulFs.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)
-    gracefulFs.lstat(srcpath, (err) => {
-      if (err) {
-        err.message = err.message.replace('lstat', 'ensureLink');
-        return callback(err)
-      }
-
-      const dir = path__default["default"].dirname(dstpath);
-      pathExists$5(dir, (err, dirExists) => {
-        if (err) return callback(err)
-        if (dirExists) return makeLink(srcpath, dstpath)
-        mkdirs_1.mkdirs(dir, err => {
-          if (err) return callback(err)
-          makeLink(srcpath, dstpath);
-        });
-      });
-    });
-  });
-}
-
-function createLinkSync (srcpath, dstpath) {
-  const destinationExists = gracefulFs.existsSync(dstpath);
-  if (destinationExists) return undefined
-
-  try {
-    gracefulFs.lstatSync(srcpath);
-  } catch (err) {
-    err.message = err.message.replace('lstat', 'ensureLink');
-    throw err
-  }
-
-  const dir = path__default["default"].dirname(dstpath);
-  const dirExists = gracefulFs.existsSync(dir);
-  if (dirExists) return gracefulFs.linkSync(srcpath, dstpath)
-  mkdirs_1.mkdirsSync(dir);
-
-  return gracefulFs.linkSync(srcpath, dstpath)
-}
-
-var link = {
-  createLink: u$5(createLink),
-  createLinkSync
-};
-
-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__default["default"].isAbsolute(srcpath)) {
-    return gracefulFs.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__default["default"].dirname(dstpath);
-    const relativeToDst = path__default["default"].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 gracefulFs.lstat(srcpath, (err) => {
-          if (err) {
-            err.message = err.message.replace('lstat', 'ensureSymlink');
-            return callback(err)
-          }
-          return callback(null, {
-            'toCwd': srcpath,
-            'toDst': path__default["default"].relative(dstdir, srcpath)
-          })
-        })
-      }
-    })
-  }
-}
-
-function symlinkPathsSync$1 (srcpath, dstpath) {
-  let exists;
-  if (path__default["default"].isAbsolute(srcpath)) {
-    exists = gracefulFs.existsSync(srcpath);
-    if (!exists) throw new Error('absolute srcpath does not exist')
-    return {
-      'toCwd': srcpath,
-      'toDst': srcpath
-    }
-  } else {
-    const dstdir = path__default["default"].dirname(dstpath);
-    const relativeToDst = path__default["default"].join(dstdir, srcpath);
-    exists = gracefulFs.existsSync(relativeToDst);
-    if (exists) {
-      return {
-        'toCwd': relativeToDst,
-        'toDst': srcpath
-      }
-    } else {
-      exists = gracefulFs.existsSync(srcpath);
-      if (!exists) throw new Error('relative srcpath does not exist')
-      return {
-        'toCwd': srcpath,
-        'toDst': path__default["default"].relative(dstdir, srcpath)
-      }
-    }
-  }
-}
-
-var symlinkPaths_1 = {
-  symlinkPaths: symlinkPaths$1,
-  symlinkPathsSync: symlinkPathsSync$1
-};
-
-function symlinkType$1 (srcpath, type, callback) {
-  callback = (typeof type === 'function') ? type : callback;
-  type = (typeof type === 'function') ? false : type;
-  if (type) return callback(null, type)
-  gracefulFs.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 = gracefulFs.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 mkdirs = mkdirs_1.mkdirs;
-const mkdirsSync = mkdirs_1.mkdirsSync;
-
-
-const symlinkPaths = symlinkPaths_1.symlinkPaths;
-const symlinkPathsSync = symlinkPaths_1.symlinkPathsSync;
-
-
-const symlinkType = symlinkType_1.symlinkType;
-const symlinkTypeSync = symlinkType_1.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__default["default"].dirname(dstpath);
-        pathExists$3(dir, (err, dirExists) => {
-          if (err) return callback(err)
-          if (dirExists) return gracefulFs.symlink(srcpath, dstpath, type, callback)
-          mkdirs(dir, err => {
-            if (err) return callback(err)
-            gracefulFs.symlink(srcpath, dstpath, type, callback);
-          });
-        });
-      });
-    });
-  });
-}
-
-function createSymlinkSync (srcpath, dstpath, type) {
-  const destinationExists = gracefulFs.existsSync(dstpath);
-  if (destinationExists) return undefined
-
-  const relative = symlinkPathsSync(srcpath, dstpath);
-  srcpath = relative.toDst;
-  type = symlinkTypeSync(relative.toCwd, type);
-  const dir = path__default["default"].dirname(dstpath);
-  const exists = gracefulFs.existsSync(dir);
-  if (exists) return gracefulFs.symlinkSync(srcpath, dstpath, type)
-  mkdirsSync(dir);
-  return gracefulFs.symlinkSync(srcpath, dstpath, type)
-}
-
-var symlink = {
-  createSymlink: u$4(createSymlink),
-  createSymlinkSync
-};
-
-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 = fs__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;
-
-
-var jsonfile = {
-  // jsonfile exports
-  readJson: u$3(jsonfile_1.readFile),
-  readJsonSync: jsonfile_1.readFileSync,
-  writeJson: u$3(jsonfile_1.writeFile),
-  writeJsonSync: jsonfile_1.writeFileSync
-};
-
-const pathExists$2 = pathExists_1.pathExists;
-
-
-function outputJson (file, data, options, callback) {
-  if (typeof options === 'function') {
-    callback = options;
-    options = {};
-  }
-
-  const dir = path__default["default"].dirname(file);
-
-  pathExists$2(dir, (err, itDoes) => {
-    if (err) return callback(err)
-    if (itDoes) return jsonfile.writeJson(file, data, options, callback)
-
-    mkdirs_1.mkdirs(dir, err => {
-      if (err) return callback(err)
-      jsonfile.writeJson(file, data, options, callback);
-    });
-  });
-}
-
-var outputJson_1 = outputJson;
-
-function outputJsonSync (file, data, options) {
-  const dir = path__default["default"].dirname(file);
-
-  if (!gracefulFs.existsSync(dir)) {
-    mkdirs_1.mkdirsSync(dir);
-  }
-
-  jsonfile.writeJsonSync(file, data, options);
-}
-
-var outputJsonSync_1 = outputJsonSync;
-
-const u$2 = universalify.fromCallback;
-
-
-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 copySync = copySync$1.copySync;
-const removeSync = remove$1.removeSync;
-const mkdirpSync = mkdirs_1.mkdirsSync;
-
-
-function moveSync (src, dest, options) {
-  options = options || {};
-  const overwrite = options.overwrite || options.clobber || false;
-
-  src = path__default["default"].resolve(src);
-  dest = path__default["default"].resolve(dest);
-
-  if (src === dest) return gracefulFs.accessSync(src)
-
-  if (isSrcSubdir$1(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
-
-  mkdirpSync(path__default["default"].dirname(dest));
-  tryRenameSync();
-
-  function tryRenameSync () {
-    if (overwrite) {
-      try {
-        return gracefulFs.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 {
-        gracefulFs.linkSync(src, dest);
-        return gracefulFs.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 = gracefulFs.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 = gracefulFs.openSync(src, 'r');
-  const stat = gracefulFs.fstatSync(fdr);
-  const fdw = gracefulFs.openSync(dest, flags, stat.mode);
-  let pos = 0;
-
-  while (pos < stat.size) {
-    const bytesRead = gracefulFs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-    gracefulFs.writeSync(fdw, _buff, 0, bytesRead);
-    pos += bytesRead;
-  }
-
-  gracefulFs.closeSync(fdr);
-  gracefulFs.closeSync(fdw);
-  return gracefulFs.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 gracefulFs.statSync(src).isDirectory() &&
-           src !== dest &&
-           dest.indexOf(src) > -1 &&
-           dest.split(path__default["default"].dirname(src) + path__default["default"].sep)[1].split(path__default["default"].sep)[0] === path__default["default"].basename(src)
-  } catch (e) {
-    return false
-  }
-}
-
-var moveSync_1 = {
-  moveSync
-};
-
-const u$1 = universalify.fromCallback;
-
-
-const copy = copy$1.copy;
-const remove = remove$1.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__default["default"].resolve(src);
-  dest = path__default["default"].resolve(dest);
-
-  if (src === dest) return gracefulFs.access(src, cb)
-
-  gracefulFs.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__default["default"].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) {
-  gracefulFs.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__default["default"].sep);
-  const destArray = dest.split(path__default["default"].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 pathExists = pathExists_1.pathExists;
-
-function outputFile (file, data, encoding, callback) {
-  if (typeof encoding === 'function') {
-    callback = encoding;
-    encoding = 'utf8';
-  }
-
-  const dir = path__default["default"].dirname(file);
-  pathExists(dir, (err, itDoes) => {
-    if (err) return callback(err)
-    if (itDoes) return gracefulFs.writeFile(file, data, encoding, callback)
-
-    mkdirs_1.mkdirs(dir, err => {
-      if (err) return callback(err)
-
-      gracefulFs.writeFile(file, data, encoding, callback);
-    });
-  });
-}
-
-function outputFileSync (file, ...args) {
-  const dir = path__default["default"].dirname(file);
-  if (gracefulFs.existsSync(dir)) {
-    return gracefulFs.writeFileSync(file, ...args)
-  }
-  mkdirs_1.mkdirsSync(dir);
-  gracefulFs.writeFileSync(file, ...args);
-}
-
-var output = {
-  outputFile: u(outputFile),
-  outputFileSync
-};
-
-var lib = createCommonjsModule(function (module) {
-
-module.exports = Object.assign(
-  {},
-  // Export promiseified graceful-fs:
-  fs_1,
-  // Export extra methods:
-  copySync$1,
-  copy$1,
-  empty,
-  ensure,
-  json,
-  mkdirs_1,
-  moveSync_1,
-  move_1,
-  output,
-  pathExists_1,
-  remove$1
-);
-
-// Export fs.promises as a getter property so that we don't trigger
-// ExperimentalWarning before fs.promises is actually accessed.
-
-if (Object.getOwnPropertyDescriptor(fs__default["default"], 'promises')) {
-  Object.defineProperty(module.exports, 'promises', {
-    get () { return fs__default["default"].promises }
-  });
-}
-});
-
-class Server extends EventEmitter__default["default"] {
-    constructor(option, common) {
-        super();
-        this.debug = Boolean(option("debug"));
-        this.file = String(option("socket", path__default["default"].join(common.cacheDir(), "socket")));
-        this.server = undefined;
-        this.option = option;
-        this._connections = {};
-        this._connectionId = 0;
-    }
-    close() {
-        if (this.debug) {
-            console.log("Server::close");
-        }
-        if (this.server) {
-            this.server.close();
-        }
-        try {
-            lib.unlinkSync(this.file);
-        }
-        catch (err) {
-            /* */
-        }
-    }
-    listen() {
-        try {
-            lib.unlinkSync(this.file); // this should be more
-            // complicated with attempts to
-            // cleanly shut down and whatnot
-        }
-        catch (err) {
-            /* */
-        }
-        return new Promise((resolve) => {
-            let connected = false;
-            this.server = net__default["default"].createServer(this._onConnection.bind(this)).listen(this.file, () => {
-                lib.chmodSync(this.file, "777");
-                connected = true;
-                resolve();
-            });
-            this.server.on("error", (err) => {
-                if (!connected) {
-                    console.error("Got server error", err);
-                    setTimeout(this.listen.bind(this), 1000);
-                }
-            });
-            this.server.on("close", (err) => {
-                if (!connected) {
-                    console.error("Got server error", err);
-                    setTimeout(this.listen.bind(this), 1000);
-                }
-            });
-        });
-    }
-    _onConnection(conn) {
-        const compile = new Compile(conn, ++this._connectionId, this.option);
-        if (this.debug) {
-            console.log("Server::_onConnection", compile.id);
-        }
-        if (this._connectionId === Math.pow(2, 31) - 1) {
-            this._connectionId = 0;
-        }
-        this._connections[compile.id] = conn;
-        compile.on("end", () => {
-            if (this.debug) {
-                console.log("Compile::end");
-            }
-            delete this._connections[compile.id];
-        });
-        this.emit("compile", compile);
-    }
-}
-
-class Slots extends EventEmitter__default["default"] {
-    constructor(count, name, debug) {
-        super();
-        this.count = count;
-        this.name = name;
-        this.used = new Map();
-        this.debug = debug;
-        this.pending = new Map();
-        if (this.debug) {
-            console.log("Slots created", this.toString());
-        }
-    }
-    acquire(id, data, cb) {
-        if (this.used.size < this.count) {
-            this.used.set(id, data);
-            if (this.debug) {
-                console.log("acquired slot", id, data, this.toString());
-            }
-            cb();
-        }
-        else {
-            if (this.debug) {
-                console.log("pending slot", id, this.toString());
-            }
-            this.pending.set(id, { data: data, cb: cb });
-        }
-    }
-    release(id) {
-        this.pending.delete(id);
-        if (this.used.has(id)) {
-            const data = this.used.get(id);
-            this.used.delete(id);
-            assert__default["default"](this.used.size < this.count);
-            assert__default["default"](this.used.size + 1 === this.count || this.pending.size === 0);
-            if (this.debug) {
-                console.log("released", id, data, this.toString());
-            }
-            // eslint-disable-next-line no-unreachable-loop
-            for (const p of this.pending) {
-                this.used.set(p[0], p[1].data);
-                this.pending.delete(p[0]);
-                p[1].cb();
-                break;
-            }
-        }
-    }
-    toString() {
-        return `${this.name} ${this.used.size}/${this.count}`;
-    }
-    dump() {
-        const pending = {}, used = {};
-        for (const p of this.pending) {
-            pending[p[0]] = p[1].data;
-        }
-        for (const p of this.used) {
-            used[p[0]] = p[1];
-        }
-        return { pending: pending, capacity: this.count, used: this.used.size };
-    }
-}
-
-const Version = 5;
-function cacheDir(option) {
-    let dir = option("cache-dir");
-    if (!dir) {
-        // @ts-ignore
-        dir = path__default["default"].join(os__default["default"].homedir(), ".cache", "fisk", path__default["default"].basename(option.prefix));
-    }
-    return String(dir);
-}
-function validateCache(option) {
-    const dir = cacheDir(option);
-    const file = path__default["default"].join(dir, "version");
-    // console.log(dir);
-    let version;
-    try {
-        version = lib.readFileSync(file);
-        if (version.readUInt32BE() === Version) {
-            return;
-        }
-    }
-    catch (err) {
-        /* */
-    }
-    if (version) {
-        console.log(`Wrong version. Destroying cache ${dir}`);
-    }
-    lib.removeSync(dir);
-    lib.mkdirpSync(dir);
-    const buf = Buffer.allocUnsafe(4);
-    buf.writeUInt32BE(Version);
-    lib.writeFileSync(file, buf);
-}
-function Common (option) {
-    validateCache(option);
-    return {
-        cacheDir: cacheDir.bind(undefined, option),
-        Version
-    };
-}
-
-// Dependencies
-
-
-// Load global paths
-var globalPaths = require$$0__default$1["default"].globalPaths;
-
-// Guess at NPM's global install dir
-var npmGlobalPrefix;
-if ('win32' === process.platform) {
-	npmGlobalPrefix = path__default["default"].dirname(process.execPath);
-} else {
-	npmGlobalPrefix = path__default["default"].dirname(path__default["default"].dirname(process.execPath));
-}
-var npmGlobalModuleDir = path__default["default"].resolve(npmGlobalPrefix, 'lib', 'node_modules');
-
-// Save OS-specific path separator
-var sep = path__default["default"].sep;
-
-// If we're in webpack, force it to use the original require() method
-var requireFunction = ("function" === typeof __webpack_require__ || "function" === typeof __non_webpack_require__)
-	? __non_webpack_require__
-	: commonjsRequire;
-
-// Resolver
-var resolve = function resolve(dirname) {
-	// Check for environmental variable
-	if (process.env.APP_ROOT_PATH) {
-		return path__default["default"].resolve(process.env.APP_ROOT_PATH);
-	}
-
-	// Defer to Yarn Plug'n'Play if enabled
-	if (process.versions.pnp) {
-		try {
-			var pnp = requireFunction('pnpapi');
-			return pnp.getPackageInformation(pnp.topLevel).packageLocation;
-		} catch (e) {}
-	}
-
-	// Defer to main process in electron renderer
-	if ('undefined' !== typeof window && window.process && 'renderer' === window.process.type) {
-		try {
-			var remote = requireFunction('electron').remote;
-			return remote.require('app-root-path').path;
-		} catch (e) {}
-	}
-
-	// Defer to AWS Lambda when executing there
-	if (process.env.LAMBDA_TASK_ROOT && process.env.AWS_EXECUTION_ENV) {
-		return process.env.LAMBDA_TASK_ROOT;
-	}
-
-	var resolved = path__default["default"].resolve(dirname);
-	var alternateMethod = false;
-	var appRootPath = null;
-
-	// Make sure that we're not loaded from a global include path
-	// Eg. $HOME/.node_modules
-	//     $HOME/.node_libraries
-	//     $PREFIX/lib/node
-	globalPaths.forEach(function(globalPath) {
-		if (!alternateMethod && 0 === resolved.indexOf(globalPath)) {
-			alternateMethod = true;
-		}
-	});
-
-	// If the app-root-path library isn't loaded globally,
-	// and node_modules exists in the path, just split __dirname
-	var nodeModulesDir = sep + 'node_modules';
-	if (!alternateMethod && -1 !== resolved.indexOf(nodeModulesDir)) {
-		var parts = resolved.split(nodeModulesDir);
-		if (parts.length) {
-			appRootPath = parts[0];
-			parts = null;
-		}
-	}
-
-	// If the above didn't work, or this module is loaded globally, then
-	// resort to require.main.filename (See http://nodejs.org/api/modules.html)
-	if (alternateMethod || null == appRootPath) {
-		appRootPath = path__default["default"].dirname(require.main.filename);
-	}
-
-	// Handle global bin/ directory edge-case
-	if (alternateMethod && -1 !== appRootPath.indexOf(npmGlobalModuleDir) && (appRootPath.length - 4) === appRootPath.indexOf(sep + 'bin')) {
-		appRootPath = appRootPath.slice(0, -4);
-	}
-
-	// Return
-	return appRootPath;
-};
-
-var appRootPath$1 = function(dirname) {
-	var path = path__default["default"];
-	var resolve$1 = resolve;
-	var appRootPath = resolve$1(dirname);
-
-	var publicInterface = {
-		resolve: function(pathToModule) {
-			return path.join(appRootPath, pathToModule);
-		},
-
-		require: function(pathToModule) {
-			return commonjsRequire(publicInterface.resolve(pathToModule));
-		},
-
-		toString: function() {
-			return appRootPath;
-		},
-
-		setPath: function(explicitlySetPath) {
-			appRootPath = path.resolve(explicitlySetPath);
-			publicInterface.path = appRootPath;
-		},
-
-		path: appRootPath
-	};
-
-	return publicInterface;
-};
-
-var appRootPath = appRootPath$1(__dirname);
-
-var xdgBasedir = createCommonjsModule(function (module, exports) {
-
-
-
-const home = os__default["default"].homedir();
-const env = process.env;
-
-exports.data = env.XDG_DATA_HOME ||
-	(home ? path__default["default"].join(home, '.local', 'share') : null);
-
-exports.config = env.XDG_CONFIG_HOME ||
-	(home ? path__default["default"].join(home, '.config') : null);
-
-exports.cache = env.XDG_CACHE_HOME || (home ? path__default["default"].join(home, '.cache') : null);
-
-exports.runtime = env.XDG_RUNTIME_DIR || null;
-
-exports.dataDirs = (env.XDG_DATA_DIRS || '/usr/local/share/:/usr/share/').split(':');
-
-if (exports.data) {
-	exports.dataDirs.unshift(exports.data);
-}
-
-exports.configDirs = (env.XDG_CONFIG_DIRS || '/etc/xdg').split(':');
-
-if (exports.config) {
-	exports.configDirs.unshift(exports.config);
-}
-});
-
-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__';
-}
-
-/*global require,module,process*/
-
-function split(data)
-{
-    const pre = data.split("\n");
-    // rejoin with lines that starts with a whitespace
-    const out = [];
-    let cur = "";
-    for (let i = 0; i < pre.length; ++i) {
-        let line = pre[i].replace(/\t/g, "  ");
-        if (!line.length)
-            continue;
-        if (!cur.length || /\s/.test(line[0])) {
-            let idx = 0;
-            while (/\s/.test(line[idx]))
-                ++idx;
-            cur += line.substr(idx ? idx - 1 : 0);
-            idx = cur.length - 1;
-            while (idx >= 0 && /\s/.test(cur[idx]))
-                --idx;
-            if (idx < cur.length - 1)
-                cur = cur.substr(0, idx + 1);
-        } else if (cur.length > 0) {
-            out.push(cur.trim());
-            cur = line.trim();
-        }
-    }
-    if (cur.length > 0) {
-        out.push(cur.trim());
-    }
-    return out;
-}
-
-function realValue(v)
-{
-    if (typeof v !== "string")
-        return v;
-    if (/^[-0-9.]+$/.exec(v)) {
-        const vf = parseFloat(v);
-        if (!isNaN(vf))
-            return vf;
-    }
-    switch (v) {
-    case "true":
-        return true;
-    case "false":
-        return false;
-    }
-    return v;
-}
-
-class Options {
-    constructor(options, argv) {
-        this.argv = Object.assign({}, argv);
-        this.prefix = options.prefix;
-        this.additionalFiles = options.additionalFiles || [];
-        this.applicationPath = options.noApplicationPath ? "" : appRootPath.toString();
-        this.debug = options.debug;
-        this.options = {};
-        this.configDirs = this.argv["config-dir"] ||  options.configDirs || xdgBasedir.configDirs;
-        this._read();
-    }
-
-    value(name) {
-        // foo-bar becomes FOO_BAR as env
-        if (name in this.argv)
-            return this.argv[name];
-        const envname = (this.prefix + "_" + name).replace(/-/g, "_").toUpperCase();
-        if (envname in process.env)
-            return realValue(process.env[envname]);
-
-        if (name in this.options)
-            return this.options[name];
-        return undefined;
-    }
-
-    _homedir() {
-        let home = process.env.home;
-        if (home) {
-            return path__default["default"].join(home, ".config");
-        }
-        return undefined;
-    }
-
-    _log(...args) {
-        if (this.debug)
-            console.log(...args);
-    }
-
-    _read() {
-        // if we have a config file passed, read it
-        let file = this.value("config-file");
-        if (!file && this.prefix)
-            file = this.prefix + ".conf";
-        if (!file)
-            return;
-
-        let data = [];
-        let seen = new Set();
-        const Failed = 0;
-        const Success = 1;
-        const Seen = 2;
-        const read = file => {
-            if (seen.has(file))
-                return Seen;
-            seen.add(file);
-            try {
-                const contents = fs__default["default"].readFileSync(file, "utf8");
-                this._log(`Loaded ${contents.length} bytes from ${file}`);
-
-                if (contents) {
-                    data.push({ file: file, contents: contents });
-                    return Success;
-                }
-            } catch (e) {
-                this._log(`Failed to load ${file}`);
-            }
-            return Failed;
-        };
-
-        // console.log("about to read file", file, "additionalFiles", this.additionalFiles, "configDirs", this.configDirs, "applicationPath", this.applicationPath, "homedir", this._homedir());
-        if (path__default["default"].isAbsolute(file)) {
-            read(file);
-        } else {
-            this.additionalFiles.forEach(file => {
-                if (path__default["default"].isAbsolute(file) && read(file) == Failed)
-                    read(file + ".conf");
-            });
-            ([this.applicationPath, this._homedir()].concat(this.configDirs)).forEach(root => {
-                // in case we appended with undefined
-                if (!root)
-                    return;
-                this.additionalFiles.forEach(additional => {
-                    if (!path__default["default"].isAbsolute(additional)) {
-                        let file = path__default["default"].join(root, additional);
-                        if (read(file) == Failed)
-                            read(file + ".conf");
-                    }
-                });
-
-                let filePath = path__default["default"].join(root, file);
-                if (read(filePath) == Failed)
-                    read(filePath + ".conf");
-            });
-        }
-        for (let i = data.length - 1; i >= 0; --i) {
-            let str = data[i].contents;
-            if (!str)
-                continue;
-            try {
-                let obj = JSON.parse(str);
-                for (let key in obj) {
-                    this._log(`Assigning ${JSON.stringify(obj[key])} over ${JSON.stringify(this.options[key])} for ${key} from ${data[i].file} (JSON)`);
-                    this.options[key] = obj[key];
-                }
-            } catch (err) {
-                const items = split(str);
-                for (let j = 0; j < items.length; ++j) {
-                    const item = items[j].trim();
-                    if (!item.length)
-                        continue;
-                    if (item[0] === "#")
-                        continue;
-                    const eq = item.indexOf("=");
-                    if (eq === -1) {
-                        this._log("Couldn't find =", item);
-                        continue;
-                    }
-                    const key = item.substr(0, eq).trim();
-                    if (!key.length) {
-                        this._log("empty key", item);
-                        continue;
-                    }
-                    const value = item.substr(eq + 1).trim();
-                    this._log(`Assigning ${value} over ${this.options[key]} for ${key} from ${data[i].file} (INI)`);
-                    this.options[key] = value;
-                }
-            }
-        }
-    }
-}
-
-const data = {};
-
-var options = function(options, argv) {
-    if (!argv)
-        argv = minimist(process.argv.slice(2));
-    if (!(options instanceof Object))
-        options = { prefix: options || "" };
-
-    data.options = new Options(options, argv);
-    let ret = function(name, defaultValue) {
-        const val = data.options.value(name);
-        if (typeof val === "undefined")
-            return defaultValue;
-        return val;
-    };
-    ret.prefix = options.prefix;
-    ret.int = function(name, defaultValue) {
-        const v = parseInt(data.options.value(name));
-        if (typeof v === "number" && !isNaN(v))
-            return v;
-        return defaultValue;
-    };
-    ret.float = function(name, defaultValue) {
-        const v = parseFloat(data.options.value(name));
-        if (typeof v === "number" && !isNaN(v))
-            return v;
-        return defaultValue;
-    };
-    ret.json = function(name, defaultValue) {
-        const opt = data.options.value(name);
-        if (opt === undefined)
-            return defaultValue;
-        if (typeof opt !== "string")
-            return opt;
-        try {
-            const json = JSON.parse(opt);
-            return json;
-        } catch (e) {
-        }
-        return defaultValue;
-    };
-    return ret;
-};
-
-// #!/usr/bin/env node
-const option = options({
-    prefix: "fisk/daemon",
-    noApplicationPath: true,
-    additionalFiles: ["fisk/daemon.conf.override"]
-});
-const common = Common(option);
-const debug = Boolean(option("debug"));
-process.on("unhandledRejection", (reason, p) => {
-    console.log("Unhandled Rejection at: Promise", p, "reason:", reason.stack);
-    process.exit();
-    // if (client)
-    //     client.send('log', { message: `Unhandled Rejection at: Promise ${p}, reason: ${reason.stack}` });
-});
-process.on("uncaughtException", (err) => {
-    console.error("Uncaught exception", err);
-    process.exit();
-    // if (client)
-    //     client.send('log', { message: `Uncaught exception ${err.toString()} ${err.stack}` });
-});
-const server = new Server(option, common);
-server.listen().then(() => {
-    console.log("listening on", server.file);
-});
-// server.on("message
-server.on("error", (err) => {
-    console.error("server error", err);
-});
-const cppSlots = new Slots(option.int("cpp-slots", Math.max(os__default["default"].cpus().length * 2, 1)), "cpp", debug);
-const compileSlots = new Slots(option.int("slots", Math.max(os__default["default"].cpus().length, 1)), "compile", debug);
-server.on("compile", (compile) => {
-    compile.on("dumpSlots", () => {
-        const ret = { cpp: cppSlots.dump(), compile: compileSlots.dump() };
-        if (debug) {
-            console.log("sending dump", ret);
-        }
-        compile.send(ret);
-    });
-    let requestedCppSlot = false;
-    compile.on("acquireCppSlot", () => {
-        if (debug) {
-            console.log("acquireCppSlot");
-        }
-        assert__default["default"](!requestedCppSlot);
-        requestedCppSlot = true;
-        cppSlots.acquire(compile.id, { pid: compile.pid }, () => {
-            // compile.send({ type: 'cppSlotAcquired' });
-            compile.send(Constants.CppSlotAcquired);
-        });
-    });
-    compile.on("releaseCppSlot", () => {
-        if (debug) {
-            console.log("releaseCppSlot");
-        }
-        assert__default["default"](requestedCppSlot);
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-    });
-    let requestedCompileSlot = false;
-    compile.on("acquireCompileSlot", () => {
-        if (debug) {
-            console.log("acquireCompileSlot");
-        }
-        assert__default["default"](!requestedCompileSlot);
-        requestedCompileSlot = true;
-        compileSlots.acquire(compile.id, { pid: compile.pid }, () => {
-            // compile.send({ type: 'compileSlotAcquired' });
-            compile.send(Constants.CompileSlotAcquired);
-        });
-    });
-    compile.on("releaseCompileSlot", () => {
-        if (debug) {
-            console.log("releaseCompileSlot");
-        }
-        assert__default["default"](requestedCompileSlot);
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-    compile.on("error", (err) => {
-        if (debug) {
-            console.error("Got error from fiskc", compile.id, compile.pid, err);
-        }
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-    compile.on("end", () => {
-        if (debug) {
-            console.log("got end from", compile.id, compile.pid);
-        }
-        if (requestedCppSlot) {
-            requestedCppSlot = false;
-            cppSlots.release(compile.id);
-        }
-        if (requestedCompileSlot) {
-            requestedCompileSlot = false;
-            compileSlots.release(compile.id);
-        }
-    });
-});
-process.on("exit", () => {
-    server.close();
-});
-process.on("SIGINT", () => {
-    server.close();
-    process.exit();
-});
-/*
-  const client = new Client(option, common.Version);
-
-let connectInterval;
-client.on('quit', message => {
-    process.exit(message.code);
-});
-
-client.on('connect', () => {
-    console.log('connected');
-    if (connectInterval) {
-        clearInterval(connectInterval);
-        connectInterval = undefined;
-    }
-});
-
-client.on('error', err => {
-    console.error('client error', err);
-});
-
-client.on('close', () => {
-    console.log('client closed');
-    if (!connectInterval) {
-        connectInterval = setInterval(() => {
-            console.log('Reconnecting...');
-            client.connect();
-        }, 1000);
-    }
-});
-*/
-//# sourceMappingURL=fisk-daemon.js.map