weapp-tailwindcss 3.5.2 → 3.5.3

package/dist/cli.mjs

@@ -1,7 +1,16 @@
-import process from 'node:process';
+import process$1 from 'node:process';
 import semver from 'semver';
 import { W as WEAPP_TW_REQUIRED_NODE_VERSION } from './index-zFq7tKDr.mjs';
-import { g as getOptions } from './options-B9PPOdJv.mjs';
+import { _ as __awaiter, g as getOptions } from './options-BDij5-AP.mjs';
+import require$$0$2 from 'fs';
+import require$$0 from 'constants';
+import require$$0$1 from 'stream';
+import require$$4 from 'util';
+import require$$5 from 'assert';
+import require$$1 from 'path';
+import { createConsola } from 'consola';
+import fetch from 'npm-registry-fetch';
+import { d as defu } from './defu-n46TJT6t.mjs';
 import '@csstools/postcss-is-pseudo-class';
 import 'postcss-rem-to-responsive-pixel';
 import 'postcss';
@@ -11,8 +20,7 @@ import '@ast-core/escape';
 import '@weapp-core/escape';
 import 'lru-cache';
 import 'md5';
-import './defaults-CWrYZAlE.mjs';
-import './defu-n46TJT6t.mjs';
+import './defaults-5A8JI2hW.mjs';
 import 'magic-string';
 import '@babel/generator';
 import '@babel/traverse';
@@ -25,17 +33,3357 @@ import 'tailwindcss-patch';
 import '@babel/types';
 import 'htmlparser2';
 
