@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/index-Dtt_h58T.js

@@ -1,2116 +0,0 @@
-import { ad as commonjsGlobal, R as getDefaultExportFromCjs } from './paths-CV7S5-Zm.js';
-import path from 'path';
-import fs$2 from 'fs';
-import require$$0 from 'constants';
-import require$$0$1 from 'stream';
-import require$$4 from 'util';
-import Mi from 'assert';
-import require$$1 from 'events';
-
-var properLockfile = {exports: {}};
-
-var lockfile$1 = {};
-
-var polyfills;
-var hasRequiredPolyfills;
-
-function requirePolyfills () {
-	if (hasRequiredPolyfills) return polyfills;
-	hasRequiredPolyfills = 1;
-	var constants = require$$0;
-
-	var origCwd = process.cwd;
-	var cwd = null;
-
-	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-
-	process.cwd = function() {
-	  if (!cwd)
-	    cwd = origCwd.call(process);
-	  return cwd
-	};
-	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);
-	}
-
-	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.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" || er.code === "EBUSY")
-	              && Date.now() - start < 60000) {
-	            setTimeout(function() {
-	              fs.stat(to, function (stater, st) {
-	                if (stater && stater.code === "ENOENT")
-	                  fs$rename(from, to, CB);
-	                else
-	                  cb(er);
-	              });
-	            }, backoff);
-	            if (backoff < 100)
-	              backoff += 10;
-	            return;
-	          }
-	          if (cb) cb(er);
-	        });
-	      }
-	      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-	      return rename
-	    })(fs.rename);
-	  }
-
-	  // if read() returns EAGAIN, then just try it again.
-	  fs.read = typeof fs.read !== 'function' ? fs.read
-	  : (function (fs$read) {
-	    function read (fd, buffer, offset, length, position, callback_) {
-	      var callback;
-	      if (callback_ && typeof callback_ === 'function') {
-	        var eagCounter = 0;
-	        callback = function (er, _, __) {
-	          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
-	            eagCounter ++;
-	            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-	          }
-	          callback_.apply(this, arguments);
-	        };
-	      }
-	      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-	    }
-
-	    // This ensures `util.promisify` works as it does for native `fs.read`.
-	    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-	    return read
-	  })(fs.read);
-
-	  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
-	  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
-	    var eagCounter = 0;
-	    while (true) {
-	      try {
-	        return fs$readSync.call(fs, fd, buffer, offset, length, position)
-	      } catch (er) {
-	        if (er.code === 'EAGAIN' && eagCounter < 10) {
-	          eagCounter ++;
-	          continue
-	        }
-	        throw er
-	      }
-	    }
-	  }})(fs.readSync);
-
-	  function patchLchmod (fs) {
-	    fs.lchmod = function (path, mode, callback) {
-	      fs.open( path
-	             , constants.O_WRONLY | constants.O_SYMLINK
-	             , mode
-	             , function (err, fd) {
-	        if (err) {
-	          if (callback) callback(err);
-	          return
-	        }
-	        // prefer to return the chmod error, if one occurs,
-	        // but still try to close, and report closing errors if they occur.
-	        fs.fchmod(fd, mode, function (err) {
-	          fs.close(fd, function(err2) {
-	            if (callback) callback(err || err2);
-	          });
-	        });
-	      });
-	    };
-
-	    fs.lchmodSync = function (path, mode) {
-	      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
-
-	      // prefer to return the chmod error, if one occurs,
-	      // but still try to close, and report closing errors if they occur.
-	      var threw = true;
-	      var ret;
-	      try {
-	        ret = fs.fchmodSync(fd, mode);
-	        threw = false;
-	      } finally {
-	        if (threw) {
-	          try {
-	            fs.closeSync(fd);
-	          } catch (er) {}
-	        } else {
-	          fs.closeSync(fd);
-	        }
-	      }
-	      return ret
-	    };
-	  }
-
-	  function patchLutimes (fs) {
-	    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
-	      fs.lutimes = function (path, at, mt, cb) {
-	        fs.open(path, constants.O_SYMLINK, function (er, fd) {
-	          if (er) {
-	            if (cb) cb(er);
-	            return
-	          }
-	          fs.futimes(fd, at, mt, function (er) {
-	            fs.close(fd, function (er2) {
-	              if (cb) cb(er || er2);
-	            });
-	          });
-	        });
-	      };
-
-	      fs.lutimesSync = function (path, at, mt) {
-	        var fd = fs.openSync(path, constants.O_SYMLINK);
-	        var ret;
-	        var threw = true;
-	        try {
-	          ret = fs.futimesSync(fd, at, mt);
-	          threw = false;
-	        } finally {
-	          if (threw) {
-	            try {
-	              fs.closeSync(fd);
-	            } catch (er) {}
-	          } else {
-	            fs.closeSync(fd);
-	          }
-	        }
-	        return ret
-	      };
-
-	    } else if (fs.futimes) {
-	      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
-	      fs.lutimesSync = function () {};
-	    }
-	  }
-
-	  function chmodFix (orig) {
-	    if (!orig) return orig
-	    return function (target, mode, cb) {
-	      return orig.call(fs, target, mode, function (er) {
-	        if (chownErOk(er)) er = null;
-	        if (cb) cb.apply(this, arguments);
-	      })
-	    }
-	  }
-
-	  function chmodFixSync (orig) {
-	    if (!orig) return orig
-	    return function (target, mode) {
-	      try {
-	        return orig.call(fs, target, mode)
-	      } catch (er) {
-	        if (!chownErOk(er)) throw er
-	      }
-	    }
-	  }
-
-
-	  function chownFix (orig) {
-	    if (!orig) return orig
-	    return function (target, uid, gid, cb) {
-	      return orig.call(fs, target, uid, gid, function (er) {
-	        if (chownErOk(er)) er = null;
-	        if (cb) cb.apply(this, arguments);
-	      })
-	    }
-	  }
-
-	  function chownFixSync (orig) {
-	    if (!orig) return orig
-	    return function (target, uid, gid) {
-	      try {
-	        return orig.call(fs, target, uid, gid)
-	      } catch (er) {
-	        if (!chownErOk(er)) throw er
-	      }
-	    }
-	  }
-
-	  function statFix (orig) {
-	    if (!orig) return orig
-	    // Older versions of Node erroneously returned signed integers for
-	    // uid + gid.
-	    return function (target, options, cb) {
-	      if (typeof options === 'function') {
-	        cb = options;
-	        options = null;
-	      }
-	      function callback (er, stats) {
-	        if (stats) {
-	          if (stats.uid < 0) stats.uid += 0x100000000;
-	          if (stats.gid < 0) stats.gid += 0x100000000;
-	        }
-	        if (cb) cb.apply(this, arguments);
-	      }
-	      return options ? orig.call(fs, target, options, callback)
-	        : orig.call(fs, target, callback)
-	    }
-	  }
-
-	  function statFixSync (orig) {
-	    if (!orig) return orig
-	    // Older versions of Node erroneously returned signed integers for
-	    // uid + gid.
-	    return function (target, options) {
-	      var stats = options ? orig.call(fs, target, options)
-	        : orig.call(fs, target);
-	      if (stats) {
-	        if (stats.uid < 0) stats.uid += 0x100000000;
-	        if (stats.gid < 0) stats.gid += 0x100000000;
-	      }
-	      return stats;
-	    }
-	  }
-
-	  // ENOSYS means that the fs doesn't support the op. Just ignore
-	  // that, because it doesn't matter.
-	  //
-	  // if there's no getuid, or if getuid() is something other
-	  // than 0, and the error is EINVAL or EPERM, then just ignore
-	  // it.
-	  //
-	  // This specific case is a silent failure in cp, install, tar,
-	  // and most other unix tools that manage permissions.
-	  //
-	  // When running as root, or if other types of errors are
-	  // encountered, then it's strict.
-	  function chownErOk (er) {
-	    if (!er)
-	      return true
-
-	    if (er.code === "ENOSYS")
-	      return true
-
-	    var nonroot = !process.getuid || process.getuid() !== 0;
-	    if (nonroot) {
-	      if (er.code === "EINVAL" || er.code === "EPERM")
-	        return true
-	    }
-
-	    return false
-	  }
-	}
-	return polyfills;
-}
-
-var legacyStreams;
-var hasRequiredLegacyStreams;
-
-function requireLegacyStreams () {
-	if (hasRequiredLegacyStreams) return legacyStreams;
-	hasRequiredLegacyStreams = 1;
-	var Stream = require$$0$1.Stream;
-
-	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();
-	    }
-	  }
-	}
-	return legacyStreams;
-}
-
-var clone_1;
-var hasRequiredClone;
-
-function requireClone () {
-	if (hasRequiredClone) return clone_1;
-	hasRequiredClone = 1;
-
-	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
-	}
-	return clone_1;
-}
-
-var gracefulFs;
-var hasRequiredGracefulFs;
-
-function requireGracefulFs () {
-	if (hasRequiredGracefulFs) return gracefulFs;
-	hasRequiredGracefulFs = 1;
-	var fs = fs$2;
-	var polyfills = requirePolyfills();
-	var legacy = requireLegacyStreams();
-	var clone = requireClone();
-
-	var util = require$$4;
-
-	/* istanbul ignore next - node 0.x polyfill */
-	var gracefulQueue;
-	var previousSymbol;
-
-	/* istanbul ignore else - node 0.x polyfill */
-	if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
-	  gracefulQueue = Symbol.for('graceful-fs.queue');
-	  // This is used in testing by future versions
-	  previousSymbol = Symbol.for('graceful-fs.previous');
-	} else {
-	  gracefulQueue = '___graceful-fs.queue';
-	  previousSymbol = '___graceful-fs.previous';
-	}
-
-	function noop () {}
-
-	function publishQueue(context, queue) {
-	  Object.defineProperty(context, gracefulQueue, {
-	    get: function() {
-	      return queue
-	    }
-	  });
-	}
-
-	var debug = noop;
-	if (util.debuglog)
-	  debug = util.debuglog('gfs4');
-	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
-	  debug = function() {
-	    var m = util.format.apply(util, arguments);
-	    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
-	    console.error(m);
-	  };
-
-	// Once time initialization
-	if (!fs[gracefulQueue]) {
-	  // This queue can be shared by multiple loaded instances
-	  var queue = commonjsGlobal[gracefulQueue] || [];
-	  publishQueue(fs, 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.close = (function (fs$close) {
-	    function close (fd, cb) {
-	      return fs$close.call(fs, 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.close);
-
-	  fs.closeSync = (function (fs$closeSync) {
-	    function closeSync (fd) {
-	      // This function uses the graceful-fs shared queue
-	      fs$closeSync.apply(fs, arguments);
-	      resetQueue();
-	    }
-
-	    Object.defineProperty(closeSync, previousSymbol, {
-	      value: fs$closeSync
-	    });
-	    return closeSync
-	  })(fs.closeSync);
-
-	  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-	    process.on('exit', function() {
-	      debug(fs[gracefulQueue]);
-	      Mi.equal(fs[gracefulQueue].length, 0);
-	    });
-	  }
-	}
-
-	if (!commonjsGlobal[gracefulQueue]) {
-	  publishQueue(commonjsGlobal, fs[gracefulQueue]);
-	}
-
-	gracefulFs = patch(clone(fs));
-	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-	    gracefulFs = patch(fs);
-	    fs.__patched = true;
-	}
-
-	function patch (fs) {
-	  // Everything that references the open() function needs to be in here
-	  polyfills(fs);
-	  fs.gracefulify = patch;
-
-	  fs.createReadStream = createReadStream;
-	  fs.createWriteStream = createWriteStream;
-	  var fs$readFile = fs.readFile;
-	  fs.readFile = readFile;
-	  function readFile (path, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$readFile(path, options, cb)
-
-	    function go$readFile (path, options, cb, startTime) {
-	      return fs$readFile(path, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$writeFile = fs.writeFile;
-	  fs.writeFile = writeFile;
-	  function writeFile (path, data, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$writeFile(path, data, options, cb)
-
-	    function go$writeFile (path, data, options, cb, startTime) {
-	      return fs$writeFile(path, data, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$appendFile = fs.appendFile;
-	  if (fs$appendFile)
-	    fs.appendFile = appendFile;
-	  function appendFile (path, data, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$appendFile(path, data, options, cb)
-
-	    function go$appendFile (path, data, options, cb, startTime) {
-	      return fs$appendFile(path, data, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$copyFile = fs.copyFile;
-	  if (fs$copyFile)
-	    fs.copyFile = copyFile;
-	  function copyFile (src, dest, flags, cb) {
-	    if (typeof flags === 'function') {
-	      cb = flags;
-	      flags = 0;
-	    }
-	    return go$copyFile(src, dest, flags, cb)
-
-	    function go$copyFile (src, dest, flags, cb, startTime) {
-	      return fs$copyFile(src, dest, flags, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$readdir = fs.readdir;
-	  fs.readdir = readdir;
-	  var noReaddirOptionVersions = /^v[0-5]\./;
-	  function readdir (path, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    var go$readdir = noReaddirOptionVersions.test(process.version)
-	      ? function go$readdir (path, options, cb, startTime) {
-	        return fs$readdir(path, fs$readdirCallback(
-	          path, options, cb, startTime
-	        ))
-	      }
-	      : function go$readdir (path, options, cb, startTime) {
-	        return fs$readdir(path, options, fs$readdirCallback(
-	          path, options, cb, startTime
-	        ))
-	      };
-
-	    return go$readdir(path, options, cb)
-
-	    function fs$readdirCallback (path, options, cb, startTime) {
-	      return function (err, files) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([
-	            go$readdir,
-	            [path, options, cb],
-	            err,
-	            startTime || Date.now(),
-	            Date.now()
-	          ]);
-	        else {
-	          if (files && files.sort)
-	            files.sort();
-
-	          if (typeof cb === 'function')
-	            cb.call(this, err, files);
-	        }
-	      }
-	    }
-	  }
-
-	  if (process.version.substr(0, 4) === 'v0.8') {
-	    var legStreams = legacy(fs);
-	    ReadStream = legStreams.ReadStream;
-	    WriteStream = legStreams.WriteStream;
-	  }
-
-	  var fs$ReadStream = fs.ReadStream;
-	  if (fs$ReadStream) {
-	    ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-	    ReadStream.prototype.open = ReadStream$open;
-	  }
-
-	  var fs$WriteStream = fs.WriteStream;
-	  if (fs$WriteStream) {
-	    WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-	    WriteStream.prototype.open = WriteStream$open;
-	  }
-
-	  Object.defineProperty(fs, 'ReadStream', {
-	    get: function () {
-	      return ReadStream
-	    },
-	    set: function (val) {
-	      ReadStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-	  Object.defineProperty(fs, 'WriteStream', {
-	    get: function () {
-	      return WriteStream
-	    },
-	    set: function (val) {
-	      WriteStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-
-	  // legacy names
-	  var FileReadStream = ReadStream;
-	  Object.defineProperty(fs, 'FileReadStream', {
-	    get: function () {
-	      return FileReadStream
-	    },
-	    set: function (val) {
-	      FileReadStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-	  var FileWriteStream = WriteStream;
-	  Object.defineProperty(fs, 'FileWriteStream', {
-	    get: function () {
-	      return FileWriteStream
-	    },
-	    set: function (val) {
-	      FileWriteStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-
-	  function ReadStream (path, options) {
-	    if (this instanceof ReadStream)
-	      return fs$ReadStream.apply(this, arguments), this
-	    else
-	      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
-	  }
-
-	  function ReadStream$open () {
-	    var that = this;
-	    open(that.path, that.flags, that.mode, function (err, fd) {
-	      if (err) {
-	        if (that.autoClose)
-	          that.destroy();
-
-	        that.emit('error', err);
-	      } else {
-	        that.fd = fd;
-	        that.emit('open', fd);
-	        that.read();
-	      }
-	    });
-	  }
-
-	  function WriteStream (path, options) {
-	    if (this instanceof WriteStream)
-	      return fs$WriteStream.apply(this, arguments), this
-	    else
-	      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
-	  }
-
-	  function WriteStream$open () {
-	    var that = this;
-	    open(that.path, that.flags, that.mode, function (err, fd) {
-	      if (err) {
-	        that.destroy();
-	        that.emit('error', err);
-	      } else {
-	        that.fd = fd;
-	        that.emit('open', fd);
-	      }
-	    });
-	  }
-
-	  function createReadStream (path, options) {
-	    return new fs.ReadStream(path, options)
-	  }
-
-	  function createWriteStream (path, options) {
-	    return new fs.WriteStream(path, options)
-	  }
-
-	  var fs$open = fs.open;
-	  fs.open = open;
-	  function open (path, flags, mode, cb) {
-	    if (typeof mode === 'function')
-	      cb = mode, mode = null;
-
-	    return go$open(path, flags, mode, cb)
-
-	    function go$open (path, flags, mode, cb, startTime) {
-	      return fs$open(path, flags, mode, function (err, fd) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  return fs
-	}
-
-	function enqueue (elem) {
-	  debug('ENQUEUE', elem[0].name, elem[1]);
-	  fs[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[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[gracefulQueue][i].length > 2) {
-	      fs[gracefulQueue][i][3] = now; // startTime
-	      fs[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[gracefulQueue].length === 0)
-	    return
-
-	  var elem = fs[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[gracefulQueue].push(elem);
-	    }
-	  }
-
-	  // schedule our next run if one isn't already scheduled
-	  if (retryTimer === undefined) {
-	    retryTimer = setTimeout(retry, 0);
-	  }
-	}
-	return gracefulFs;
-}
-
-var retry$1 = {};
-
-var retry_operation;
-var hasRequiredRetry_operation;
-
-function requireRetry_operation () {
-	if (hasRequiredRetry_operation) return retry_operation;
-	hasRequiredRetry_operation = 1;
-	function RetryOperation(timeouts, options) {
-	  // Compatibility for the old (timeouts, retryForever) signature
-	  if (typeof options === 'boolean') {
-	    options = { forever: options };
-	  }
-
-	  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-	  this._timeouts = timeouts;
-	  this._options = options || {};
-	  this._maxRetryTime = options && options.maxRetryTime || Infinity;
-	  this._fn = null;
-	  this._errors = [];
-	  this._attempts = 1;
-	  this._operationTimeout = null;
-	  this._operationTimeoutCb = null;
-	  this._timeout = null;
-	  this._operationStart = null;
-
-	  if (this._options.forever) {
-	    this._cachedTimeouts = this._timeouts.slice(0);
-	  }
-	}
-	retry_operation = RetryOperation;
-
-	RetryOperation.prototype.reset = function() {
-	  this._attempts = 1;
-	  this._timeouts = this._originalTimeouts;
-	};
-
-	RetryOperation.prototype.stop = function() {
-	  if (this._timeout) {
-	    clearTimeout(this._timeout);
-	  }
-
-	  this._timeouts       = [];
-	  this._cachedTimeouts = null;
-	};
-
-	RetryOperation.prototype.retry = function(err) {
-	  if (this._timeout) {
-	    clearTimeout(this._timeout);
-	  }
-
-	  if (!err) {
-	    return false;
-	  }
-	  var currentTime = new Date().getTime();
-	  if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-	    this._errors.unshift(new Error('RetryOperation timeout occurred'));
-	    return false;
-	  }
-
-	  this._errors.push(err);
-
-	  var timeout = this._timeouts.shift();
-	  if (timeout === undefined) {
-	    if (this._cachedTimeouts) {
-	      // retry forever, only keep last error
-	      this._errors.splice(this._errors.length - 1, this._errors.length);
-	      this._timeouts = this._cachedTimeouts.slice(0);
-	      timeout = this._timeouts.shift();
-	    } else {
-	      return false;
-	    }
-	  }
-
-	  var self = this;
-	  var timer = setTimeout(function() {
-	    self._attempts++;
-
-	    if (self._operationTimeoutCb) {
-	      self._timeout = setTimeout(function() {
-	        self._operationTimeoutCb(self._attempts);
-	      }, self._operationTimeout);
-
-	      if (self._options.unref) {
-	          self._timeout.unref();
-	      }
-	    }
-
-	    self._fn(self._attempts);
-	  }, timeout);
-
-	  if (this._options.unref) {
-	      timer.unref();
-	  }
-
-	  return true;
-	};
-
-	RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-	  this._fn = fn;
-
-	  if (timeoutOps) {
-	    if (timeoutOps.timeout) {
-	      this._operationTimeout = timeoutOps.timeout;
-	    }
-	    if (timeoutOps.cb) {
-	      this._operationTimeoutCb = timeoutOps.cb;
-	    }
-	  }
-
-	  var self = this;
-	  if (this._operationTimeoutCb) {
-	    this._timeout = setTimeout(function() {
-	      self._operationTimeoutCb();
-	    }, self._operationTimeout);
-	  }
-
-	  this._operationStart = new Date().getTime();
-
-	  this._fn(this._attempts);
-	};
-
-	RetryOperation.prototype.try = function(fn) {
-	  console.log('Using RetryOperation.try() is deprecated');
-	  this.attempt(fn);
-	};
-
-	RetryOperation.prototype.start = function(fn) {
-	  console.log('Using RetryOperation.start() is deprecated');
-	  this.attempt(fn);
-	};
-
-	RetryOperation.prototype.start = RetryOperation.prototype.try;
-
-	RetryOperation.prototype.errors = function() {
-	  return this._errors;
-	};
-
-	RetryOperation.prototype.attempts = function() {
-	  return this._attempts;
-	};
-
-	RetryOperation.prototype.mainError = function() {
-	  if (this._errors.length === 0) {
-	    return null;
-	  }
-
-	  var counts = {};
-	  var mainError = null;
-	  var mainErrorCount = 0;
-
-	  for (var i = 0; i < this._errors.length; i++) {
-	    var error = this._errors[i];
-	    var message = error.message;
-	    var count = (counts[message] || 0) + 1;
-
-	    counts[message] = count;
-
-	    if (count >= mainErrorCount) {
-	      mainError = error;
-	      mainErrorCount = count;
-	    }
-	  }
-
-	  return mainError;
-	};
-	return retry_operation;
-}
-
-var hasRequiredRetry$1;
-
-function requireRetry$1 () {
-	if (hasRequiredRetry$1) return retry$1;
-	hasRequiredRetry$1 = 1;
-	(function (exports$1) {
-		var RetryOperation = requireRetry_operation();
-
-		exports$1.operation = function(options) {
-		  var timeouts = exports$1.timeouts(options);
-		  return new RetryOperation(timeouts, {
-		      forever: options && options.forever,
-		      unref: options && options.unref,
-		      maxRetryTime: options && options.maxRetryTime
-		  });
-		};
-
-		exports$1.timeouts = function(options) {
-		  if (options instanceof Array) {
-		    return [].concat(options);
-		  }
-
-		  var opts = {
-		    retries: 10,
-		    factor: 2,
-		    minTimeout: 1 * 1000,
-		    maxTimeout: Infinity,
-		    randomize: false
-		  };
-		  for (var key in options) {
-		    opts[key] = options[key];
-		  }
-
-		  if (opts.minTimeout > opts.maxTimeout) {
-		    throw new Error('minTimeout is greater than maxTimeout');
-		  }
-
-		  var timeouts = [];
-		  for (var i = 0; i < opts.retries; i++) {
-		    timeouts.push(this.createTimeout(i, opts));
-		  }
-
-		  if (options && options.forever && !timeouts.length) {
-		    timeouts.push(this.createTimeout(i, opts));
-		  }
-
-		  // sort the array numerically ascending
-		  timeouts.sort(function(a,b) {
-		    return a - b;
-		  });
-
-		  return timeouts;
-		};
-
-		exports$1.createTimeout = function(attempt, opts) {
-		  var random = (opts.randomize)
-		    ? (Math.random() + 1)
-		    : 1;
-
-		  var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
-		  timeout = Math.min(timeout, opts.maxTimeout);
-
-		  return timeout;
-		};
-
-		exports$1.wrap = function(obj, options, methods) {
-		  if (options instanceof Array) {
-		    methods = options;
-		    options = null;
-		  }
-
-		  if (!methods) {
-		    methods = [];
-		    for (var key in obj) {
-		      if (typeof obj[key] === 'function') {
-		        methods.push(key);
-		      }
-		    }
-		  }
-
-		  for (var i = 0; i < methods.length; i++) {
-		    var method   = methods[i];
-		    var original = obj[method];
-
-		    obj[method] = function retryWrapper(original) {
-		      var op       = exports$1.operation(options);
-		      var args     = Array.prototype.slice.call(arguments, 1);
-		      var callback = args.pop();
-
-		      args.push(function(err) {
-		        if (op.retry(err)) {
-		          return;
-		        }
-		        if (err) {
-		          arguments[0] = op.mainError();
-		        }
-		        callback.apply(this, arguments);
-		      });
-
-		      op.attempt(function() {
-		        original.apply(obj, args);
-		      });
-		    }.bind(obj, original);
-		    obj[method].options = options;
-		  }
-		}; 
-	} (retry$1));
-	return retry$1;
-}
-
-var retry;
-var hasRequiredRetry;
-
-function requireRetry () {
-	if (hasRequiredRetry) return retry;
-	hasRequiredRetry = 1;
-	retry = requireRetry$1();
-	return retry;
-}
-
-var signalExit = {exports: {}};
-
-var signals = {exports: {}};
-
-var hasRequiredSignals;
-
-function requireSignals () {
-	if (hasRequiredSignals) return signals.exports;
-	hasRequiredSignals = 1;
-	(function (module) {
-		// This is not the set of all possible signals.
-		//
-		// It IS, however, the set of all signals that trigger
-		// an exit on either Linux or BSD systems.  Linux is a
-		// superset of the signal names supported on BSD, and
-		// the unknown signals just fail to register, so we can
-		// catch that easily enough.
-		//
-		// Don't bother with SIGKILL.  It's uncatchable, which
-		// means that we can't fire any callbacks anyway.
-		//
-		// If a user does happen to register a handler on a non-
-		// fatal signal like SIGWINCH or something, and then
-		// exit, it'll end up firing `process.emit('exit')`, so
-		// the handler will be fired anyway.
-		//
-		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-		// artificially, inherently leave the process in a
-		// state from which it is not safe to try and enter JS
-		// listeners.
-		module.exports = [
-		  'SIGABRT',
-		  'SIGALRM',
-		  'SIGHUP',
-		  'SIGINT',
-		  'SIGTERM'
-		];
-
-		if (process.platform !== 'win32') {
-		  module.exports.push(
-		    'SIGVTALRM',
-		    'SIGXCPU',
-		    'SIGXFSZ',
-		    'SIGUSR2',
-		    'SIGTRAP',
-		    'SIGSYS',
-		    'SIGQUIT',
-		    'SIGIOT'
-		    // should detect profiler and enable/disable accordingly.
-		    // see #21
-		    // 'SIGPROF'
-		  );
-		}
-
-		if (process.platform === 'linux') {
-		  module.exports.push(
-		    'SIGIO',
-		    'SIGPOLL',
-		    'SIGPWR',
-		    'SIGSTKFLT',
-		    'SIGUNUSED'
-		  );
-		} 
-	} (signals));
-	return signals.exports;
-}
-
-var hasRequiredSignalExit;
-
-function requireSignalExit () {
-	if (hasRequiredSignalExit) return signalExit.exports;
-	hasRequiredSignalExit = 1;
-	// Note: since nyc uses this module to output coverage, any lines
-	// that are in the direct sync flow of nyc's outputCoverage are
-	// ignored, since we can never get coverage for them.
-	// grab a reference to node's real process object right away
-	var process = commonjsGlobal.process;
-
-	const processOk = function (process) {
-	  return process &&
-	    typeof process === 'object' &&
-	    typeof process.removeListener === 'function' &&
-	    typeof process.emit === 'function' &&
-	    typeof process.reallyExit === 'function' &&
-	    typeof process.listeners === 'function' &&
-	    typeof process.kill === 'function' &&
-	    typeof process.pid === 'number' &&
-	    typeof process.on === 'function'
-	};
-
-	// some kind of non-node environment, just no-op
-	/* istanbul ignore if */
-	if (!processOk(process)) {
-	  signalExit.exports = function () {
-	    return function () {}
-	  };
-	} else {
-	  var assert = Mi;
-	  var signals = requireSignals();
-	  var isWin = /^win/i.test(process.platform);
-
-	  var EE = require$$1;
-	  /* istanbul ignore if */
-	  if (typeof EE !== 'function') {
-	    EE = EE.EventEmitter;
-	  }
-
-	  var emitter;
-	  if (process.__signal_exit_emitter__) {
-	    emitter = process.__signal_exit_emitter__;
-	  } else {
-	    emitter = process.__signal_exit_emitter__ = new EE();
-	    emitter.count = 0;
-	    emitter.emitted = {};
-	  }
-
-	  // Because this emitter is a global, we have to check to see if a
-	  // previous version of this library failed to enable infinite listeners.
-	  // I know what you're about to say.  But literally everything about
-	  // signal-exit is a compromise with evil.  Get used to it.
-	  if (!emitter.infinite) {
-	    emitter.setMaxListeners(Infinity);
-	    emitter.infinite = true;
-	  }
-
-	  signalExit.exports = function (cb, opts) {
-	    /* istanbul ignore if */
-	    if (!processOk(commonjsGlobal.process)) {
-	      return function () {}
-	    }
-	    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
-
-	    if (loaded === false) {
-	      load();
-	    }
-
-	    var ev = 'exit';
-	    if (opts && opts.alwaysLast) {
-	      ev = 'afterexit';
-	    }
-
-	    var remove = function () {
-	      emitter.removeListener(ev, cb);
-	      if (emitter.listeners('exit').length === 0 &&
-	          emitter.listeners('afterexit').length === 0) {
-	        unload();
-	      }
-	    };
-	    emitter.on(ev, cb);
-
-	    return remove
-	  };
-
-	  var unload = function unload () {
-	    if (!loaded || !processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    loaded = false;
-
-	    signals.forEach(function (sig) {
-	      try {
-	        process.removeListener(sig, sigListeners[sig]);
-	      } catch (er) {}
-	    });
-	    process.emit = originalProcessEmit;
-	    process.reallyExit = originalProcessReallyExit;
-	    emitter.count -= 1;
-	  };
-	  signalExit.exports.unload = unload;
-
-	  var emit = function emit (event, code, signal) {
-	    /* istanbul ignore if */
-	    if (emitter.emitted[event]) {
-	      return
-	    }
-	    emitter.emitted[event] = true;
-	    emitter.emit(event, code, signal);
-	  };
-
-	  // { <signal>: <listener fn>, ... }
-	  var sigListeners = {};
-	  signals.forEach(function (sig) {
-	    sigListeners[sig] = function listener () {
-	      /* istanbul ignore if */
-	      if (!processOk(commonjsGlobal.process)) {
-	        return
-	      }
-	      // If there are no other listeners, an exit is coming!
-	      // Simplest way: remove us and then re-send the signal.
-	      // We know that this will kill the process, so we can
-	      // safely emit now.
-	      var listeners = process.listeners(sig);
-	      if (listeners.length === emitter.count) {
-	        unload();
-	        emit('exit', null, sig);
-	        /* istanbul ignore next */
-	        emit('afterexit', null, sig);
-	        /* istanbul ignore next */
-	        if (isWin && sig === 'SIGHUP') {
-	          // "SIGHUP" throws an `ENOSYS` error on Windows,
-	          // so use a supported signal instead
-	          sig = 'SIGINT';
-	        }
-	        /* istanbul ignore next */
-	        process.kill(process.pid, sig);
-	      }
-	    };
-	  });
-
-	  signalExit.exports.signals = function () {
-	    return signals
-	  };
-
-	  var loaded = false;
-
-	  var load = function load () {
-	    if (loaded || !processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    loaded = true;
-
-	    // This is the number of onSignalExit's that are in play.
-	    // It's important so that we can count the correct number of
-	    // listeners on signals, and don't wait for the other one to
-	    // handle it instead of us.
-	    emitter.count += 1;
-
-	    signals = signals.filter(function (sig) {
-	      try {
-	        process.on(sig, sigListeners[sig]);
-	        return true
-	      } catch (er) {
-	        return false
-	      }
-	    });
-
-	    process.emit = processEmit;
-	    process.reallyExit = processReallyExit;
-	  };
-	  signalExit.exports.load = load;
-
-	  var originalProcessReallyExit = process.reallyExit;
-	  var processReallyExit = function processReallyExit (code) {
-	    /* istanbul ignore if */
-	    if (!processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    process.exitCode = code || /* istanbul ignore next */ 0;
-	    emit('exit', process.exitCode, null);
-	    /* istanbul ignore next */
-	    emit('afterexit', process.exitCode, null);
-	    /* istanbul ignore next */
-	    originalProcessReallyExit.call(process, process.exitCode);
-	  };
-
-	  var originalProcessEmit = process.emit;
-	  var processEmit = function processEmit (ev, arg) {
-	    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
-	      /* istanbul ignore else */
-	      if (arg !== undefined) {
-	        process.exitCode = arg;
-	      }
-	      var ret = originalProcessEmit.apply(this, arguments);
-	      /* istanbul ignore next */
-	      emit('exit', process.exitCode, null);
-	      /* istanbul ignore next */
-	      emit('afterexit', process.exitCode, null);
-	      /* istanbul ignore next */
-	      return ret
-	    } else {
-	      return originalProcessEmit.apply(this, arguments)
-	    }
-	  };
-	}
-	return signalExit.exports;
-}
-
-var mtimePrecision = {};
-
-var hasRequiredMtimePrecision;
-
-function requireMtimePrecision () {
-	if (hasRequiredMtimePrecision) return mtimePrecision;
-	hasRequiredMtimePrecision = 1;
-
-	const cacheSymbol = Symbol();
-
-	function probe(file, fs, callback) {
-	    const cachedPrecision = fs[cacheSymbol];
-
-	    if (cachedPrecision) {
-	        return fs.stat(file, (err, stat) => {
-	            /* istanbul ignore if */
-	            if (err) {
-	                return callback(err);
-	            }
-
-	            callback(null, stat.mtime, cachedPrecision);
-	        });
-	    }
-
-	    // Set mtime by ceiling Date.now() to seconds + 5ms so that it's "not on the second"
-	    const mtime = new Date((Math.ceil(Date.now() / 1000) * 1000) + 5);
-
-	    fs.utimes(file, mtime, mtime, (err) => {
-	        /* istanbul ignore if */
-	        if (err) {
-	            return callback(err);
-	        }
-
-	        fs.stat(file, (err, stat) => {
-	            /* istanbul ignore if */
-	            if (err) {
-	                return callback(err);
-	            }
-
-	            const precision = stat.mtime.getTime() % 1000 === 0 ? 's' : 'ms';
-
-	            // Cache the precision in a non-enumerable way
-	            Object.defineProperty(fs, cacheSymbol, { value: precision });
-
-	            callback(null, stat.mtime, precision);
-	        });
-	    });
-	}
-
-	function getMtime(precision) {
-	    let now = Date.now();
-
-	    if (precision === 's') {
-	        now = Math.ceil(now / 1000) * 1000;
-	    }
-
-	    return new Date(now);
-	}
-
-	mtimePrecision.probe = probe;
-	mtimePrecision.getMtime = getMtime;
-	return mtimePrecision;
-}
-
-var hasRequiredLockfile;
-
-function requireLockfile () {
-	if (hasRequiredLockfile) return lockfile$1;
-	hasRequiredLockfile = 1;
-
-	const path$1 = path;
-	const fs = requireGracefulFs();
-	const retry = requireRetry();
-	const onExit = requireSignalExit();
-	const mtimePrecision = requireMtimePrecision();
-
-	const locks = {};
-
-	function getLockFile(file, options) {
-	    return options.lockfilePath || `${file}.lock`;
-	}
-
-	function resolveCanonicalPath(file, options, callback) {
-	    if (!options.realpath) {
-	        return callback(null, path$1.resolve(file));
-	    }
-
-	    // Use realpath to resolve symlinks
-	    // It also resolves relative paths
-	    options.fs.realpath(file, callback);
-	}
-
-	function acquireLock(file, options, callback) {
-	    const lockfilePath = getLockFile(file, options);
-
-	    // Use mkdir to create the lockfile (atomic operation)
-	    options.fs.mkdir(lockfilePath, (err) => {
-	        if (!err) {
-	            // At this point, we acquired the lock!
-	            // Probe the mtime precision
-	            return mtimePrecision.probe(lockfilePath, options.fs, (err, mtime, mtimePrecision) => {
-	                // If it failed, try to remove the lock..
-	                /* istanbul ignore if */
-	                if (err) {
-	                    options.fs.rmdir(lockfilePath, () => {});
-
-	                    return callback(err);
-	                }
-
-	                callback(null, mtime, mtimePrecision);
-	            });
-	        }
-
-	        // If error is not EEXIST then some other error occurred while locking
-	        if (err.code !== 'EEXIST') {
-	            return callback(err);
-	        }
-
-	        // Otherwise, check if lock is stale by analyzing the file mtime
-	        if (options.stale <= 0) {
-	            return callback(Object.assign(new Error('Lock file is already being held'), { code: 'ELOCKED', file }));
-	        }
-
-	        options.fs.stat(lockfilePath, (err, stat) => {
-	            if (err) {
-	                // Retry if the lockfile has been removed (meanwhile)
-	                // Skip stale check to avoid recursiveness
-	                if (err.code === 'ENOENT') {
-	                    return acquireLock(file, { ...options, stale: 0 }, callback);
-	                }
-
-	                return callback(err);
-	            }
-
-	            if (!isLockStale(stat, options)) {
-	                return callback(Object.assign(new Error('Lock file is already being held'), { code: 'ELOCKED', file }));
-	            }
-
-	            // If it's stale, remove it and try again!
-	            // Skip stale check to avoid recursiveness
-	            removeLock(file, options, (err) => {
-	                if (err) {
-	                    return callback(err);
-	                }
-
-	                acquireLock(file, { ...options, stale: 0 }, callback);
-	            });
-	        });
-	    });
-	}
-
-	function isLockStale(stat, options) {
-	    return stat.mtime.getTime() < Date.now() - options.stale;
-	}
-
-	function removeLock(file, options, callback) {
-	    // Remove lockfile, ignoring ENOENT errors
-	    options.fs.rmdir(getLockFile(file, options), (err) => {
-	        if (err && err.code !== 'ENOENT') {
-	            return callback(err);
-	        }
-
-	        callback();
-	    });
-	}
-
-	function updateLock(file, options) {
-	    const lock = locks[file];
-
-	    // Just for safety, should never happen
-	    /* istanbul ignore if */
-	    if (lock.updateTimeout) {
-	        return;
-	    }
-
-	    lock.updateDelay = lock.updateDelay || options.update;
-	    lock.updateTimeout = setTimeout(() => {
-	        lock.updateTimeout = null;
-
-	        // Stat the file to check if mtime is still ours
-	        // If it is, we can still recover from a system sleep or a busy event loop
-	        options.fs.stat(lock.lockfilePath, (err, stat) => {
-	            const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
-
-	            // If it failed to update the lockfile, keep trying unless
-	            // the lockfile was deleted or we are over the threshold
-	            if (err) {
-	                if (err.code === 'ENOENT' || isOverThreshold) {
-	                    return setLockAsCompromised(file, lock, Object.assign(err, { code: 'ECOMPROMISED' }));
-	                }
-
-	                lock.updateDelay = 1000;
-
-	                return updateLock(file, options);
-	            }
-
-	            const isMtimeOurs = lock.mtime.getTime() === stat.mtime.getTime();
-
-	            if (!isMtimeOurs) {
-	                return setLockAsCompromised(
-	                    file,
-	                    lock,
-	                    Object.assign(
-	                        new Error('Unable to update lock within the stale threshold'),
-	                        { code: 'ECOMPROMISED' }
-	                    ));
-	            }
-
-	            const mtime = mtimePrecision.getMtime(lock.mtimePrecision);
-
-	            options.fs.utimes(lock.lockfilePath, mtime, mtime, (err) => {
-	                const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
-
-	                // Ignore if the lock was released
-	                if (lock.released) {
-	                    return;
-	                }
-
-	                // If it failed to update the lockfile, keep trying unless
-	                // the lockfile was deleted or we are over the threshold
-	                if (err) {
-	                    if (err.code === 'ENOENT' || isOverThreshold) {
-	                        return setLockAsCompromised(file, lock, Object.assign(err, { code: 'ECOMPROMISED' }));
-	                    }
-
-	                    lock.updateDelay = 1000;
-
-	                    return updateLock(file, options);
-	                }
-
-	                // All ok, keep updating..
-	                lock.mtime = mtime;
-	                lock.lastUpdate = Date.now();
-	                lock.updateDelay = null;
-	                updateLock(file, options);
-	            });
-	        });
-	    }, lock.updateDelay);
-
-	    // Unref the timer so that the nodejs process can exit freely
-	    // This is safe because all acquired locks will be automatically released
-	    // on process exit
-
-	    // We first check that `lock.updateTimeout.unref` exists because some users
-	    // may be using this module outside of NodeJS (e.g., in an electron app),
-	    // and in those cases `setTimeout` return an integer.
-	    /* istanbul ignore else */
-	    if (lock.updateTimeout.unref) {
-	        lock.updateTimeout.unref();
-	    }
-	}
-
-	function setLockAsCompromised(file, lock, err) {
-	    // Signal the lock has been released
-	    lock.released = true;
-
-	    // Cancel lock mtime update
-	    // Just for safety, at this point updateTimeout should be null
-	    /* istanbul ignore if */
-	    if (lock.updateTimeout) {
-	        clearTimeout(lock.updateTimeout);
-	    }
-
-	    if (locks[file] === lock) {
-	        delete locks[file];
-	    }
-
-	    lock.options.onCompromised(err);
-	}
-
-	// ----------------------------------------------------------
-
-	function lock(file, options, callback) {
-	    /* istanbul ignore next */
-	    options = {
-	        stale: 10000,
-	        update: null,
-	        realpath: true,
-	        retries: 0,
-	        fs,
-	        onCompromised: (err) => { throw err; },
-	        ...options,
-	    };
-
-	    options.retries = options.retries || 0;
-	    options.retries = typeof options.retries === 'number' ? { retries: options.retries } : options.retries;
-	    options.stale = Math.max(options.stale || 0, 2000);
-	    options.update = options.update == null ? options.stale / 2 : options.update || 0;
-	    options.update = Math.max(Math.min(options.update, options.stale / 2), 1000);
-
-	    // Resolve to a canonical file path
-	    resolveCanonicalPath(file, options, (err, file) => {
-	        if (err) {
-	            return callback(err);
-	        }
-
-	        // Attempt to acquire the lock
-	        const operation = retry.operation(options.retries);
-
-	        operation.attempt(() => {
-	            acquireLock(file, options, (err, mtime, mtimePrecision) => {
-	                if (operation.retry(err)) {
-	                    return;
-	                }
-
-	                if (err) {
-	                    return callback(operation.mainError());
-	                }
-
-	                // We now own the lock
-	                const lock = locks[file] = {
-	                    lockfilePath: getLockFile(file, options),
-	                    mtime,
-	                    mtimePrecision,
-	                    options,
-	                    lastUpdate: Date.now(),
-	                };
-
-	                // We must keep the lock fresh to avoid staleness
-	                updateLock(file, options);
-
-	                callback(null, (releasedCallback) => {
-	                    if (lock.released) {
-	                        return releasedCallback &&
-	                            releasedCallback(Object.assign(new Error('Lock is already released'), { code: 'ERELEASED' }));
-	                    }
-
-	                    // Not necessary to use realpath twice when unlocking
-	                    unlock(file, { ...options, realpath: false }, releasedCallback);
-	                });
-	            });
-	        });
-	    });
-	}
-
-	function unlock(file, options, callback) {
-	    options = {
-	        fs,
-	        realpath: true,
-	        ...options,
-	    };
-
-	    // Resolve to a canonical file path
-	    resolveCanonicalPath(file, options, (err, file) => {
-	        if (err) {
-	            return callback(err);
-	        }
-
-	        // Skip if the lock is not acquired
-	        const lock = locks[file];
-
-	        if (!lock) {
-	            return callback(Object.assign(new Error('Lock is not acquired/owned by you'), { code: 'ENOTACQUIRED' }));
-	        }
-
-	        lock.updateTimeout && clearTimeout(lock.updateTimeout); // Cancel lock mtime update
-	        lock.released = true; // Signal the lock has been released
-	        delete locks[file]; // Delete from locks
-
-	        removeLock(file, options, callback);
-	    });
-	}
-
-	function check(file, options, callback) {
-	    options = {
-	        stale: 10000,
-	        realpath: true,
-	        fs,
-	        ...options,
-	    };
-
-	    options.stale = Math.max(options.stale || 0, 2000);
-
-	    // Resolve to a canonical file path
-	    resolveCanonicalPath(file, options, (err, file) => {
-	        if (err) {
-	            return callback(err);
-	        }
-
-	        // Check if lockfile exists
-	        options.fs.stat(getLockFile(file, options), (err, stat) => {
-	            if (err) {
-	                // If does not exist, file is not locked. Otherwise, callback with error
-	                return err.code === 'ENOENT' ? callback(null, false) : callback(err);
-	            }
-
-	            // Otherwise, check if lock is stale by analyzing the file mtime
-	            return callback(null, !isLockStale(stat, options));
-	        });
-	    });
-	}
-
-	function getLocks() {
-	    return locks;
-	}
-
-	// Remove acquired locks on exit
-	/* istanbul ignore next */
-	onExit(() => {
-	    for (const file in locks) {
-	        const options = locks[file].options;
-
-	        try { options.fs.rmdirSync(getLockFile(file, options)); } catch (e) { /* Empty */ }
-	    }
-	});
-
-	lockfile$1.lock = lock;
-	lockfile$1.unlock = unlock;
-	lockfile$1.check = check;
-	lockfile$1.getLocks = getLocks;
-	return lockfile$1;
-}
-
-var adapter;
-var hasRequiredAdapter;
-
-function requireAdapter () {
-	if (hasRequiredAdapter) return adapter;
-	hasRequiredAdapter = 1;
-
-	const fs = requireGracefulFs();
-
-	function createSyncFs(fs) {
-	    const methods = ['mkdir', 'realpath', 'stat', 'rmdir', 'utimes'];
-	    const newFs = { ...fs };
-
-	    methods.forEach((method) => {
-	        newFs[method] = (...args) => {
-	            const callback = args.pop();
-	            let ret;
-
-	            try {
-	                ret = fs[`${method}Sync`](...args);
-	            } catch (err) {
-	                return callback(err);
-	            }
-
-	            callback(null, ret);
-	        };
-	    });
-
-	    return newFs;
-	}
-
-	// ----------------------------------------------------------
-
-	function toPromise(method) {
-	    return (...args) => new Promise((resolve, reject) => {
-	        args.push((err, result) => {
-	            if (err) {
-	                reject(err);
-	            } else {
-	                resolve(result);
-	            }
-	        });
-
-	        method(...args);
-	    });
-	}
-
-	function toSync(method) {
-	    return (...args) => {
-	        let err;
-	        let result;
-
-	        args.push((_err, _result) => {
-	            err = _err;
-	            result = _result;
-	        });
-
-	        method(...args);
-
-	        if (err) {
-	            throw err;
-	        }
-
-	        return result;
-	    };
-	}
-
-	function toSyncOptions(options) {
-	    // Shallow clone options because we are oging to mutate them
-	    options = { ...options };
-
-	    // Transform fs to use the sync methods instead
-	    options.fs = createSyncFs(options.fs || fs);
-
-	    // Retries are not allowed because it requires the flow to be sync
-	    if (
-	        (typeof options.retries === 'number' && options.retries > 0) ||
-	        (options.retries && typeof options.retries.retries === 'number' && options.retries.retries > 0)
-	    ) {
-	        throw Object.assign(new Error('Cannot use retries with the sync api'), { code: 'ESYNC' });
-	    }
-
-	    return options;
-	}
-
-	adapter = {
-	    toPromise,
-	    toSync,
-	    toSyncOptions,
-	};
-	return adapter;
-}
-
-var hasRequiredProperLockfile;
-
-function requireProperLockfile () {
-	if (hasRequiredProperLockfile) return properLockfile.exports;
-	hasRequiredProperLockfile = 1;
-
-	const lockfile = requireLockfile();
-	const { toPromise, toSync, toSyncOptions } = requireAdapter();
-
-	async function lock(file, options) {
-	    const release = await toPromise(lockfile.lock)(file, options);
-
-	    return toPromise(release);
-	}
-
-	function lockSync(file, options) {
-	    const release = toSync(lockfile.lock)(file, toSyncOptions(options));
-
-	    return toSync(release);
-	}
-
-	function unlock(file, options) {
-	    return toPromise(lockfile.unlock)(file, options);
-	}
-
-	function unlockSync(file, options) {
-	    return toSync(lockfile.unlock)(file, toSyncOptions(options));
-	}
-
-	function check(file, options) {
-	    return toPromise(lockfile.check)(file, options);
-	}
-
-	function checkSync(file, options) {
-	    return toSync(lockfile.check)(file, toSyncOptions(options));
-	}
-
-	properLockfile.exports = lock;
-	properLockfile.exports.lock = lock;
-	properLockfile.exports.unlock = unlock;
-	properLockfile.exports.lockSync = lockSync;
-	properLockfile.exports.unlockSync = unlockSync;
-	properLockfile.exports.check = check;
-	properLockfile.exports.checkSync = checkSync;
-	return properLockfile.exports;
-}
-
-var properLockfileExports = requireProperLockfile();
-var lockfile = /*@__PURE__*/getDefaultExportFromCjs(properLockfileExports);
-
-export { lockfile as l, properLockfileExports as p };
-//# sourceMappingURL=index-Dtt_h58T.js.map