-process.title = 'node (weapp-tailwindcss)';
-const args = process.argv.slice(2);
-if (semver.lt(process.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
-    console.error(`You are using Node.js ${process.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`);
-    process.exit(1);
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var fs$1 = {};
+
+var universalify = {};
+
+var hasRequiredUniversalify;
+
+function requireUniversalify () {
+	if (hasRequiredUniversalify) return universalify;
+	hasRequiredUniversalify = 1;
+
+	universalify.fromCallback = function (fn) {
+	  return Object.defineProperty(function (...args) {
+	    if (typeof args[args.length - 1] === 'function') fn.apply(this, args);
+	    else {
+	      return new Promise((resolve, reject) => {
+	        args.push((err, res) => (err != null) ? reject(err) : resolve(res));
+	        fn.apply(this, args);
+	      })
+	    }
+	  }, 'name', { value: fn.name })
+	};
+
+	universalify.fromPromise = function (fn) {
+	  return Object.defineProperty(function (...args) {
+	    const cb = args[args.length - 1];
+	    if (typeof cb !== 'function') return fn.apply(this, args)
+	    else {
+	      args.pop();
+	      fn.apply(this, args).then(r => cb(null, r), cb);
+	    }
+	  }, 'name', { value: fn.name })
+	};
+	return universalify;
+}
+
+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 = require$$0$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]);
+	      require$$5.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 hasRequiredFs;
+
+function requireFs () {
+	if (hasRequiredFs) return fs$1;
+	hasRequiredFs = 1;
+	(function (exports) {
+		// This is adapted from https://github.com/normalize/mz
+		// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
+		const u = requireUniversalify().fromCallback;
+		const fs = requireGracefulFs();
+
+		const api = [
+		  'access',
+		  'appendFile',
+		  'chmod',
+		  'chown',
+		  'close',
+		  'copyFile',
+		  'fchmod',
+		  'fchown',
+		  'fdatasync',
+		  'fstat',
+		  'fsync',
+		  'ftruncate',
+		  'futimes',
+		  'lchmod',
+		  'lchown',
+		  'link',
+		  'lstat',
+		  'mkdir',
+		  'mkdtemp',
+		  'open',
+		  'opendir',
+		  'readdir',
+		  'readFile',
+		  'readlink',
+		  'realpath',
+		  'rename',
+		  'rm',
+		  'rmdir',
+		  'stat',
+		  'symlink',
+		  'truncate',
+		  'unlink',
+		  'utimes',
+		  'writeFile'
+		].filter(key => {
+		  // Some commands are not available on some systems. Ex:
+		  // fs.cp was added in Node.js v16.7.0
+		  // fs.lchown is not available on at least some Linux
+		  return typeof fs[key] === 'function'
+		});
+
+		// Export cloned fs:
+		Object.assign(exports, fs);
+
+		// Universalify async methods:
+		api.forEach(method => {
+		  exports[method] = u(fs[method]);
+		});
+
+		// We differ from mz/fs in that we still ship the old, broken, fs.exists()
+		// since we are a drop-in replacement for the native module
+		exports.exists = function (filename, callback) {
+		  if (typeof callback === 'function') {
+		    return fs.exists(filename, callback)
+		  }
+		  return new Promise(resolve => {
+		    return fs.exists(filename, resolve)
+		  })
+		};
+
+		// fs.read(), fs.write(), fs.readv(), & fs.writev() need special treatment due to multiple callback args
+
+		exports.read = function (fd, buffer, offset, length, position, callback) {
+		  if (typeof callback === 'function') {
+		    return fs.read(fd, buffer, offset, length, position, callback)
+		  }
+		  return new Promise((resolve, reject) => {
+		    fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
+		      if (err) return reject(err)
+		      resolve({ bytesRead, buffer });
+		    });
+		  })
+		};
+
+		// Function signature can be
+		// fs.write(fd, buffer[, offset[, length[, position]]], callback)
+		// OR
+		// fs.write(fd, string[, position[, encoding]], callback)
+		// We need to handle both cases, so we use ...args
+		exports.write = function (fd, buffer, ...args) {
+		  if (typeof args[args.length - 1] === 'function') {
+		    return fs.write(fd, buffer, ...args)
+		  }
+
+		  return new Promise((resolve, reject) => {
+		    fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
+		      if (err) return reject(err)
+		      resolve({ bytesWritten, buffer });
+		    });
+		  })
+		};
+
+		// Function signature is
+		// s.readv(fd, buffers[, position], callback)
+		// We need to handle the optional arg, so we use ...args
+		exports.readv = function (fd, buffers, ...args) {
+		  if (typeof args[args.length - 1] === 'function') {
+		    return fs.readv(fd, buffers, ...args)
+		  }
+
+		  return new Promise((resolve, reject) => {
+		    fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
+		      if (err) return reject(err)
+		      resolve({ bytesRead, buffers });
+		    });
+		  })
+		};
+
+		// Function signature is
+		// s.writev(fd, buffers[, position], callback)
+		// We need to handle the optional arg, so we use ...args
+		exports.writev = function (fd, buffers, ...args) {
+		  if (typeof args[args.length - 1] === 'function') {
+		    return fs.writev(fd, buffers, ...args)
+		  }
+
+		  return new Promise((resolve, reject) => {
+		    fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
+		      if (err) return reject(err)
+		      resolve({ bytesWritten, buffers });
+		    });
+		  })
+		};
+
+		// fs.realpath.native sometimes not available if fs is monkey-patched
+		if (typeof fs.realpath.native === 'function') {
+		  exports.realpath.native = u(fs.realpath.native);
+		} else {
+		  process.emitWarning(
+		    'fs.realpath.native is not a function. Is fs being monkey-patched?',
+		    'Warning', 'fs-extra-WARN0003'
+		  );
+		} 
+	} (fs$1));
+	return fs$1;
+}
+
+var makeDir = {};
+
+var utils$1 = {};
+
+var hasRequiredUtils$1;
+
+function requireUtils$1 () {
+	if (hasRequiredUtils$1) return utils$1;
+	hasRequiredUtils$1 = 1;
+	const path = require$$1;
+
+	// https://github.com/nodejs/node/issues/8987
+	// https://github.com/libuv/libuv/pull/1088
+	utils$1.checkPath = function checkPath (pth) {
+	  if (process.platform === 'win32') {
+	    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
+
+	    if (pathHasInvalidWinCharacters) {
+	      const error = new Error(`Path contains invalid characters: ${pth}`);
+	      error.code = 'EINVAL';
+	      throw error
+	    }
+	  }
+	};
+	return utils$1;
+}
+
+var hasRequiredMakeDir;
+
+function requireMakeDir () {
+	if (hasRequiredMakeDir) return makeDir;
+	hasRequiredMakeDir = 1;
+	const fs = /*@__PURE__*/ requireFs();
+	const { checkPath } = /*@__PURE__*/ requireUtils$1();
+
+	const getMode = options => {
+	  const defaults = { mode: 0o777 };
+	  if (typeof options === 'number') return options
+	  return ({ ...defaults, ...options }).mode
+	};
+
+	makeDir.makeDir = async (dir, options) => {
+	  checkPath(dir);
+
+	  return fs.mkdir(dir, {
+	    mode: getMode(options),
+	    recursive: true
+	  })
+	};
+
+	makeDir.makeDirSync = (dir, options) => {
+	  checkPath(dir);
+
+	  return fs.mkdirSync(dir, {
+	    mode: getMode(options),
+	    recursive: true
+	  })
+	};
+	return makeDir;
+}
+
+var mkdirs;
+var hasRequiredMkdirs;
+
+function requireMkdirs () {
+	if (hasRequiredMkdirs) return mkdirs;
+	hasRequiredMkdirs = 1;
+	const u = requireUniversalify().fromPromise;
+	const { makeDir: _makeDir, makeDirSync } = /*@__PURE__*/ requireMakeDir();
+	const makeDir = u(_makeDir);
+
+	mkdirs = {
+	  mkdirs: makeDir,
+	  mkdirsSync: makeDirSync,
+	  // alias
+	  mkdirp: makeDir,
+	  mkdirpSync: makeDirSync,
+	  ensureDir: makeDir,
+	  ensureDirSync: makeDirSync
+	};
+	return mkdirs;
+}
+
+var pathExists_1;
+var hasRequiredPathExists;
+
+function requirePathExists () {
+	if (hasRequiredPathExists) return pathExists_1;
+	hasRequiredPathExists = 1;
+	const u = requireUniversalify().fromPromise;
+	const fs = /*@__PURE__*/ requireFs();
+
+	function pathExists (path) {
+	  return fs.access(path).then(() => true).catch(() => false)
+	}
+
+	pathExists_1 = {
+	  pathExists: u(pathExists),
+	  pathExistsSync: fs.existsSync
+	};
+	return pathExists_1;
+}
+
+var utimes;
+var hasRequiredUtimes;
+
+function requireUtimes () {
+	if (hasRequiredUtimes) return utimes;
+	hasRequiredUtimes = 1;
+
+	const fs = /*@__PURE__*/ requireFs();
+	const u = requireUniversalify().fromPromise;
+
+	async function utimesMillis (path, atime, mtime) {
+	  // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
+	  const fd = await fs.open(path, 'r+');
+
+	  let closeErr = null;
+
+	  try {
+	    await fs.futimes(fd, atime, mtime);
+	  } finally {
+	    try {
+	      await fs.close(fd);
+	    } catch (e) {
+	      closeErr = e;
+	    }
+	  }
+
+	  if (closeErr) {
+	    throw closeErr
+	  }
+	}
+
+	function utimesMillisSync (path, atime, mtime) {
+	  const fd = fs.openSync(path, 'r+');
+	  fs.futimesSync(fd, atime, mtime);
+	  return fs.closeSync(fd)
+	}
+
+	utimes = {
+	  utimesMillis: u(utimesMillis),
+	  utimesMillisSync
+	};
+	return utimes;
+}
+
+var stat;
+var hasRequiredStat;
+
+function requireStat () {
+	if (hasRequiredStat) return stat;
+	hasRequiredStat = 1;
+
+	const fs = /*@__PURE__*/ requireFs();
+	const path = require$$1;
+	const u = requireUniversalify().fromPromise;
+
+	function getStats (src, dest, opts) {
+	  const statFunc = opts.dereference
+	    ? (file) => fs.stat(file, { bigint: true })
+	    : (file) => fs.lstat(file, { bigint: true });
+	  return Promise.all([
+	    statFunc(src),
+	    statFunc(dest).catch(err => {
+	      if (err.code === 'ENOENT') return null
+	      throw err
+	    })
+	  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
+	}
+
+	function getStatsSync (src, dest, opts) {
+	  let destStat;
+	  const statFunc = opts.dereference
+	    ? (file) => fs.statSync(file, { bigint: true })
+	    : (file) => fs.lstatSync(file, { bigint: true });
+	  const srcStat = statFunc(src);
+	  try {
+	    destStat = statFunc(dest);
+	  } catch (err) {
+	    if (err.code === 'ENOENT') return { srcStat, destStat: null }
+	    throw err
+	  }
+	  return { srcStat, destStat }
+	}
+
+	async function checkPaths (src, dest, funcName, opts) {
+	  const { srcStat, destStat } = await getStats(src, dest, opts);
+	  if (destStat) {
+	    if (areIdentical(srcStat, destStat)) {
+	      const srcBaseName = path.basename(src);
+	      const destBaseName = path.basename(dest);
+	      if (funcName === 'move' &&
+	        srcBaseName !== destBaseName &&
+	        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+	        return { srcStat, destStat, isChangingCase: true }
+	      }
+	      throw new Error('Source and destination must not be the same.')
+	    }
+	    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+	      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+	    }
+	    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+	      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
+	    }
+	  }
+
+	  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+	    throw new Error(errMsg(src, dest, funcName))
+	  }
+
+	  return { srcStat, destStat }
+	}
+
+	function checkPathsSync (src, dest, funcName, opts) {
+	  const { srcStat, destStat } = getStatsSync(src, dest, opts);
+
+	  if (destStat) {
+	    if (areIdentical(srcStat, destStat)) {
+	      const srcBaseName = path.basename(src);
+	      const destBaseName = path.basename(dest);
+	      if (funcName === 'move' &&
+	        srcBaseName !== destBaseName &&
+	        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+	        return { srcStat, destStat, isChangingCase: true }
+	      }
+	      throw new Error('Source and destination must not be the same.')
+	    }
+	    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+	      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+	    }
+	    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+	      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
+	    }
+	  }
+
+	  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+	    throw new Error(errMsg(src, dest, funcName))
+	  }
+	  return { srcStat, destStat }
+	}
+
+	// recursively check if dest parent is a subdirectory of src.
+	// It works for all file types including symlinks since it
+	// checks the src and dest inodes. It starts from the deepest
+	// parent and stops once it reaches the src parent or the root path.
+	async function checkParentPaths (src, srcStat, dest, funcName) {
+	  const srcParent = path.resolve(path.dirname(src));
+	  const destParent = path.resolve(path.dirname(dest));
+	  if (destParent === srcParent || destParent === path.parse(destParent).root) return
+
+	  let destStat;
+	  try {
+	    destStat = await fs.stat(destParent, { bigint: true });
+	  } catch (err) {
+	    if (err.code === 'ENOENT') return
+	    throw err
+	  }
+
+	  if (areIdentical(srcStat, destStat)) {
+	    throw new Error(errMsg(src, dest, funcName))
+	  }
+
+	  return checkParentPaths(src, srcStat, destParent, funcName)
+	}
+
+	function checkParentPathsSync (src, srcStat, dest, funcName) {
+	  const srcParent = path.resolve(path.dirname(src));
+	  const destParent = path.resolve(path.dirname(dest));
+	  if (destParent === srcParent || destParent === path.parse(destParent).root) return
+	  let destStat;
+	  try {
+	    destStat = fs.statSync(destParent, { bigint: true });
+	  } catch (err) {
+	    if (err.code === 'ENOENT') return
+	    throw err
+	  }
+	  if (areIdentical(srcStat, destStat)) {
+	    throw new Error(errMsg(src, dest, funcName))
+	  }
+	  return checkParentPathsSync(src, srcStat, destParent, funcName)
+	}
+
+	function areIdentical (srcStat, destStat) {
+	  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
+	}
+
+	// return true if dest is a subdir of src, otherwise false.
+	// It only checks the path strings.
+	function isSrcSubdir (src, dest) {
+	  const srcArr = path.resolve(src).split(path.sep).filter(i => i);
+	  const destArr = path.resolve(dest).split(path.sep).filter(i => i);
+	  return srcArr.every((cur, i) => destArr[i] === cur)
+	}
+
+	function errMsg (src, dest, funcName) {
+	  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
+	}
+
+	stat = {
+	  // checkPaths
+	  checkPaths: u(checkPaths),
+	  checkPathsSync,
+	  // checkParent
+	  checkParentPaths: u(checkParentPaths),
+	  checkParentPathsSync,
+	  // Misc
+	  isSrcSubdir,
+	  areIdentical
+	};
+	return stat;
+}
+
+var copy_1;
+var hasRequiredCopy$1;
+
+function requireCopy$1 () {
+	if (hasRequiredCopy$1) return copy_1;
+	hasRequiredCopy$1 = 1;
+
+	const fs = /*@__PURE__*/ requireFs();
+	const path = require$$1;
+	const { mkdirs } = /*@__PURE__*/ requireMkdirs();
+	const { pathExists } = /*@__PURE__*/ requirePathExists();
+	const { utimesMillis } = /*@__PURE__*/ requireUtimes();
+	const stat = /*@__PURE__*/ requireStat();
+
+	async function copy (src, dest, opts = {}) {
+	  if (typeof opts === 'function') {
+	    opts = { filter: opts };
+	  }
+
+	  opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
+	  opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
+
+	  // Warn about using preserveTimestamps on 32-bit node
+	  if (opts.preserveTimestamps && process.arch === 'ia32') {
+	    process.emitWarning(
+	      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+	      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+	      'Warning', 'fs-extra-WARN0001'
+	    );
+	  }
+
+	  const { srcStat, destStat } = await stat.checkPaths(src, dest, 'copy', opts);
+
+	  await stat.checkParentPaths(src, srcStat, dest, 'copy');
+
+	  const include = await runFilter(src, dest, opts);
+
+	  if (!include) return
+
+	  // check if the parent of dest exists, and create it if it doesn't exist
+	  const destParent = path.dirname(dest);
+	  const dirExists = await pathExists(destParent);
+	  if (!dirExists) {
+	    await mkdirs(destParent);
+	  }
+
+	  await getStatsAndPerformCopy(destStat, src, dest, opts);
+	}
+
+	async function runFilter (src, dest, opts) {
+	  if (!opts.filter) return true
+	  return opts.filter(src, dest)
+	}
+
+	async function getStatsAndPerformCopy (destStat, src, dest, opts) {
+	  const statFn = opts.dereference ? fs.stat : fs.lstat;
+	  const srcStat = await statFn(src);
+
+	  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
+
+	  if (
+	    srcStat.isFile() ||
+	    srcStat.isCharacterDevice() ||
+	    srcStat.isBlockDevice()
+	  ) return onFile(srcStat, destStat, src, dest, opts)
+
+	  if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
+	  if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
+	  if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
+	  throw new Error(`Unknown file: ${src}`)
+	}
+
+	async function onFile (srcStat, destStat, src, dest, opts) {
+	  if (!destStat) return copyFile(srcStat, src, dest, opts)
+
+	  if (opts.overwrite) {
+	    await fs.unlink(dest);
+	    return copyFile(srcStat, src, dest, opts)
+	  }
+	  if (opts.errorOnExist) {
+	    throw new Error(`'${dest}' already exists`)
+	  }
+	}
+
+	async function copyFile (srcStat, src, dest, opts) {
+	  await fs.copyFile(src, dest);
+	  if (opts.preserveTimestamps) {
+	    // Make sure the file is writable before setting the timestamp
+	    // otherwise open fails with EPERM when invoked with 'r+'
+	    // (through utimes call)
+	    if (fileIsNotWritable(srcStat.mode)) {
+	      await makeFileWritable(dest, srcStat.mode);
+	    }
+
+	    // Set timestamps and mode correspondingly
+
+	    // Note that The initial srcStat.atime cannot be trusted
+	    // because it is modified by the read(2) system call
+	    // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+	    const updatedSrcStat = await fs.stat(src);
+	    await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+	  }
+
+	  return fs.chmod(dest, srcStat.mode)
+	}
+
+	function fileIsNotWritable (srcMode) {
+	  return (srcMode & 0o200) === 0
+	}
+
+	function makeFileWritable (dest, srcMode) {
+	  return fs.chmod(dest, srcMode | 0o200)
+	}
+
+	async function onDir (srcStat, destStat, src, dest, opts) {
+	  // the dest directory might not exist, create it
+	  if (!destStat) {
+	    await fs.mkdir(dest);
+	  }
+
+	  const items = await fs.readdir(src);
+
+	  // loop through the files in the current directory to copy everything
+	  await Promise.all(items.map(async item => {
+	    const srcItem = path.join(src, item);
+	    const destItem = path.join(dest, item);
+
+	    // skip the item if it is matches by the filter function
+	    const include = await runFilter(srcItem, destItem, opts);
+	    if (!include) return
+
+	    const { destStat } = await stat.checkPaths(srcItem, destItem, 'copy', opts);
+
+	    // If the item is a copyable file, `getStatsAndPerformCopy` will copy it
+	    // If the item is a directory, `getStatsAndPerformCopy` will call `onDir` recursively
+	    return getStatsAndPerformCopy(destStat, srcItem, destItem, opts)
+	  }));
+
+	  if (!destStat) {
+	    await fs.chmod(dest, srcStat.mode);
+	  }
+	}
+
+	async function onLink (destStat, src, dest, opts) {
+	  let resolvedSrc = await fs.readlink(src);
+	  if (opts.dereference) {
+	    resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
+	  }
+	  if (!destStat) {
+	    return fs.symlink(resolvedSrc, dest)
+	  }
+
+	  let resolvedDest = null;
+	  try {
+	    resolvedDest = await fs.readlink(dest);
+	  } catch (e) {
+	    // dest exists and is a regular file or directory,
+	    // Windows may throw UNKNOWN error. If dest already exists,
+	    // fs throws error anyway, so no need to guard against it here.
+	    if (e.code === 'EINVAL' || e.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest)
+	    throw e
+	  }
+	  if (opts.dereference) {
+	    resolvedDest = path.resolve(process.cwd(), resolvedDest);
+	  }
+	  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+	    throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
+	  }
+
+	  // do not copy if src is a subdir of dest since unlinking
+	  // dest in this case would result in removing src contents
+	  // and therefore a broken symlink would be created.
+	  if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+	    throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
+	  }
+
+	  // copy the link
+	  await fs.unlink(dest);
+	  return fs.symlink(resolvedSrc, dest)
+	}
+
+	copy_1 = copy;
+	return copy_1;
+}
+
+var copySync_1;
+var hasRequiredCopySync;
+
+function requireCopySync () {
+	if (hasRequiredCopySync) return copySync_1;
+	hasRequiredCopySync = 1;
+
+	const fs = requireGracefulFs();
+	const path = require$$1;
+	const mkdirsSync = /*@__PURE__*/ requireMkdirs().mkdirsSync;
+	const utimesMillisSync = /*@__PURE__*/ requireUtimes().utimesMillisSync;
+	const stat = /*@__PURE__*/ requireStat();
+
+	function copySync (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') {
+	    process.emitWarning(
+	      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+	      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+	      'Warning', 'fs-extra-WARN0002'
+	    );
+	  }
+
+	  const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts);
+	  stat.checkParentPathsSync(src, srcStat, dest, 'copy');
+	  if (opts.filter && !opts.filter(src, dest)) return
+	  const destParent = path.dirname(dest);
+	  if (!fs.existsSync(destParent)) mkdirsSync(destParent);
+	  return getStats(destStat, src, dest, opts)
+	}
+
+	function getStats (destStat, src, dest, opts) {
+	  const statSync = opts.dereference ? fs.statSync : fs.lstatSync;
+	  const srcStat = statSync(src);
+
+	  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
+	  else if (srcStat.isFile() ||
+	           srcStat.isCharacterDevice() ||
+	           srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
+	  else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
+	  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
+	  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
+	  throw new Error(`Unknown file: ${src}`)
+	}
+
+	function onFile (srcStat, destStat, src, dest, opts) {
+	  if (!destStat) return copyFile(srcStat, src, dest, opts)
+	  return mayCopyFile(srcStat, src, dest, opts)
+	}
+
+	function mayCopyFile (srcStat, src, dest, opts) {
+	  if (opts.overwrite) {
+	    fs.unlinkSync(dest);
+	    return copyFile(srcStat, src, dest, opts)
+	  } else if (opts.errorOnExist) {
+	    throw new Error(`'${dest}' already exists`)
+	  }
+	}
+
+	function copyFile (srcStat, src, dest, opts) {
+	  fs.copyFileSync(src, dest);
+	  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+	  return setDestMode(dest, srcStat.mode)
+	}
+
+	function handleTimestamps (srcMode, src, dest) {
+	  // Make sure the file is writable before setting the timestamp
+	  // otherwise open fails with EPERM when invoked with 'r+'
+	  // (through utimes call)
+	  if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+	  return setDestTimestamps(src, dest)
+	}
+
+	function fileIsNotWritable (srcMode) {
+	  return (srcMode & 0o200) === 0
+	}
+
+	function makeFileWritable (dest, srcMode) {
+	  return setDestMode(dest, srcMode | 0o200)
+	}
+
+	function setDestMode (dest, srcMode) {
+	  return fs.chmodSync(dest, srcMode)
+	}
+
+	function setDestTimestamps (src, dest) {
+	  // The initial srcStat.atime cannot be trusted
+	  // because it is modified by the read(2) system call
+	  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+	  const updatedSrcStat = fs.statSync(src);
+	  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
+	}
+
+	function onDir (srcStat, destStat, src, dest, opts) {
+	  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
+	  return copyDir(src, dest, opts)
+	}
+
+	function mkDirAndCopy (srcMode, src, dest, opts) {
+	  fs.mkdirSync(dest);
+	  copyDir(src, dest, opts);
+	  return setDestMode(dest, srcMode)
+	}
+
+	function copyDir (src, dest, opts) {
+	  fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts));
+	}
+
+	function copyDirItem (item, src, dest, opts) {
+	  const srcItem = path.join(src, item);
+	  const destItem = path.join(dest, item);
+	  if (opts.filter && !opts.filter(srcItem, destItem)) return
+	  const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts);
+	  return getStats(destStat, srcItem, destItem, opts)
+	}
+
+	function onLink (destStat, src, dest, opts) {
+	  let resolvedSrc = fs.readlinkSync(src);
+	  if (opts.dereference) {
+	    resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
+	  }
+
+	  if (!destStat) {
+	    return fs.symlinkSync(resolvedSrc, dest)
+	  } else {
+	    let resolvedDest;
+	    try {
+	      resolvedDest = fs.readlinkSync(dest);
+	    } catch (err) {
+	      // dest exists and is a regular file or directory,
+	      // Windows may throw UNKNOWN error. If dest already exists,
+	      // fs throws error anyway, so no need to guard against it here.
+	      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)
+	      throw err
+	    }
+	    if (opts.dereference) {
+	      resolvedDest = path.resolve(process.cwd(), resolvedDest);
+	    }
+	    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+	      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
+	    }
+
+	    // prevent copy if src is a subdir of dest since unlinking
+	    // dest in this case would result in removing src contents
+	    // and therefore a broken symlink would be created.
+	    if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+	      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
+	    }
+	    return copyLink(resolvedSrc, dest)
+	  }
+	}
+
+	function copyLink (resolvedSrc, dest) {
+	  fs.unlinkSync(dest);
+	  return fs.symlinkSync(resolvedSrc, dest)
+	}
+
+	copySync_1 = copySync;
+	return copySync_1;
+}
+
+var copy;
+var hasRequiredCopy;
+
+function requireCopy () {
+	if (hasRequiredCopy) return copy;
+	hasRequiredCopy = 1;
+
+	const u = requireUniversalify().fromPromise;
+	copy = {
+	  copy: u(/*@__PURE__*/ requireCopy$1()),
+	  copySync: /*@__PURE__*/ requireCopySync()
+	};
+	return copy;
+}
+
+var remove_1;
+var hasRequiredRemove;
+
+function requireRemove () {
+	if (hasRequiredRemove) return remove_1;
+	hasRequiredRemove = 1;
+
+	const fs = requireGracefulFs();
+	const u = requireUniversalify().fromCallback;
+
+	function remove (path, callback) {
+	  fs.rm(path, { recursive: true, force: true }, callback);
+	}
+
+	function removeSync (path) {
+	  fs.rmSync(path, { recursive: true, force: true });
+	}
+
+	remove_1 = {
+	  remove: u(remove),
+	  removeSync
+	};
+	return remove_1;
+}
+
+var empty;
+var hasRequiredEmpty;
+
+function requireEmpty () {
+	if (hasRequiredEmpty) return empty;
+	hasRequiredEmpty = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const fs = /*@__PURE__*/ requireFs();
+	const path = require$$1;
+	const mkdir = /*@__PURE__*/ requireMkdirs();
+	const remove = /*@__PURE__*/ requireRemove();
+
+	const emptyDir = u(async function emptyDir (dir) {
+	  let items;
+	  try {
+	    items = await fs.readdir(dir);
+	  } catch {
+	    return mkdir.mkdirs(dir)
+	  }
+
+	  return Promise.all(items.map(item => remove.remove(path.join(dir, item))))
+	});
+
+	function emptyDirSync (dir) {
+	  let items;
+	  try {
+	    items = fs.readdirSync(dir);
+	  } catch {
+	    return mkdir.mkdirsSync(dir)
+	  }
+
+	  items.forEach(item => {
+	    item = path.join(dir, item);
+	    remove.removeSync(item);
+	  });
+	}
+
+	empty = {
+	  emptyDirSync,
+	  emptydirSync: emptyDirSync,
+	  emptyDir,
+	  emptydir: emptyDir
+	};
+	return empty;
+}
+
+var file;
+var hasRequiredFile;
+
+function requireFile () {
+	if (hasRequiredFile) return file;
+	hasRequiredFile = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const path = require$$1;
+	const fs = /*@__PURE__*/ requireFs();
+	const mkdir = /*@__PURE__*/ requireMkdirs();
+
+	async function createFile (file) {
+	  let stats;
+	  try {
+	    stats = await fs.stat(file);
+	  } catch { }
+	  if (stats && stats.isFile()) return
+
+	  const dir = path.dirname(file);
+
+	  let dirStats = null;
+	  try {
+	    dirStats = await fs.stat(dir);
+	  } catch (err) {
+	    // if the directory doesn't exist, make it
+	    if (err.code === 'ENOENT') {
+	      await mkdir.mkdirs(dir);
+	      await fs.writeFile(file, '');
+	      return
+	    } else {
+	      throw err
+	    }
+	  }
+
+	  if (dirStats.isDirectory()) {
+	    await fs.writeFile(file, '');
+	  } else {
+	    // parent is not a directory
+	    // This is just to cause an internal ENOTDIR error to be thrown
+	    await fs.readdir(dir);
+	  }
+	}
+
+	function createFileSync (file) {
+	  let stats;
+	  try {
+	    stats = fs.statSync(file);
+	  } catch { }
+	  if (stats && stats.isFile()) return
+
+	  const dir = path.dirname(file);
+	  try {
+	    if (!fs.statSync(dir).isDirectory()) {
+	      // parent is not a directory
+	      // This is just to cause an internal ENOTDIR error to be thrown
+	      fs.readdirSync(dir);
+	    }
+	  } catch (err) {
+	    // If the stat call above failed because the directory doesn't exist, create it
+	    if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir);
+	    else throw err
+	  }
+
+	  fs.writeFileSync(file, '');
+	}
+
+	file = {
+	  createFile: u(createFile),
+	  createFileSync
+	};
+	return file;
+}
+
+var link;
+var hasRequiredLink;
+
+function requireLink () {
+	if (hasRequiredLink) return link;
+	hasRequiredLink = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const path = require$$1;
+	const fs = /*@__PURE__*/ requireFs();
+	const mkdir = /*@__PURE__*/ requireMkdirs();
+	const { pathExists } = /*@__PURE__*/ requirePathExists();
+	const { areIdentical } = /*@__PURE__*/ requireStat();
+
+	async function createLink (srcpath, dstpath) {
+	  let dstStat;
+	  try {
+	    dstStat = await fs.lstat(dstpath);
+	  } catch {
+	    // ignore error
+	  }
+
+	  let srcStat;
+	  try {
+	    srcStat = await fs.lstat(srcpath);
+	  } catch (err) {
+	    err.message = err.message.replace('lstat', 'ensureLink');
+	    throw err
+	  }
+
+	  if (dstStat && areIdentical(srcStat, dstStat)) return
+
+	  const dir = path.dirname(dstpath);
+
+	  const dirExists = await pathExists(dir);
+
+	  if (!dirExists) {
+	    await mkdir.mkdirs(dir);
+	  }
+
+	  await fs.link(srcpath, dstpath);
+	}
+
+	function createLinkSync (srcpath, dstpath) {
+	  let dstStat;
+	  try {
+	    dstStat = fs.lstatSync(dstpath);
+	  } catch {}
+
+	  try {
+	    const srcStat = fs.lstatSync(srcpath);
+	    if (dstStat && areIdentical(srcStat, dstStat)) return
+	  } catch (err) {
+	    err.message = err.message.replace('lstat', 'ensureLink');
+	    throw err
+	  }
+
+	  const dir = path.dirname(dstpath);
+	  const dirExists = fs.existsSync(dir);
+	  if (dirExists) return fs.linkSync(srcpath, dstpath)
+	  mkdir.mkdirsSync(dir);
+
+	  return fs.linkSync(srcpath, dstpath)
+	}
+
+	link = {
+	  createLink: u(createLink),
+	  createLinkSync
+	};
+	return link;
+}
+
+var symlinkPaths_1;
+var hasRequiredSymlinkPaths;
+
+function requireSymlinkPaths () {
+	if (hasRequiredSymlinkPaths) return symlinkPaths_1;
+	hasRequiredSymlinkPaths = 1;
+
+	const path = require$$1;
+	const fs = /*@__PURE__*/ requireFs();
+	const { pathExists } = /*@__PURE__*/ requirePathExists();
+
+	const u = requireUniversalify().fromPromise;
+
+	/**
+	 * 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.
+	 */
+
+	async function symlinkPaths (srcpath, dstpath) {
+	  if (path.isAbsolute(srcpath)) {
+	    try {
+	      await fs.lstat(srcpath);
+	    } catch (err) {
+	      err.message = err.message.replace('lstat', 'ensureSymlink');
+	      throw err
+	    }
+
+	    return {
+	      toCwd: srcpath,
+	      toDst: srcpath
+	    }
+	  }
+
+	  const dstdir = path.dirname(dstpath);
+	  const relativeToDst = path.join(dstdir, srcpath);
+
+	  const exists = await pathExists(relativeToDst);
+	  if (exists) {
+	    return {
+	      toCwd: relativeToDst,
+	      toDst: srcpath
+	    }
+	  }
+
+	  try {
+	    await fs.lstat(srcpath);
+	  } catch (err) {
+	    err.message = err.message.replace('lstat', 'ensureSymlink');
+	    throw err
+	  }
+
+	  return {
+	    toCwd: srcpath,
+	    toDst: path.relative(dstdir, srcpath)
+	  }
+	}
+
+	function symlinkPathsSync (srcpath, dstpath) {
+	  if (path.isAbsolute(srcpath)) {
+	    const exists = fs.existsSync(srcpath);
+	    if (!exists) throw new Error('absolute srcpath does not exist')
+	    return {
+	      toCwd: srcpath,
+	      toDst: srcpath
+	    }
+	  }
+
+	  const dstdir = path.dirname(dstpath);
+	  const relativeToDst = path.join(dstdir, srcpath);
+	  const exists = fs.existsSync(relativeToDst);
+	  if (exists) {
+	    return {
+	      toCwd: relativeToDst,
+	      toDst: srcpath
+	    }
+	  }
+
+	  const srcExists = fs.existsSync(srcpath);
+	  if (!srcExists) throw new Error('relative srcpath does not exist')
+	  return {
+	    toCwd: srcpath,
+	    toDst: path.relative(dstdir, srcpath)
+	  }
+	}
+
+	symlinkPaths_1 = {
+	  symlinkPaths: u(symlinkPaths),
+	  symlinkPathsSync
+	};
+	return symlinkPaths_1;
+}
+
+var symlinkType_1;
+var hasRequiredSymlinkType;
+
+function requireSymlinkType () {
+	if (hasRequiredSymlinkType) return symlinkType_1;
+	hasRequiredSymlinkType = 1;
+
+	const fs = /*@__PURE__*/ requireFs();
+	const u = requireUniversalify().fromPromise;
+
+	async function symlinkType (srcpath, type) {
+	  if (type) return type
+
+	  let stats;
+	  try {
+	    stats = await fs.lstat(srcpath);
+	  } catch {
+	    return 'file'
+	  }
+
+	  return (stats && stats.isDirectory()) ? 'dir' : 'file'
+	}
+
+	function symlinkTypeSync (srcpath, type) {
+	  if (type) return type
+
+	  let stats;
+	  try {
+	    stats = fs.lstatSync(srcpath);
+	  } catch {
+	    return 'file'
+	  }
+	  return (stats && stats.isDirectory()) ? 'dir' : 'file'
+	}
+
+	symlinkType_1 = {
+	  symlinkType: u(symlinkType),
+	  symlinkTypeSync
+	};
+	return symlinkType_1;
+}
+
+var symlink;
+var hasRequiredSymlink;
+
+function requireSymlink () {
+	if (hasRequiredSymlink) return symlink;
+	hasRequiredSymlink = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const path = require$$1;
+	const fs = /*@__PURE__*/ requireFs();
+
+	const { mkdirs, mkdirsSync } = /*@__PURE__*/ requireMkdirs();
+
+	const { symlinkPaths, symlinkPathsSync } = /*@__PURE__*/ requireSymlinkPaths();
+	const { symlinkType, symlinkTypeSync } = /*@__PURE__*/ requireSymlinkType();
+
+	const { pathExists } = /*@__PURE__*/ requirePathExists();
+
+	const { areIdentical } = /*@__PURE__*/ requireStat();
+
+	async function createSymlink (srcpath, dstpath, type) {
+	  let stats;
+	  try {
+	    stats = await fs.lstat(dstpath);
+	  } catch { }
+
+	  if (stats && stats.isSymbolicLink()) {
+	    const [srcStat, dstStat] = await Promise.all([
+	      fs.stat(srcpath),
+	      fs.stat(dstpath)
+	    ]);
+
+	    if (areIdentical(srcStat, dstStat)) return
+	  }
+
+	  const relative = await symlinkPaths(srcpath, dstpath);
+	  srcpath = relative.toDst;
+	  const toType = await symlinkType(relative.toCwd, type);
+	  const dir = path.dirname(dstpath);
+
+	  if (!(await pathExists(dir))) {
+	    await mkdirs(dir);
+	  }
+
+	  return fs.symlink(srcpath, dstpath, toType)
+	}
+
+	function createSymlinkSync (srcpath, dstpath, type) {
+	  let stats;
+	  try {
+	    stats = fs.lstatSync(dstpath);
+	  } catch { }
+	  if (stats && stats.isSymbolicLink()) {
+	    const srcStat = fs.statSync(srcpath);
+	    const dstStat = fs.statSync(dstpath);
+	    if (areIdentical(srcStat, dstStat)) return
+	  }
+
+	  const relative = symlinkPathsSync(srcpath, dstpath);
+	  srcpath = relative.toDst;
+	  type = symlinkTypeSync(relative.toCwd, type);
+	  const dir = path.dirname(dstpath);
+	  const exists = fs.existsSync(dir);
+	  if (exists) return fs.symlinkSync(srcpath, dstpath, type)
+	  mkdirsSync(dir);
+	  return fs.symlinkSync(srcpath, dstpath, type)
+	}
+
+	symlink = {
+	  createSymlink: u(createSymlink),
+	  createSymlinkSync
+	};
+	return symlink;
+}
+
+var ensure;
+var hasRequiredEnsure;
+
+function requireEnsure () {
+	if (hasRequiredEnsure) return ensure;
+	hasRequiredEnsure = 1;
+
+	const { createFile, createFileSync } = /*@__PURE__*/ requireFile();
+	const { createLink, createLinkSync } = /*@__PURE__*/ requireLink();
+	const { createSymlink, createSymlinkSync } = /*@__PURE__*/ requireSymlink();
+
+	ensure = {
+	  // file
+	  createFile,
+	  createFileSync,
+	  ensureFile: createFile,
+	  ensureFileSync: createFileSync,
+	  // link
+	  createLink,
+	  createLinkSync,
+	  ensureLink: createLink,
+	  ensureLinkSync: createLinkSync,
+	  // symlink
+	  createSymlink,
+	  createSymlinkSync,
+	  ensureSymlink: createSymlink,
+	  ensureSymlinkSync: createSymlinkSync
+	};
+	return ensure;
+}
+
+var utils;
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
+	  const EOF = finalEOL ? EOL : '';
+	  const str = JSON.stringify(obj, replacer, spaces);
+
+	  return str.replace(/\n/g, EOL) + EOF
+	}
+
+	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');
+	  return content.replace(/^\uFEFF/, '')
+	}
+
+	utils = { stringify, stripBom };
+	return utils;
+}
+
+var jsonfile_1;
+var hasRequiredJsonfile$1;
+
+function requireJsonfile$1 () {
+	if (hasRequiredJsonfile$1) return jsonfile_1;
+	hasRequiredJsonfile$1 = 1;
+	let _fs;
+	try {
+	  _fs = requireGracefulFs();
+	} catch (_) {
+	  _fs = require$$0$2;
+	}
+	const universalify = requireUniversalify();
+	const { stringify, stripBom } = requireUtils();
+
+	async function _readFile (file, options = {}) {
+	  if (typeof options === 'string') {
+	    options = { encoding: options };
+	  }
+
+	  const fs = options.fs || _fs;
+
+	  const shouldThrow = 'throws' in options ? options.throws : true;
+
+	  let data = await universalify.fromCallback(fs.readFile)(file, options);
+
+	  data = stripBom(data);
+
+	  let obj;
+	  try {
+	    obj = JSON.parse(data, options ? options.reviver : null);
+	  } catch (err) {
+	    if (shouldThrow) {
+	      err.message = `${file}: ${err.message}`;
+	      throw err
+	    } else {
+	      return null
+	    }
+	  }
+
+	  return obj
+	}
+
+	const readFile = universalify.fromPromise(_readFile);
+
+	function readFileSync (file, options = {}) {
+	  if (typeof options === 'string') {
+	    options = { encoding: options };
+	  }
+
+	  const fs = options.fs || _fs;
+
+	  const shouldThrow = 'throws' in options ? options.throws : true;
+
+	  try {
+	    let content = fs.readFileSync(file, options);
+	    content = stripBom(content);
+	    return JSON.parse(content, options.reviver)
+	  } catch (err) {
+	    if (shouldThrow) {
+	      err.message = `${file}: ${err.message}`;
+	      throw err
+	    } else {
+	      return null
+	    }
+	  }
+	}
+
+	async function _writeFile (file, obj, options = {}) {
+	  const fs = options.fs || _fs;
+
+	  const str = stringify(obj, options);
+
+	  await universalify.fromCallback(fs.writeFile)(file, str, options);
+	}
+
+	const writeFile = universalify.fromPromise(_writeFile);
+
+	function writeFileSync (file, obj, options = {}) {
+	  const fs = options.fs || _fs;
+
+	  const str = stringify(obj, options);
+	  // not sure if fs.writeFileSync returns anything, but just in case
+	  return fs.writeFileSync(file, str, options)
+	}
+
+	const jsonfile = {
+	  readFile,
+	  readFileSync,
+	  writeFile,
+	  writeFileSync
+	};
+
+	jsonfile_1 = jsonfile;
+	return jsonfile_1;
+}
+
+var jsonfile;
+var hasRequiredJsonfile;
+
+function requireJsonfile () {
+	if (hasRequiredJsonfile) return jsonfile;
+	hasRequiredJsonfile = 1;
+
+	const jsonFile = requireJsonfile$1();
+
+	jsonfile = {
+	  // jsonfile exports
+	  readJson: jsonFile.readFile,
+	  readJsonSync: jsonFile.readFileSync,
+	  writeJson: jsonFile.writeFile,
+	  writeJsonSync: jsonFile.writeFileSync
+	};
+	return jsonfile;
+}
+
+var outputFile_1;
+var hasRequiredOutputFile;
+
+function requireOutputFile () {
+	if (hasRequiredOutputFile) return outputFile_1;
+	hasRequiredOutputFile = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const fs = /*@__PURE__*/ requireFs();
+	const path = require$$1;
+	const mkdir = /*@__PURE__*/ requireMkdirs();
+	const pathExists = /*@__PURE__*/ requirePathExists().pathExists;
+
+	async function outputFile (file, data, encoding = 'utf-8') {
+	  const dir = path.dirname(file);
+
+	  if (!(await pathExists(dir))) {
+	    await mkdir.mkdirs(dir);
+	  }
+
+	  return fs.writeFile(file, data, encoding)
+	}
+
+	function outputFileSync (file, ...args) {
+	  const dir = path.dirname(file);
+	  if (!fs.existsSync(dir)) {
+	    mkdir.mkdirsSync(dir);
+	  }
+
+	  fs.writeFileSync(file, ...args);
+	}
+
+	outputFile_1 = {
+	  outputFile: u(outputFile),
+	  outputFileSync
+	};
+	return outputFile_1;
+}
+
+var outputJson_1;
+var hasRequiredOutputJson;
+
+function requireOutputJson () {
+	if (hasRequiredOutputJson) return outputJson_1;
+	hasRequiredOutputJson = 1;
+
+	const { stringify } = requireUtils();
+	const { outputFile } = /*@__PURE__*/ requireOutputFile();
+
+	async function outputJson (file, data, options = {}) {
+	  const str = stringify(data, options);
+
+	  await outputFile(file, str, options);
+	}
+
+	outputJson_1 = outputJson;
+	return outputJson_1;
+}
+
+var outputJsonSync_1;
+var hasRequiredOutputJsonSync;
+
+function requireOutputJsonSync () {
+	if (hasRequiredOutputJsonSync) return outputJsonSync_1;
+	hasRequiredOutputJsonSync = 1;
+
+	const { stringify } = requireUtils();
+	const { outputFileSync } = /*@__PURE__*/ requireOutputFile();
+
+	function outputJsonSync (file, data, options) {
+	  const str = stringify(data, options);
+
+	  outputFileSync(file, str, options);
+	}
+
+	outputJsonSync_1 = outputJsonSync;
+	return outputJsonSync_1;
+}
+
+var json;
+var hasRequiredJson;
+
+function requireJson () {
+	if (hasRequiredJson) return json;
+	hasRequiredJson = 1;
+
+	const u = requireUniversalify().fromPromise;
+	const jsonFile = /*@__PURE__*/ requireJsonfile();
+
+	jsonFile.outputJson = u(/*@__PURE__*/ requireOutputJson());
+	jsonFile.outputJsonSync = /*@__PURE__*/ requireOutputJsonSync();
+	// 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;
+
+	json = jsonFile;
+	return json;
+}
+
+var move_1;
+var hasRequiredMove$1;
+
+function requireMove$1 () {
+	if (hasRequiredMove$1) return move_1;
+	hasRequiredMove$1 = 1;
+
+	const fs = /*@__PURE__*/ requireFs();
+	const path = require$$1;
+	const { copy } = /*@__PURE__*/ requireCopy();
+	const { remove } = /*@__PURE__*/ requireRemove();
+	const { mkdirp } = /*@__PURE__*/ requireMkdirs();
+	const { pathExists } = /*@__PURE__*/ requirePathExists();
+	const stat = /*@__PURE__*/ requireStat();
+
+	async function move (src, dest, opts = {}) {
+	  const overwrite = opts.overwrite || opts.clobber || false;
+
+	  const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, 'move', opts);
+
+	  await stat.checkParentPaths(src, srcStat, dest, 'move');
+
+	  // If the parent of dest is not root, make sure it exists before proceeding
+	  const destParent = path.dirname(dest);
+	  const parsedParentPath = path.parse(destParent);
+	  if (parsedParentPath.root !== destParent) {
+	    await mkdirp(destParent);
+	  }
+
+	  return doRename(src, dest, overwrite, isChangingCase)
+	}
+
+	async function doRename (src, dest, overwrite, isChangingCase) {
+	  if (!isChangingCase) {
+	    if (overwrite) {
+	      await remove(dest);
+	    } else if (await pathExists(dest)) {
+	      throw new Error('dest already exists.')
+	    }
+	  }
+
+	  try {
+	    // Try w/ rename first, and try copy + remove if EXDEV
+	    await fs.rename(src, dest);
+	  } catch (err) {
+	    if (err.code !== 'EXDEV') {
+	      throw err
+	    }
+	    await moveAcrossDevice(src, dest, overwrite);
+	  }
+	}
+
+	async function moveAcrossDevice (src, dest, overwrite) {
+	  const opts = {
+	    overwrite,
+	    errorOnExist: true,
+	    preserveTimestamps: true
+	  };
+
+	  await copy(src, dest, opts);
+	  return remove(src)
+	}
+
+	move_1 = move;
+	return move_1;
+}
+
+var moveSync_1;
+var hasRequiredMoveSync;
+
+function requireMoveSync () {
+	if (hasRequiredMoveSync) return moveSync_1;
+	hasRequiredMoveSync = 1;
+
+	const fs = requireGracefulFs();
+	const path = require$$1;
+	const copySync = /*@__PURE__*/ requireCopy().copySync;
+	const removeSync = /*@__PURE__*/ requireRemove().removeSync;
+	const mkdirpSync = /*@__PURE__*/ requireMkdirs().mkdirpSync;
+	const stat = /*@__PURE__*/ requireStat();
+
+	function moveSync (src, dest, opts) {
+	  opts = opts || {};
+	  const overwrite = opts.overwrite || opts.clobber || false;
+
+	  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts);
+	  stat.checkParentPathsSync(src, srcStat, dest, 'move');
+	  if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest));
+	  return doRename(src, dest, overwrite, isChangingCase)
+	}
+
+	function isParentRoot (dest) {
+	  const parent = path.dirname(dest);
+	  const parsedPath = path.parse(parent);
+	  return parsedPath.root === parent
+	}
+
+	function doRename (src, dest, overwrite, isChangingCase) {
+	  if (isChangingCase) return rename(src, dest, overwrite)
+	  if (overwrite) {
+	    removeSync(dest);
+	    return rename(src, dest, overwrite)
+	  }
+	  if (fs.existsSync(dest)) throw new Error('dest already exists.')
+	  return rename(src, dest, overwrite)
+	}
+
+	function rename (src, dest, overwrite) {
+	  try {
+	    fs.renameSync(src, dest);
+	  } catch (err) {
+	    if (err.code !== 'EXDEV') throw err
+	    return moveAcrossDevice(src, dest, overwrite)
+	  }
+	}
+
+	function moveAcrossDevice (src, dest, overwrite) {
+	  const opts = {
+	    overwrite,
+	    errorOnExist: true,
+	    preserveTimestamps: true
+	  };
+	  copySync(src, dest, opts);
+	  return removeSync(src)
+	}
+
+	moveSync_1 = moveSync;
+	return moveSync_1;
+}
+
+var move;
+var hasRequiredMove;
+
+function requireMove () {
+	if (hasRequiredMove) return move;
+	hasRequiredMove = 1;
+
+	const u = requireUniversalify().fromPromise;
+	move = {
+	  move: u(/*@__PURE__*/ requireMove$1()),
+	  moveSync: /*@__PURE__*/ requireMoveSync()
+	};
+	return move;
+}
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+
+	lib = {
+	  // Export promiseified graceful-fs:
+	  .../*@__PURE__*/ requireFs(),
+	  // Export extra methods:
+	  .../*@__PURE__*/ requireCopy(),
+	  .../*@__PURE__*/ requireEmpty(),
+	  .../*@__PURE__*/ requireEnsure(),
+	  .../*@__PURE__*/ requireJson(),
+	  .../*@__PURE__*/ requireMkdirs(),
+	  .../*@__PURE__*/ requireMove(),
+	  .../*@__PURE__*/ requireOutputFile(),
+	  .../*@__PURE__*/ requirePathExists(),
+	  .../*@__PURE__*/ requireRemove()
+	};
+	return lib;
+}
+
+var libExports = /*@__PURE__*/ requireLib();
+var fs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const _EXTNAME_RE = /.(\.[^./]+)$/;
+const extname = function(p) {
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+const relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const format = function(p) {
+  const segments = [p.root, p.dir, p.base ?? p.name + p.ext].filter(Boolean);
+  return normalizeWindowsPath(
+    p.root ? resolve(...segments) : segments.join("/")
+  );
+};
+const basename = function(p, extension) {
+  const lastSegment = normalizeWindowsPath(p).split("/").pop();
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse = function(p) {
+  const root = normalizeWindowsPath(p).split("/").shift() || "/";
+  const base = basename(p);
+  const extension = extname(base);
+  return {
+    root,
+    dir: dirname(p),
+    base,
+    ext: extension,
+    name: base.slice(0, base.length - extension.length)
+  };
+};
+
+const path = {
+  __proto__: null,
+  basename: basename,
+  delimiter: delimiter,
+  dirname: dirname,
+  extname: extname,
+  format: format,
+  isAbsolute: isAbsolute,
+  join: join,
+  normalize: normalize,
+  normalizeString: normalizeString,
+  parse: parse,
+  relative: relative,
+  resolve: resolve,
+  sep: sep,
+  toNamespacedPath: toNamespacedPath
+};
+
+/*!
+ * is-primitive <https://github.com/jonschlinkert/is-primitive>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isPrimitive;
+var hasRequiredIsPrimitive;
+
+function requireIsPrimitive () {
+	if (hasRequiredIsPrimitive) return isPrimitive;
+	hasRequiredIsPrimitive = 1;
+
+	isPrimitive = function isPrimitive(val) {
+	  if (typeof val === 'object') {
+	    return val === null;
+	  }
+	  return typeof val !== 'function';
+	};
+	return isPrimitive;
+}
+
+/*!
+ * isobject <https://github.com/jonschlinkert/isobject>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isobject;
+var hasRequiredIsobject;
+
+function requireIsobject () {
+	if (hasRequiredIsobject) return isobject;
+	hasRequiredIsobject = 1;
+
+	isobject = function isObject(val) {
+	  return val != null && typeof val === 'object' && Array.isArray(val) === false;
+	};
+	return isobject;
+}
+
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isPlainObject;
+var hasRequiredIsPlainObject;
+
+function requireIsPlainObject () {
+	if (hasRequiredIsPlainObject) return isPlainObject;
+	hasRequiredIsPlainObject = 1;
+
+	var isObject = requireIsobject();
+
+	function isObjectObject(o) {
+	  return isObject(o) === true
+	    && Object.prototype.toString.call(o) === '[object Object]';
+	}
+
+	isPlainObject = function isPlainObject(o) {
+	  var ctor,prot;
+
+	  if (isObjectObject(o) === false) return false;
+
+	  // If has modified constructor
+	  ctor = o.constructor;
+	  if (typeof ctor !== 'function') return false;
+
+	  // If has modified prototype
+	  prot = ctor.prototype;
+	  if (isObjectObject(prot) === false) return false;
+
+	  // If constructor does not have an Object-specific method
+	  if (prot.hasOwnProperty('isPrototypeOf') === false) {
+	    return false;
+	  }
+
+	  // Most likely a plain Object
+	  return true;
+	};
+	return isPlainObject;
+}
+
+/*!
+ * set-value <https://github.com/jonschlinkert/set-value>
+ *
+ * Copyright (c) Jon Schlinkert (https://github.com/jonschlinkert).
+ * Released under the MIT License.
+ */
+
+var setValue_1;
+var hasRequiredSetValue;
+
+function requireSetValue () {
+	if (hasRequiredSetValue) return setValue_1;
+	hasRequiredSetValue = 1;
+
+	const { deleteProperty } = Reflect;
+	const isPrimitive = requireIsPrimitive();
+	const isPlainObject = requireIsPlainObject();
+
+	const isObject = value => {
+	  return (typeof value === 'object' && value !== null) || typeof value === 'function';
+	};
+
+	const isUnsafeKey = key => {
+	  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+	};
+
+	const validateKey = key => {
+	  if (!isPrimitive(key)) {
+	    throw new TypeError('Object keys must be strings or symbols');
+	  }
+
+	  if (isUnsafeKey(key)) {
+	    throw new Error(`Cannot set unsafe key: "${key}"`);
+	  }
+	};
+
+	const toStringKey = input => {
+	  return Array.isArray(input) ? input.flat().map(String).join(',') : input;
+	};
+
+	const createMemoKey = (input, options) => {
+	  if (typeof input !== 'string' || !options) return input;
+	  let key = input + ';';
+	  if (options.arrays !== undefined) key += `arrays=${options.arrays};`;
+	  if (options.separator !== undefined) key += `separator=${options.separator};`;
+	  if (options.split !== undefined) key += `split=${options.split};`;
+	  if (options.merge !== undefined) key += `merge=${options.merge};`;
+	  if (options.preservePaths !== undefined) key += `preservePaths=${options.preservePaths};`;
+	  return key;
+	};
+
+	const memoize = (input, options, fn) => {
+	  const key = toStringKey(options ? createMemoKey(input, options) : input);
+	  validateKey(key);
+
+	  const value = setValue.cache.get(key) || fn();
+	  setValue.cache.set(key, value);
+	  return value;
+	};
+
+	const splitString = (input, options = {}) => {
+	  const sep = options.separator || '.';
+	  const preserve = sep === '/' ? false : options.preservePaths;
+
+	  if (typeof input === 'string' && preserve !== false && /\//.test(input)) {
+	    return [input];
+	  }
+
+	  const parts = [];
+	  let part = '';
+
+	  const push = part => {
+	    let number;
+	    if (part.trim() !== '' && Number.isInteger((number = Number(part)))) {
+	      parts.push(number);
+	    } else {
+	      parts.push(part);
+	    }
+	  };
+
+	  for (let i = 0; i < input.length; i++) {
+	    const value = input[i];
+
+	    if (value === '\\') {
+	      part += input[++i];
+	      continue;
+	    }
+
+	    if (value === sep) {
+	      push(part);
+	      part = '';
+	      continue;
+	    }
+
+	    part += value;
+	  }
+
+	  if (part) {
+	    push(part);
+	  }
+
+	  return parts;
+	};
+
+	const split = (input, options) => {
+	  if (options && typeof options.split === 'function') return options.split(input);
+	  if (typeof input === 'symbol') return [input];
+	  if (Array.isArray(input)) return input;
+	  return memoize(input, options, () => splitString(input, options));
+	};
+
+	const assignProp = (obj, prop, value, options) => {
+	  validateKey(prop);
+
+	  // Delete property when "value" is undefined
+	  if (value === undefined) {
+	    deleteProperty(obj, prop);
+
+	  } else if (options && options.merge) {
+	    const merge = options.merge === 'function' ? options.merge : Object.assign;
+
+	    // Only merge plain objects
+	    if (merge && isPlainObject(obj[prop]) && isPlainObject(value)) {
+	      obj[prop] = merge(obj[prop], value);
+	    } else {
+	      obj[prop] = value;
+	    }
+
+	  } else {
+	    obj[prop] = value;
+	  }
+
+	  return obj;
+	};
+
+	const setValue = (target, path, value, options) => {
+	  if (!path || !isObject(target)) return target;
+
+	  const keys = split(path, options);
+	  let obj = target;
+
+	  for (let i = 0; i < keys.length; i++) {
+	    const key = keys[i];
+	    const next = keys[i + 1];
+
+	    validateKey(key);
+
+	    if (next === undefined) {
+	      assignProp(obj, key, value, options);
+	      break;
+	    }
+
+	    if (typeof next === 'number' && !Array.isArray(obj[key])) {
+	      obj = obj[key] = [];
+	      continue;
+	    }
+
+	    if (!isObject(obj[key])) {
+	      obj[key] = {};
+	    }
+
+	    obj = obj[key];
+	  }
+
+	  return target;
+	};
+
+	setValue.split = split;
+	setValue.cache = new Map();
+	setValue.clear = () => {
+	  setValue.cache = new Map();
+	};
+
+	setValue_1 = setValue;
+	return setValue_1;
+}
+
+var setValueExports = requireSetValue();
+var set = /*@__PURE__*/getDefaultExportFromCjs(setValueExports);
+
+const logger = createConsola();
+
+function fetchPackage(packageName, options) {
+    return fetch.json(`/${packageName}`, options);
+}
+function getLatestVersionInRange(packageName, versionRange, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetchPackage(packageName, options);
+        const versions = Object.keys(response.versions);
+        const filteredVersions = versions.filter(version => version.startsWith(versionRange));
+        return filteredVersions[filteredVersions.length - 1];
+    });
+}
+const defaultDevDeps = {
+    'tailwindcss': '3',
+    'postcss': '8',
+    'autoprefixer': '10',
+    'weapp-tailwindcss': '3',
+};
+function getDevDepsVersions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Object.fromEntries(yield Promise.all(Object.entries(defaultDevDeps).map((x) => __awaiter(this, void 0, void 0, function* () {
+            return [x[0], `^${yield getLatestVersionInRange(...x, options)}`];
+        }))));
+    });
+}
+
+function createContext(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { cwd, pkgJsonBasename, postcssConfigBasename, tailwindConfigBasename, fetchOptions } = options;
+        const pkgJsonPath = path.resolve(cwd, pkgJsonBasename);
+        if (yield fs.exists(pkgJsonPath)) {
+            const pkgJson = yield fs.readJson(pkgJsonPath);
+            const versions = yield getDevDepsVersions(fetchOptions);
+            return {
+                pkgJson,
+                pkgJsonPath,
+                cwd,
+                versions,
+                postcssConfigBasename,
+                tailwindConfigBasename,
+                get type() {
+                    return pkgJson.type;
+                },
+            };
+        }
+        else {
+            logger.warn('当前目录下不存在 `package.json` 文件，初始化脚本将被跳过，请执行 `npm init` 或手动创建 `package.json` 后重试 ');
+        }
+    });
+}
+function updatePackageJson(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        set(ctx.pkgJson, 'scripts.postinstall', 'weapp-tw patch');
+        for (const [key, value] of Object.entries(ctx.versions)) {
+            set(ctx.pkgJson, `devDependencies.${key}`, value);
+        }
+        yield fs.writeJSON(ctx.pkgJsonPath, ctx.pkgJson, { spaces: 2 });
+    });
+}
+function touchPostcssConfig(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = `${ctx.type === 'module' ? 'export default ' : 'module.exports = '}{
+  plugins: {
+    tailwindcss: {},
+    // 假如框架已经内置了 \`autoprefixer\`，可以去除下一行
+    autoprefixer: {},
+  }
+}`;
+        yield fs.writeFile(path.resolve(ctx.cwd, ctx.postcssConfigBasename), data);
+    });
+}
+function touchTailwindConfig(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = `/** @type {import('tailwindcss').Config} */
+${ctx.type === 'module' ? 'export default ' : 'module.exports = '}{
+  // 这里给出了一份 uni-app /taro 通用示例，具体要根据你自己项目的目录结构进行配置
+  // 不在 content 包括的文件内，你编写的 class，是不会生成对应的css工具类的
+  content: ['./public/index.html', './src/**/*.{html,js,ts,jsx,tsx,vue}'],
+  // 其他配置项
+  // ...
+  corePlugins: {
+    // 小程序不需要 preflight，因为这主要是给 h5 的，如果你要同时开发小程序和 h5 端，你应该使用环境变量来控制它
+    preflight: false,
+  },
+}`;
+        yield fs.writeFile(path.resolve(ctx.cwd, ctx.tailwindConfigBasename), data);
+    });
+}
+function getInitDefaults() {
+    return {
+        cwd: process$1.cwd(),
+        postcssConfigBasename: 'postcss.config.js',
+        tailwindConfigBasename: 'tailwind.config.js',
+        pkgJsonBasename: 'package.json',
+    };
+}
+function init(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = defu(options, getInitDefaults());
+        const ctx = yield createContext(opts);
+        if (ctx) {
+            yield updatePackageJson(ctx);
+            yield touchPostcssConfig(ctx);
+            yield touchTailwindConfig(ctx);
+        }
+    });
+}
+
+process$1.title = 'node (weapp-tailwindcss)';
+const args = process$1.argv.slice(2);
+if (semver.lt(process$1.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
+    console.error(`You are using Node.js ${process$1.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`);
+    process$1.exit(1);
 }
 const command = args[0];
 if (command === 'patch') {
     const options = getOptions();
     options.patch();
 }
+else if (command === 'init') {
+    init();
+}
 else {
     try {
         import('@weapp-tailwindcss/cli').then(({ createCli }) => {