@wzyjs/cli 0.2.12 → 0.2.37

package/dist/index.js

@@ -1,18 +1,3394 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const cac_1 = __importDefault(require("cac"));
-const dev_1 = __importDefault(require("./commands/dev"));
-const build_1 = __importDefault(require("./commands/build"));
-const start_1 = __importDefault(require("./commands/start"));
-const merge_1 = __importDefault(require("./commands/merge"));
-const cli = (0, cac_1.default)();
-(0, dev_1.default)(cli);
-(0, build_1.default)(cli);
-(0, start_1.default)(cli);
-(0, merge_1.default)(cli);
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/universalify/index.js
+var require_universalify = __commonJS((exports) => {
+  exports.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 });
+  };
+  exports.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 });
+  };
+});
+
+// ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS((exports, module) => {
+  function patch(fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      patchLchmod(fs);
+    }
+    if (!fs.lutimes) {
+      patchLutimes(fs);
+    }
+    fs.chown = chownFix(fs.chown);
+    fs.fchown = chownFix(fs.fchown);
+    fs.lchown = chownFix(fs.lchown);
+    fs.chmod = chmodFix(fs.chmod);
+    fs.fchmod = chmodFix(fs.fchmod);
+    fs.lchmod = chmodFix(fs.lchmod);
+    fs.chownSync = chownFixSync(fs.chownSync);
+    fs.fchownSync = chownFixSync(fs.fchownSync);
+    fs.lchownSync = chownFixSync(fs.lchownSync);
+    fs.chmodSync = chmodFixSync(fs.chmodSync);
+    fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+    fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+    fs.stat = statFix(fs.stat);
+    fs.fstat = statFix(fs.fstat);
+    fs.lstat = statFix(fs.lstat);
+    fs.statSync = statFixSync(fs.statSync);
+    fs.fstatSync = statFixSync(fs.fstatSync);
+    fs.lstatSync = statFixSync(fs.lstatSync);
+    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() {
+      };
+    }
+    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);
+    }
+    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);
+      }
+      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(fs2) {
+      fs2.lchmod = function(path, mode, callback) {
+        fs2.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+          if (err) {
+            if (callback)
+              callback(err);
+            return;
+          }
+          fs2.fchmod(fd, mode, function(err2) {
+            fs2.close(fd, function(err22) {
+              if (callback)
+                callback(err2 || err22);
+            });
+          });
+        });
+      };
+      fs2.lchmodSync = function(path, mode) {
+        var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        var threw = true;
+        var ret;
+        try {
+          ret = fs2.fchmodSync(fd, mode);
+          threw = false;
+        } finally {
+          if (threw) {
+            try {
+              fs2.closeSync(fd);
+            } catch (er) {
+            }
+          } else {
+            fs2.closeSync(fd);
+          }
+        }
+        return ret;
+      };
+    }
+    function patchLutimes(fs2) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+        fs2.lutimes = function(path, at, mt, cb) {
+          fs2.open(path, constants.O_SYMLINK, function(er, fd) {
+            if (er) {
+              if (cb)
+                cb(er);
+              return;
+            }
+            fs2.futimes(fd, at, mt, function(er2) {
+              fs2.close(fd, function(er22) {
+                if (cb)
+                  cb(er2 || er22);
+              });
+            });
+          });
+        };
+        fs2.lutimesSync = function(path, at, mt) {
+          var fd = fs2.openSync(path, constants.O_SYMLINK);
+          var ret;
+          var threw = true;
+          try {
+            ret = fs2.futimesSync(fd, at, mt);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs2.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs2.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      } else if (fs2.futimes) {
+        fs2.lutimes = function(_a, _b, _c, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs2.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;
+      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 += 4294967296;
+            if (stats.gid < 0)
+              stats.gid += 4294967296;
+          }
+          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;
+      return function(target, options) {
+        var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+        if (stats) {
+          if (stats.uid < 0)
+            stats.uid += 4294967296;
+          if (stats.gid < 0)
+            stats.gid += 4294967296;
+        }
+        return stats;
+      };
+    }
+    function chownErOk(er) {
+      if (!er)
+        return true;
+      if (er.code === "ENOSYS")
+        return true;
+      var nonroot = !process.getuid || process.getuid() !== 0;
+      if (nonroot) {
+        if (er.code === "EINVAL" || er.code === "EPERM")
+          return true;
+      }
+      return false;
+    }
+  }
+  var constants = import.meta.require("constants");
+  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) {
+  }
+  if (typeof process.chdir === "function") {
+    chdir = process.chdir;
+    process.chdir = function(d) {
+      cwd = null;
+      chdir.call(process, d);
+    };
+    if (Object.setPrototypeOf)
+      Object.setPrototypeOf(process.chdir, chdir);
+  }
+  var chdir;
+  module.exports = patch;
+});
+
+// ../../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS((exports, module) => {
+  function legacy(fs) {
+    return {
+      ReadStream,
+      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;
+      this.bufferSize = 64 * 1024;
+      options = options || {};
+      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 (typeof this.start !== "number") {
+          throw TypeError("start must be a Number");
+        }
+        if (this.end === undefined) {
+          this.end = Infinity;
+        } else if (typeof this.end !== "number") {
+          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;
+      this.bytesWritten = 0;
+      options = options || {};
+      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 (typeof this.start !== "number") {
+          throw TypeError("start must be a Number");
+        }
+        if (this.start < 0) {
+          throw new Error("start must be >= zero");
+        }
+        this.pos = this.start;
+      }
+      this.busy = false;
+      this._queue = [];
+      if (this.fd === null) {
+        this._open = fs.open;
+        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+        this.flush();
+      }
+    }
+  }
+  var Stream = import.meta.require("stream").Stream;
+  module.exports = legacy;
+});
+
+// ../../node_modules/graceful-fs/clone.js
+var require_clone = __commonJS((exports, module) => {
+  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;
+  }
+  module.exports = clone;
+  var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+    return obj.__proto__;
+  };
+});
+
+// ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS((exports, module) => {
+  function noop() {
+  }
+  function publishQueue(context, queue2) {
+    Object.defineProperty(context, gracefulQueue, {
+      get: function() {
+        return queue2;
+      }
+    });
+  }
+  function patch(fs2) {
+    polyfills(fs2);
+    fs2.gracefulify = patch;
+    fs2.createReadStream = createReadStream;
+    fs2.createWriteStream = createWriteStream;
+    var fs$readFile = fs2.readFile;
+    fs2.readFile = readFile;
+    function readFile(path, options, cb) {
+      if (typeof options === "function")
+        cb = options, options = null;
+      return go$readFile(path, options, cb);
+      function go$readFile(path2, options2, cb2, startTime) {
+        return fs$readFile(path2, options2, function(err) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+          else {
+            if (typeof cb2 === "function")
+              cb2.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$writeFile = fs2.writeFile;
+    fs2.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(path2, data2, options2, cb2, startTime) {
+        return fs$writeFile(path2, data2, options2, function(err) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+          else {
+            if (typeof cb2 === "function")
+              cb2.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$appendFile = fs2.appendFile;
+    if (fs$appendFile)
+      fs2.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(path2, data2, options2, cb2, startTime) {
+        return fs$appendFile(path2, data2, options2, function(err) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+          else {
+            if (typeof cb2 === "function")
+              cb2.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$copyFile = fs2.copyFile;
+    if (fs$copyFile)
+      fs2.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(src2, dest2, flags2, cb2, startTime) {
+        return fs$copyFile(src2, dest2, flags2, function(err) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+          else {
+            if (typeof cb2 === "function")
+              cb2.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$readdir = fs2.readdir;
+    fs2.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(path2, options2, cb2, startTime) {
+        return fs$readdir(path2, fs$readdirCallback(path2, options2, cb2, startTime));
+      } : function go$readdir(path2, options2, cb2, startTime) {
+        return fs$readdir(path2, options2, fs$readdirCallback(path2, options2, cb2, startTime));
+      };
+      return go$readdir(path, options, cb);
+      function fs$readdirCallback(path2, options2, cb2, startTime) {
+        return function(err, files) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([
+              go$readdir,
+              [path2, options2, cb2],
+              err,
+              startTime || Date.now(),
+              Date.now()
+            ]);
+          else {
+            if (files && files.sort)
+              files.sort();
+            if (typeof cb2 === "function")
+              cb2.call(this, err, files);
+          }
+        };
+      }
+    }
+    if (process.version.substr(0, 4) === "v0.8") {
+      var legStreams = legacy(fs2);
+      ReadStream = legStreams.ReadStream;
+      WriteStream = legStreams.WriteStream;
+    }
+    var fs$ReadStream = fs2.ReadStream;
+    if (fs$ReadStream) {
+      ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+      ReadStream.prototype.open = ReadStream$open;
+    }
+    var fs$WriteStream = fs2.WriteStream;
+    if (fs$WriteStream) {
+      WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+      WriteStream.prototype.open = WriteStream$open;
+    }
+    Object.defineProperty(fs2, "ReadStream", {
+      get: function() {
+        return ReadStream;
+      },
+      set: function(val) {
+        ReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(fs2, "WriteStream", {
+      get: function() {
+        return WriteStream;
+      },
+      set: function(val) {
+        WriteStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    var FileReadStream = ReadStream;
+    Object.defineProperty(fs2, "FileReadStream", {
+      get: function() {
+        return FileReadStream;
+      },
+      set: function(val) {
+        FileReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    var FileWriteStream = WriteStream;
+    Object.defineProperty(fs2, "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 fs2.ReadStream(path, options);
+    }
+    function createWriteStream(path, options) {
+      return new fs2.WriteStream(path, options);
+    }
+    var fs$open = fs2.open;
+    fs2.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(path2, flags2, mode2, cb2, startTime) {
+        return fs$open(path2, flags2, mode2, function(err, fd) {
+          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+            enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+          else {
+            if (typeof cb2 === "function")
+              cb2.apply(this, arguments);
+          }
+        });
+      }
+    }
+    return fs2;
+  }
+  function enqueue(elem) {
+    debug("ENQUEUE", elem[0].name, elem[1]);
+    fs[gracefulQueue].push(elem);
+    retry();
+  }
+  function resetQueue() {
+    var now = Date.now();
+    for (var i = 0;i < fs[gracefulQueue].length; ++i) {
+      if (fs[gracefulQueue][i].length > 2) {
+        fs[gracefulQueue][i][3] = now;
+        fs[gracefulQueue][i][4] = now;
+      }
+    }
+    retry();
+  }
+  function retry() {
+    clearTimeout(retryTimer);
+    retryTimer = undefined;
+    if (fs[gracefulQueue].length === 0)
+      return;
+    var elem = fs[gracefulQueue].shift();
+    var fn = elem[0];
+    var args = elem[1];
+    var err = elem[2];
+    var startTime = elem[3];
+    var lastTime = elem[4];
+    if (startTime === undefined) {
+      debug("RETRY", fn.name, args);
+      fn.apply(null, args);
+    } else if (Date.now() - startTime >= 60000) {
+      debug("TIMEOUT", fn.name, args);
+      var cb = args.pop();
+      if (typeof cb === "function")
+        cb.call(null, err);
+    } else {
+      var sinceAttempt = Date.now() - lastTime;
+      var sinceStart = Math.max(lastTime - startTime, 1);
+      var desiredDelay = Math.min(sinceStart * 1.2, 100);
+      if (sinceAttempt >= desiredDelay) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args.concat([startTime]));
+      } else {
+        fs[gracefulQueue].push(elem);
+      }
+    }
+    if (retryTimer === undefined) {
+      retryTimer = setTimeout(retry, 0);
+    }
+  }
+  var fs = import.meta.require("fs");
+  var polyfills = require_polyfills();
+  var legacy = require_legacy_streams();
+  var clone = require_clone();
+  var util = import.meta.require("util");
+  var gracefulQueue;
+  var previousSymbol;
+  if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+    gracefulQueue = Symbol.for("graceful-fs.queue");
+    previousSymbol = Symbol.for("graceful-fs.previous");
+  } else {
+    gracefulQueue = "___graceful-fs.queue";
+    previousSymbol = "___graceful-fs.previous";
+  }
+  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);
+    };
+  if (!fs[gracefulQueue]) {
+    queue = global[gracefulQueue] || [];
+    publishQueue(fs, queue);
+    fs.close = function(fs$close) {
+      function close(fd, cb) {
+        return fs$close.call(fs, fd, function(err) {
+          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) {
+        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]);
+        import.meta.require("assert").equal(fs[gracefulQueue].length, 0);
+      });
+    }
+  }
+  var queue;
+  if (!global[gracefulQueue]) {
+    publishQueue(global, fs[gracefulQueue]);
+  }
+  module.exports = patch(clone(fs));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs);
+    fs.__patched = true;
+  }
+  var retryTimer;
+});
+
+// ../../node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS((exports) => {
+  var u = require_universalify().fromCallback;
+  var fs = require_graceful_fs();
+  var 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) => {
+    return typeof fs[key] === "function";
+  });
+  Object.assign(exports, fs);
+  api.forEach((method) => {
+    exports[method] = u(fs[method]);
+  });
+  exports.exists = function(filename, callback) {
+    if (typeof callback === "function") {
+      return fs.exists(filename, callback);
+    }
+    return new Promise((resolve) => {
+      return fs.exists(filename, resolve);
+    });
+  };
+  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, buffer2) => {
+        if (err)
+          return reject(err);
+        resolve({ bytesRead, buffer: buffer2 });
+      });
+    });
+  };
+  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, buffer2) => {
+        if (err)
+          return reject(err);
+        resolve({ bytesWritten, buffer: buffer2 });
+      });
+    });
+  };
+  if (typeof fs.writev === "function") {
+    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, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+  }
+  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");
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS((exports, module) => {
+  var path = import.meta.require("path");
+  exports.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;
+      }
+    }
+  };
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS((exports, module) => {
+  var fs = require_fs();
+  var { checkPath } = require_utils();
+  var getMode = (options) => {
+    const defaults = { mode: 511 };
+    if (typeof options === "number")
+      return options;
+    return { ...defaults, ...options }.mode;
+  };
+  exports.makeDir = async (dir, options) => {
+    checkPath(dir);
+    return fs.mkdir(dir, {
+      mode: getMode(options),
+      recursive: true
+    });
+  };
+  exports.makeDirSync = (dir, options) => {
+    checkPath(dir);
+    return fs.mkdirSync(dir, {
+      mode: getMode(options),
+      recursive: true
+    });
+  };
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS((exports, module) => {
+  var u = require_universalify().fromPromise;
+  var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+  var makeDir = u(_makeDir);
+  module.exports = {
+    mkdirs: makeDir,
+    mkdirsSync: makeDirSync,
+    mkdirp: makeDir,
+    mkdirpSync: makeDirSync,
+    ensureDir: makeDir,
+    ensureDirSync: makeDirSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS((exports, module) => {
+  function pathExists(path) {
+    return fs.access(path).then(() => true).catch(() => false);
+  }
+  var u = require_universalify().fromPromise;
+  var fs = require_fs();
+  module.exports = {
+    pathExists: u(pathExists),
+    pathExistsSync: fs.existsSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS((exports, module) => {
+  function utimesMillis(path, atime, mtime, callback) {
+    fs.open(path, "r+", (err, fd) => {
+      if (err)
+        return callback(err);
+      fs.futimes(fd, atime, mtime, (futimesErr) => {
+        fs.close(fd, (closeErr) => {
+          if (callback)
+            callback(futimesErr || closeErr);
+        });
+      });
+    });
+  }
+  function utimesMillisSync(path, atime, mtime) {
+    const fd = fs.openSync(path, "r+");
+    fs.futimesSync(fd, atime, mtime);
+    return fs.closeSync(fd);
+  }
+  var fs = require_graceful_fs();
+  module.exports = {
+    utimesMillis,
+    utimesMillisSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS((exports, module) => {
+  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 };
+  }
+  function checkPaths(src, dest, funcName, opts, cb) {
+    util.callbackify(getStats)(src, dest, opts, (err, stats) => {
+      if (err)
+        return cb(err);
+      const { srcStat, destStat } = stats;
+      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 cb(null, { srcStat, destStat, isChangingCase: true });
+          }
+          return cb(new Error("Source and destination must not be the same."));
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`));
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        return cb(new Error(errMsg(src, dest, funcName)));
+      }
+      return cb(null, { 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 };
+  }
+  function checkParentPaths(src, srcStat, dest, funcName, cb) {
+    const srcParent = path.resolve(path.dirname(src));
+    const destParent = path.resolve(path.dirname(dest));
+    if (destParent === srcParent || destParent === path.parse(destParent).root)
+      return cb();
+    fs.stat(destParent, { bigint: true }, (err, destStat) => {
+      if (err) {
+        if (err.code === "ENOENT")
+          return cb();
+        return cb(err);
+      }
+      if (areIdentical(srcStat, destStat)) {
+        return cb(new Error(errMsg(src, dest, funcName)));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName, cb);
+    });
+  }
+  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;
+  }
+  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.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
+  }
+  function errMsg(src, dest, funcName) {
+    return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+  }
+  var fs = require_fs();
+  var path = import.meta.require("path");
+  var util = import.meta.require("util");
+  module.exports = {
+    checkPaths,
+    checkPathsSync,
+    checkParentPaths,
+    checkParentPathsSync,
+    isSrcSubdir,
+    areIdentical
+  };
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS((exports, module) => {
+  function copy(src, dest, opts, cb) {
+    if (typeof opts === "function" && !cb) {
+      cb = opts;
+      opts = {};
+    } else if (typeof opts === "function") {
+      opts = { filter: opts };
+    }
+    cb = cb || function() {
+    };
+    opts = opts || {};
+    opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+    opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+    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");
+    }
+    stat.checkPaths(src, dest, "copy", opts, (err, stats) => {
+      if (err)
+        return cb(err);
+      const { srcStat, destStat } = stats;
+      stat.checkParentPaths(src, srcStat, dest, "copy", (err2) => {
+        if (err2)
+          return cb(err2);
+        if (opts.filter)
+          return handleFilter(checkParentDir, destStat, src, dest, opts, cb);
+        return checkParentDir(destStat, src, dest, opts, cb);
+      });
+    });
+  }
+  function checkParentDir(destStat, src, dest, opts, cb) {
+    const destParent = path.dirname(dest);
+    pathExists(destParent, (err, dirExists) => {
+      if (err)
+        return cb(err);
+      if (dirExists)
+        return getStats(destStat, src, dest, opts, cb);
+      mkdirs(destParent, (err2) => {
+        if (err2)
+          return cb(err2);
+        return getStats(destStat, src, dest, opts, cb);
+      });
+    });
+  }
+  function handleFilter(onInclude, destStat, src, dest, opts, cb) {
+    Promise.resolve(opts.filter(src, dest)).then((include) => {
+      if (include)
+        return onInclude(destStat, src, dest, opts, cb);
+      return cb();
+    }, (error) => cb(error));
+  }
+  function startCopy(destStat, src, dest, opts, cb) {
+    if (opts.filter)
+      return handleFilter(getStats, destStat, src, dest, opts, cb);
+    return getStats(destStat, src, dest, opts, cb);
+  }
+  function getStats(destStat, src, dest, opts, cb) {
+    const stat2 = opts.dereference ? fs.stat : fs.lstat;
+    stat2(src, (err, srcStat) => {
+      if (err)
+        return cb(err);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts, cb);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts, cb);
+      else if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts, cb);
+      else if (srcStat.isSocket())
+        return cb(new Error(`Cannot copy a socket file: ${src}`));
+      else if (srcStat.isFIFO())
+        return cb(new Error(`Cannot copy a FIFO pipe: ${src}`));
+      return cb(new Error(`Unknown file: ${src}`));
+    });
+  }
+  function onFile(srcStat, destStat, src, dest, opts, cb) {
+    if (!destStat)
+      return copyFile(srcStat, src, dest, opts, cb);
+    return mayCopyFile(srcStat, src, dest, opts, cb);
+  }
+  function mayCopyFile(srcStat, src, dest, opts, cb) {
+    if (opts.overwrite) {
+      fs.unlink(dest, (err) => {
+        if (err)
+          return cb(err);
+        return copyFile(srcStat, src, dest, opts, cb);
+      });
+    } else if (opts.errorOnExist) {
+      return cb(new Error(`'${dest}' already exists`));
+    } else
+      return cb();
+  }
+  function copyFile(srcStat, src, dest, opts, cb) {
+    fs.copyFile(src, dest, (err) => {
+      if (err)
+        return cb(err);
+      if (opts.preserveTimestamps)
+        return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
+      return setDestMode(dest, srcStat.mode, cb);
+    });
+  }
+  function handleTimestampsAndMode(srcMode, src, dest, cb) {
+    if (fileIsNotWritable(srcMode)) {
+      return makeFileWritable(dest, srcMode, (err) => {
+        if (err)
+          return cb(err);
+        return setDestTimestampsAndMode(srcMode, src, dest, cb);
+      });
+    }
+    return setDestTimestampsAndMode(srcMode, src, dest, cb);
+  }
+  function fileIsNotWritable(srcMode) {
+    return (srcMode & 128) === 0;
+  }
+  function makeFileWritable(dest, srcMode, cb) {
+    return setDestMode(dest, srcMode | 128, cb);
+  }
+  function setDestTimestampsAndMode(srcMode, src, dest, cb) {
+    setDestTimestamps(src, dest, (err) => {
+      if (err)
+        return cb(err);
+      return setDestMode(dest, srcMode, cb);
+    });
+  }
+  function setDestMode(dest, srcMode, cb) {
+    return fs.chmod(dest, srcMode, cb);
+  }
+  function setDestTimestamps(src, dest, cb) {
+    fs.stat(src, (err, updatedSrcStat) => {
+      if (err)
+        return cb(err);
+      return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
+    });
+  }
+  function onDir(srcStat, destStat, src, dest, opts, cb) {
+    if (!destStat)
+      return mkDirAndCopy(srcStat.mode, src, dest, opts, cb);
+    return copyDir(src, dest, opts, cb);
+  }
+  function mkDirAndCopy(srcMode, src, dest, opts, cb) {
+    fs.mkdir(dest, (err) => {
+      if (err)
+        return cb(err);
+      copyDir(src, dest, opts, (err2) => {
+        if (err2)
+          return cb(err2);
+        return setDestMode(dest, srcMode, cb);
+      });
+    });
+  }
+  function copyDir(src, dest, opts, cb) {
+    fs.readdir(src, (err, items) => {
+      if (err)
+        return cb(err);
+      return copyDirItems(items, src, dest, opts, cb);
+    });
+  }
+  function copyDirItems(items, src, dest, opts, cb) {
+    const item = items.pop();
+    if (!item)
+      return cb();
+    return copyDirItem(items, item, src, dest, opts, cb);
+  }
+  function copyDirItem(items, item, src, dest, opts, cb) {
+    const srcItem = path.join(src, item);
+    const destItem = path.join(dest, item);
+    stat.checkPaths(srcItem, destItem, "copy", opts, (err, stats) => {
+      if (err)
+        return cb(err);
+      const { destStat } = stats;
+      startCopy(destStat, srcItem, destItem, opts, (err2) => {
+        if (err2)
+          return cb(err2);
+        return copyDirItems(items, src, dest, opts, cb);
+      });
+    });
+  }
+  function onLink(destStat, src, dest, opts, cb) {
+    fs.readlink(src, (err, resolvedSrc) => {
+      if (err)
+        return cb(err);
+      if (opts.dereference) {
+        resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs.symlink(resolvedSrc, dest, cb);
+      } else {
+        fs.readlink(dest, (err2, resolvedDest) => {
+          if (err2) {
+            if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
+              return fs.symlink(resolvedSrc, dest, cb);
+            return cb(err2);
+          }
+          if (opts.dereference) {
+            resolvedDest = path.resolve(process.cwd(), resolvedDest);
+          }
+          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+            return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
+          }
+          if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+            return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
+          }
+          return copyLink(resolvedSrc, dest, cb);
+        });
+      }
+    });
+  }
+  function copyLink(resolvedSrc, dest, cb) {
+    fs.unlink(dest, (err) => {
+      if (err)
+        return cb(err);
+      return fs.symlink(resolvedSrc, dest, cb);
+    });
+  }
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var mkdirs = require_mkdirs().mkdirs;
+  var pathExists = require_path_exists().pathExists;
+  var utimesMillis = require_utimes().utimesMillis;
+  var stat = require_stat();
+  module.exports = copy;
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = __commonJS((exports, module) => {
+  function copySync(src, dest, opts) {
+    if (typeof opts === "function") {
+      opts = { filter: opts };
+    }
+    opts = opts || {};
+    opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+    opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+    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");
+    return handleFilterAndCopy(destStat, src, dest, opts);
+  }
+  function handleFilterAndCopy(destStat, src, dest, opts) {
+    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 startCopy(destStat, src, dest, opts) {
+    if (opts.filter && !opts.filter(src, dest))
+      return;
+    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) {
+    if (fileIsNotWritable(srcMode))
+      makeFileWritable(dest, srcMode);
+    return setDestTimestamps(src, dest);
+  }
+  function fileIsNotWritable(srcMode) {
+    return (srcMode & 128) === 0;
+  }
+  function makeFileWritable(dest, srcMode) {
+    return setDestMode(dest, srcMode | 128);
+  }
+  function setDestMode(dest, srcMode) {
+    return fs.chmodSync(dest, srcMode);
+  }
+  function setDestTimestamps(src, dest) {
+    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);
+    const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+    return startCopy(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) {
+        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}'.`);
+      }
+      if (fs.statSync(dest).isDirectory() && 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);
+  }
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var mkdirsSync = require_mkdirs().mkdirsSync;
+  var utimesMillisSync = require_utimes().utimesMillisSync;
+  var stat = require_stat();
+  module.exports = copySync;
+});
+
+// ../../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS((exports, module) => {
+  var u = require_universalify().fromCallback;
+  module.exports = {
+    copy: u(require_copy()),
+    copySync: require_copy_sync()
+  };
+});
+
+// ../../node_modules/fs-extra/lib/remove/rimraf.js
+var require_rimraf = __commonJS((exports, module) => {
+  function defaults(options) {
+    const methods = [
+      "unlink",
+      "chmod",
+      "stat",
+      "lstat",
+      "rmdir",
+      "readdir"
+    ];
+    methods.forEach((m) => {
+      options[m] = options[m] || fs[m];
+      m = m + "Sync";
+      options[m] = options[m] || fs[m];
+    });
+    options.maxBusyTries = options.maxBusyTries || 3;
+  }
+  function rimraf(p, options, cb) {
+    let busyTries = 0;
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    assert(p, "rimraf: missing path");
+    assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
+    assert.strictEqual(typeof cb, "function", "rimraf: callback function required");
+    assert(options, "rimraf: invalid options argument provided");
+    assert.strictEqual(typeof options, "object", "rimraf: options should be object");
+    defaults(options);
+    rimraf_(p, options, function CB(er) {
+      if (er) {
+        if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
+          busyTries++;
+          const time = busyTries * 100;
+          return setTimeout(() => rimraf_(p, options, CB), time);
+        }
+        if (er.code === "ENOENT")
+          er = null;
+      }
+      cb(er);
+    });
+  }
+  function rimraf_(p, options, cb) {
+    assert(p);
+    assert(options);
+    assert(typeof cb === "function");
+    options.lstat(p, (er, st) => {
+      if (er && er.code === "ENOENT") {
+        return cb(null);
+      }
+      if (er && er.code === "EPERM" && isWindows) {
+        return fixWinEPERM(p, options, er, cb);
+      }
+      if (st && st.isDirectory()) {
+        return rmdir(p, options, er, cb);
+      }
+      options.unlink(p, (er2) => {
+        if (er2) {
+          if (er2.code === "ENOENT") {
+            return cb(null);
+          }
+          if (er2.code === "EPERM") {
+            return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
+          }
+          if (er2.code === "EISDIR") {
+            return rmdir(p, options, er2, cb);
+          }
+        }
+        return cb(er2);
+      });
+    });
+  }
+  function fixWinEPERM(p, options, er, cb) {
+    assert(p);
+    assert(options);
+    assert(typeof cb === "function");
+    options.chmod(p, 438, (er2) => {
+      if (er2) {
+        cb(er2.code === "ENOENT" ? null : er);
+      } else {
+        options.stat(p, (er3, stats) => {
+          if (er3) {
+            cb(er3.code === "ENOENT" ? null : er);
+          } else if (stats.isDirectory()) {
+            rmdir(p, options, er, cb);
+          } else {
+            options.unlink(p, cb);
+          }
+        });
+      }
+    });
+  }
+  function fixWinEPERMSync(p, options, er) {
+    let stats;
+    assert(p);
+    assert(options);
+    try {
+      options.chmodSync(p, 438);
+    } catch (er2) {
+      if (er2.code === "ENOENT") {
+        return;
+      } else {
+        throw er;
+      }
+    }
+    try {
+      stats = options.statSync(p);
+    } catch (er3) {
+      if (er3.code === "ENOENT") {
+        return;
+      } else {
+        throw er;
+      }
+    }
+    if (stats.isDirectory()) {
+      rmdirSync(p, options, er);
+    } else {
+      options.unlinkSync(p);
+    }
+  }
+  function rmdir(p, options, originalEr, cb) {
+    assert(p);
+    assert(options);
+    assert(typeof cb === "function");
+    options.rmdir(p, (er) => {
+      if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) {
+        rmkids(p, options, cb);
+      } else if (er && er.code === "ENOTDIR") {
+        cb(originalEr);
+      } else {
+        cb(er);
+      }
+    });
+  }
+  function rmkids(p, options, cb) {
+    assert(p);
+    assert(options);
+    assert(typeof cb === "function");
+    options.readdir(p, (er, files) => {
+      if (er)
+        return cb(er);
+      let n = files.length;
+      let errState;
+      if (n === 0)
+        return options.rmdir(p, cb);
+      files.forEach((f) => {
+        rimraf(path.join(p, f), options, (er2) => {
+          if (errState) {
+            return;
+          }
+          if (er2)
+            return cb(errState = er2);
+          if (--n === 0) {
+            options.rmdir(p, cb);
+          }
+        });
+      });
+    });
+  }
+  function rimrafSync(p, options) {
+    let st;
+    options = options || {};
+    defaults(options);
+    assert(p, "rimraf: missing path");
+    assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
+    assert(options, "rimraf: missing options");
+    assert.strictEqual(typeof options, "object", "rimraf: options should be object");
+    try {
+      st = options.lstatSync(p);
+    } catch (er) {
+      if (er.code === "ENOENT") {
+        return;
+      }
+      if (er.code === "EPERM" && isWindows) {
+        fixWinEPERMSync(p, options, er);
+      }
+    }
+    try {
+      if (st && st.isDirectory()) {
+        rmdirSync(p, options, null);
+      } else {
+        options.unlinkSync(p);
+      }
+    } catch (er) {
+      if (er.code === "ENOENT") {
+        return;
+      } else if (er.code === "EPERM") {
+        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+      } else if (er.code !== "EISDIR") {
+        throw er;
+      }
+      rmdirSync(p, options, er);
+    }
+  }
+  function rmdirSync(p, options, originalEr) {
+    assert(p);
+    assert(options);
+    try {
+      options.rmdirSync(p);
+    } catch (er) {
+      if (er.code === "ENOTDIR") {
+        throw originalEr;
+      } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") {
+        rmkidsSync(p, options);
+      } else if (er.code !== "ENOENT") {
+        throw er;
+      }
+    }
+  }
+  function rmkidsSync(p, options) {
+    assert(p);
+    assert(options);
+    options.readdirSync(p).forEach((f) => rimrafSync(path.join(p, f), options));
+    if (isWindows) {
+      const startTime = Date.now();
+      do {
+        try {
+          const ret = options.rmdirSync(p, options);
+          return ret;
+        } catch {
+        }
+      } while (Date.now() - startTime < 500);
+    } else {
+      const ret = options.rmdirSync(p, options);
+      return ret;
+    }
+  }
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var assert = import.meta.require("assert");
+  var isWindows = process.platform === "win32";
+  module.exports = rimraf;
+  rimraf.sync = rimrafSync;
+});
+
+// ../../node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS((exports, module) => {
+  function remove(path, callback) {
+    if (fs.rm)
+      return fs.rm(path, { recursive: true, force: true }, callback);
+    rimraf(path, callback);
+  }
+  function removeSync(path) {
+    if (fs.rmSync)
+      return fs.rmSync(path, { recursive: true, force: true });
+    rimraf.sync(path);
+  }
+  var fs = require_graceful_fs();
+  var u = require_universalify().fromCallback;
+  var rimraf = require_rimraf();
+  module.exports = {
+    remove: u(remove),
+    removeSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS((exports, module) => {
+  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);
+    });
+  }
+  var u = require_universalify().fromPromise;
+  var fs = require_fs();
+  var path = import.meta.require("path");
+  var mkdir = require_mkdirs();
+  var remove = require_remove();
+  var 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))));
+  });
+  module.exports = {
+    emptyDirSync,
+    emptydirSync: emptyDirSync,
+    emptyDir,
+    emptydir: emptyDir
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS((exports, module) => {
+  function createFile(file, callback) {
+    function makeFile() {
+      fs.writeFile(file, "", (err) => {
+        if (err)
+          return callback(err);
+        callback();
+      });
+    }
+    fs.stat(file, (err, stats) => {
+      if (!err && stats.isFile())
+        return callback();
+      const dir = path.dirname(file);
+      fs.stat(dir, (err2, stats2) => {
+        if (err2) {
+          if (err2.code === "ENOENT") {
+            return mkdir.mkdirs(dir, (err3) => {
+              if (err3)
+                return callback(err3);
+              makeFile();
+            });
+          }
+          return callback(err2);
+        }
+        if (stats2.isDirectory())
+          makeFile();
+        else {
+          fs.readdir(dir, (err3) => {
+            if (err3)
+              return callback(err3);
+          });
+        }
+      });
+    });
+  }
+  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()) {
+        fs.readdirSync(dir);
+      }
+    } catch (err) {
+      if (err && err.code === "ENOENT")
+        mkdir.mkdirsSync(dir);
+      else
+        throw err;
+    }
+    fs.writeFileSync(file, "");
+  }
+  var u = require_universalify().fromCallback;
+  var path = import.meta.require("path");
+  var fs = require_graceful_fs();
+  var mkdir = require_mkdirs();
+  module.exports = {
+    createFile: u(createFile),
+    createFileSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS((exports, module) => {
+  function createLink(srcpath, dstpath, callback) {
+    function makeLink(srcpath2, dstpath2) {
+      fs.link(srcpath2, dstpath2, (err) => {
+        if (err)
+          return callback(err);
+        callback(null);
+      });
+    }
+    fs.lstat(dstpath, (_, dstStat) => {
+      fs.lstat(srcpath, (err, srcStat) => {
+        if (err) {
+          err.message = err.message.replace("lstat", "ensureLink");
+          return callback(err);
+        }
+        if (dstStat && areIdentical(srcStat, dstStat))
+          return callback(null);
+        const dir = path.dirname(dstpath);
+        pathExists(dir, (err2, dirExists) => {
+          if (err2)
+            return callback(err2);
+          if (dirExists)
+            return makeLink(srcpath, dstpath);
+          mkdir.mkdirs(dir, (err3) => {
+            if (err3)
+              return callback(err3);
+            makeLink(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);
+  }
+  var u = require_universalify().fromCallback;
+  var path = import.meta.require("path");
+  var fs = require_graceful_fs();
+  var mkdir = require_mkdirs();
+  var pathExists = require_path_exists().pathExists;
+  var { areIdentical } = require_stat();
+  module.exports = {
+    createLink: u(createLink),
+    createLinkSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS((exports, module) => {
+  function symlinkPaths(srcpath, dstpath, callback) {
+    if (path.isAbsolute(srcpath)) {
+      return fs.lstat(srcpath, (err) => {
+        if (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          return callback(err);
+        }
+        return callback(null, {
+          toCwd: srcpath,
+          toDst: srcpath
+        });
+      });
+    } else {
+      const dstdir = path.dirname(dstpath);
+      const relativeToDst = path.join(dstdir, srcpath);
+      return pathExists(relativeToDst, (err, exists) => {
+        if (err)
+          return callback(err);
+        if (exists) {
+          return callback(null, {
+            toCwd: relativeToDst,
+            toDst: srcpath
+          });
+        } else {
+          return fs.lstat(srcpath, (err2) => {
+            if (err2) {
+              err2.message = err2.message.replace("lstat", "ensureSymlink");
+              return callback(err2);
+            }
+            return callback(null, {
+              toCwd: srcpath,
+              toDst: path.relative(dstdir, srcpath)
+            });
+          });
+        }
+      });
+    }
+  }
+  function symlinkPathsSync(srcpath, dstpath) {
+    let exists;
+    if (path.isAbsolute(srcpath)) {
+      exists = fs.existsSync(srcpath);
+      if (!exists)
+        throw new Error("absolute srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: srcpath
+      };
+    } else {
+      const dstdir = path.dirname(dstpath);
+      const relativeToDst = path.join(dstdir, srcpath);
+      exists = fs.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      } else {
+        exists = fs.existsSync(srcpath);
+        if (!exists)
+          throw new Error("relative srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: path.relative(dstdir, srcpath)
+        };
+      }
+    }
+  }
+  var path = import.meta.require("path");
+  var fs = require_graceful_fs();
+  var pathExists = require_path_exists().pathExists;
+  module.exports = {
+    symlinkPaths,
+    symlinkPathsSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS((exports, module) => {
+  function symlinkType(srcpath, type, callback) {
+    callback = typeof type === "function" ? type : callback;
+    type = typeof type === "function" ? false : type;
+    if (type)
+      return callback(null, type);
+    fs.lstat(srcpath, (err, stats) => {
+      if (err)
+        return callback(null, "file");
+      type = stats && stats.isDirectory() ? "dir" : "file";
+      callback(null, type);
+    });
+  }
+  function symlinkTypeSync(srcpath, type) {
+    let stats;
+    if (type)
+      return type;
+    try {
+      stats = fs.lstatSync(srcpath);
+    } catch {
+      return "file";
+    }
+    return stats && stats.isDirectory() ? "dir" : "file";
+  }
+  var fs = require_graceful_fs();
+  module.exports = {
+    symlinkType,
+    symlinkTypeSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS((exports, module) => {
+  function createSymlink(srcpath, dstpath, type, callback) {
+    callback = typeof type === "function" ? type : callback;
+    type = typeof type === "function" ? false : type;
+    fs.lstat(dstpath, (err, stats) => {
+      if (!err && stats.isSymbolicLink()) {
+        Promise.all([
+          fs.stat(srcpath),
+          fs.stat(dstpath)
+        ]).then(([srcStat, dstStat]) => {
+          if (areIdentical(srcStat, dstStat))
+            return callback(null);
+          _createSymlink(srcpath, dstpath, type, callback);
+        });
+      } else
+        _createSymlink(srcpath, dstpath, type, callback);
+    });
+  }
+  function _createSymlink(srcpath, dstpath, type, callback) {
+    symlinkPaths(srcpath, dstpath, (err, relative) => {
+      if (err)
+        return callback(err);
+      srcpath = relative.toDst;
+      symlinkType(relative.toCwd, type, (err2, type2) => {
+        if (err2)
+          return callback(err2);
+        const dir = path.dirname(dstpath);
+        pathExists(dir, (err3, dirExists) => {
+          if (err3)
+            return callback(err3);
+          if (dirExists)
+            return fs.symlink(srcpath, dstpath, type2, callback);
+          mkdirs(dir, (err4) => {
+            if (err4)
+              return callback(err4);
+            fs.symlink(srcpath, dstpath, type2, callback);
+          });
+        });
+      });
+    });
+  }
+  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);
+  }
+  var u = require_universalify().fromCallback;
+  var path = import.meta.require("path");
+  var fs = require_fs();
+  var _mkdirs = require_mkdirs();
+  var mkdirs = _mkdirs.mkdirs;
+  var mkdirsSync = _mkdirs.mkdirsSync;
+  var _symlinkPaths = require_symlink_paths();
+  var symlinkPaths = _symlinkPaths.symlinkPaths;
+  var symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
+  var _symlinkType = require_symlink_type();
+  var symlinkType = _symlinkType.symlinkType;
+  var symlinkTypeSync = _symlinkType.symlinkTypeSync;
+  var pathExists = require_path_exists().pathExists;
+  var { areIdentical } = require_stat();
+  module.exports = {
+    createSymlink: u(createSymlink),
+    createSymlinkSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS((exports, module) => {
+  var { createFile, createFileSync } = require_file();
+  var { createLink, createLinkSync } = require_link();
+  var { createSymlink, createSymlinkSync } = require_symlink();
+  module.exports = {
+    createFile,
+    createFileSync,
+    ensureFile: createFile,
+    ensureFileSync: createFileSync,
+    createLink,
+    createLinkSync,
+    ensureLink: createLink,
+    ensureLinkSync: createLinkSync,
+    createSymlink,
+    createSymlinkSync,
+    ensureSymlink: createSymlink,
+    ensureSymlinkSync: createSymlinkSync
+  };
+});
+
+// ../../node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS((exports, module) => {
+  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) {
+    if (Buffer.isBuffer(content))
+      content = content.toString("utf8");
+    return content.replace(/^\uFEFF/, "");
+  }
+  module.exports = { stringify, stripBom };
+});
+
+// ../../node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS((exports, module) => {
+  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;
+  }
+  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);
+  }
+  function writeFileSync(file, obj, options = {}) {
+    const fs = options.fs || _fs;
+    const str = stringify(obj, options);
+    return fs.writeFileSync(file, str, options);
+  }
+  var _fs;
+  try {
+    _fs = require_graceful_fs();
+  } catch (_) {
+    _fs = import.meta.require("fs");
+  }
+  var universalify = require_universalify();
+  var { stringify, stripBom } = require_utils2();
+  var readFile = universalify.fromPromise(_readFile);
+  var writeFile = universalify.fromPromise(_writeFile);
+  var jsonfile = {
+    readFile,
+    readFileSync,
+    writeFile,
+    writeFileSync
+  };
+  module.exports = jsonfile;
+});
+
+// ../../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS((exports, module) => {
+  var jsonFile = require_jsonfile();
+  module.exports = {
+    readJson: jsonFile.readFile,
+    readJsonSync: jsonFile.readFileSync,
+    writeJson: jsonFile.writeFile,
+    writeJsonSync: jsonFile.writeFileSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS((exports, module) => {
+  function outputFile(file, data, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = "utf8";
+    }
+    const dir = path.dirname(file);
+    pathExists(dir, (err, itDoes) => {
+      if (err)
+        return callback(err);
+      if (itDoes)
+        return fs.writeFile(file, data, encoding, callback);
+      mkdir.mkdirs(dir, (err2) => {
+        if (err2)
+          return callback(err2);
+        fs.writeFile(file, data, encoding, callback);
+      });
+    });
+  }
+  function outputFileSync(file, ...args) {
+    const dir = path.dirname(file);
+    if (fs.existsSync(dir)) {
+      return fs.writeFileSync(file, ...args);
+    }
+    mkdir.mkdirsSync(dir);
+    fs.writeFileSync(file, ...args);
+  }
+  var u = require_universalify().fromCallback;
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var mkdir = require_mkdirs();
+  var pathExists = require_path_exists().pathExists;
+  module.exports = {
+    outputFile: u(outputFile),
+    outputFileSync
+  };
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS((exports, module) => {
+  async function outputJson(file, data, options = {}) {
+    const str = stringify(data, options);
+    await outputFile(file, str, options);
+  }
+  var { stringify } = require_utils2();
+  var { outputFile } = require_output_file();
+  module.exports = outputJson;
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS((exports, module) => {
+  function outputJsonSync(file, data, options) {
+    const str = stringify(data, options);
+    outputFileSync(file, str, options);
+  }
+  var { stringify } = require_utils2();
+  var { outputFileSync } = require_output_file();
+  module.exports = outputJsonSync;
+});
+
+// ../../node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS((exports, module) => {
+  var u = require_universalify().fromPromise;
+  var jsonFile = require_jsonfile2();
+  jsonFile.outputJson = u(require_output_json());
+  jsonFile.outputJsonSync = require_output_json_sync();
+  jsonFile.outputJSON = jsonFile.outputJson;
+  jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+  jsonFile.writeJSON = jsonFile.writeJson;
+  jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+  jsonFile.readJSON = jsonFile.readJson;
+  jsonFile.readJSONSync = jsonFile.readJsonSync;
+  module.exports = jsonFile;
+});
+
+// ../../node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS((exports, module) => {
+  function move(src, dest, opts, cb) {
+    if (typeof opts === "function") {
+      cb = opts;
+      opts = {};
+    }
+    opts = opts || {};
+    const overwrite = opts.overwrite || opts.clobber || false;
+    stat.checkPaths(src, dest, "move", opts, (err, stats) => {
+      if (err)
+        return cb(err);
+      const { srcStat, isChangingCase = false } = stats;
+      stat.checkParentPaths(src, srcStat, dest, "move", (err2) => {
+        if (err2)
+          return cb(err2);
+        if (isParentRoot(dest))
+          return doRename(src, dest, overwrite, isChangingCase, cb);
+        mkdirp(path.dirname(dest), (err3) => {
+          if (err3)
+            return cb(err3);
+          return doRename(src, dest, overwrite, isChangingCase, cb);
+        });
+      });
+    });
+  }
+  function isParentRoot(dest) {
+    const parent = path.dirname(dest);
+    const parsedPath = path.parse(parent);
+    return parsedPath.root === parent;
+  }
+  function doRename(src, dest, overwrite, isChangingCase, cb) {
+    if (isChangingCase)
+      return rename(src, dest, overwrite, cb);
+    if (overwrite) {
+      return remove(dest, (err) => {
+        if (err)
+          return cb(err);
+        return rename(src, dest, overwrite, cb);
+      });
+    }
+    pathExists(dest, (err, destExists) => {
+      if (err)
+        return cb(err);
+      if (destExists)
+        return cb(new Error("dest already exists."));
+      return rename(src, dest, overwrite, cb);
+    });
+  }
+  function rename(src, dest, overwrite, cb) {
+    fs.rename(src, dest, (err) => {
+      if (!err)
+        return cb();
+      if (err.code !== "EXDEV")
+        return cb(err);
+      return moveAcrossDevice(src, dest, overwrite, cb);
+    });
+  }
+  function moveAcrossDevice(src, dest, overwrite, cb) {
+    const opts = {
+      overwrite,
+      errorOnExist: true
+    };
+    copy(src, dest, opts, (err) => {
+      if (err)
+        return cb(err);
+      return remove(src, cb);
+    });
+  }
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var copy = require_copy2().copy;
+  var remove = require_remove().remove;
+  var mkdirp = require_mkdirs().mkdirp;
+  var pathExists = require_path_exists().pathExists;
+  var stat = require_stat();
+  module.exports = move;
+});
+
+// ../../node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS((exports, module) => {
+  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
+    };
+    copySync(src, dest, opts);
+    return removeSync(src);
+  }
+  var fs = require_graceful_fs();
+  var path = import.meta.require("path");
+  var copySync = require_copy2().copySync;
+  var removeSync = require_remove().removeSync;
+  var mkdirpSync = require_mkdirs().mkdirpSync;
+  var stat = require_stat();
+  module.exports = moveSync;
+});
+
+// ../../node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS((exports, module) => {
+  var u = require_universalify().fromCallback;
+  module.exports = {
+    move: u(require_move()),
+    moveSync: require_move_sync()
+  };
+});
+
+// ../../node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  module.exports = {
+    ...require_fs(),
+    ...require_copy2(),
+    ...require_empty(),
+    ...require_ensure(),
+    ...require_json(),
+    ...require_mkdirs(),
+    ...require_move2(),
+    ...require_output_file(),
+    ...require_path_exists(),
+    ...require_remove()
+  };
+});
+
+// ../../node_modules/cac/dist/index.mjs
+import { EventEmitter } from "events";
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = ~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== undefined;
+  const strict = opts.unknown !== undefined;
+  const defaults = opts.default !== undefined;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0;i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length;i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length;j-- > 0; )
+      opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length;i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length;j-- > 0; )
+      opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== undefined) {
+        opts[name].push(k);
+        for (i = 0;i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0;i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0;j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45)
+        break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1;idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61)
+          break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0;idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name))
+          return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === undefined) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+var findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+var getMriOptions = (options) => {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+var findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+var padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+var camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+var setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (;i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+var setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+var getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+var camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+
+class CACError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+}
+
+class Option {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+}
+var processArgs = process.argv;
+var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+
+class Command {
+  constructor(rawName, description, config = {}, cli) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  \$ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  \$ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === undefined ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+}
+
+class GlobalCommand extends Command {
+  constructor(cli) {
+    super("@@global@@", "", {}, cli);
+  }
+}
+var __assign = Object.assign;
+
+class CAC extends EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = undefined;
+    this.matchedCommandName = undefined;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, { _: [] });
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== undefined) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === undefined) {
+          transforms[cliOption.name] = Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+}
+var cac = (name = "") => new CAC(name);
+var dist_default = cac;
+
+// src/commands/gen/index.ts
+var import_fs_extra2 = __toESM(require_lib(), 1);
+
+// src/commands/gen/utils.ts
+var import_fs_extra = __toESM(require_lib(), 1);
+import path from "path";
+var splitPath = (path2) => {
+  return path2.split("/").filter(Boolean);
+};
+var capitalizeFirstLetter = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var replaceAndCopyFile = async (sourceFilePath, targetFilePath, replacements) => {
+  try {
+    let result = await import_fs_extra.default.readFile(sourceFilePath, "utf8");
+    for (const [searchValue, newValue] of replacements) {
+      result = result.replace(searchValue, newValue);
+    }
+    const filePathToWrite = targetFilePath || sourceFilePath;
+    const dirPath = path.dirname(filePathToWrite);
+    await import_fs_extra.default.ensureDir(dirPath);
+    await import_fs_extra.default.writeFile(filePathToWrite, result, "utf8");
+  } catch (err) {
+    console.error("\u64CD\u4F5C\u6587\u4EF6\u5931\u8D25:", err);
+  }
+};
+var addRoute = async (routesFilePath, newName, newPath, newComponent) => {
+  try {
+    const routesContent = await import_fs_extra.default.readFile(routesFilePath, "utf-8");
+    const routes = new Function(routesContent.replace("export default", "return"))();
+    const newPage = {
+      name: newName,
+      path: newPath,
+      component: newComponent,
+      wrappers: ["@/wrappers/login"]
+    };
+    routes.splice(routes.length - 1, 0, newPage);
+    const updatedRoutesContent = `export default ${JSON.stringify(routes, null, 1)}\n`;
+    await import_fs_extra.default.writeFile(routesFilePath, updatedRoutesContent, "utf-8");
+  } catch (error) {
+    console.error("\u6DFB\u52A0\u9875\u9762\u5931\u8D25\uFF1A", error);
+  }
+};
+var getTsType = (type) => {
+  const tsTypeMap = new Map;
+  tsTypeMap.set(["int", "tinyint", "smallint", "mediumint", "bigint", "float", "double", "decimal"], "number");
+  tsTypeMap.set(["char", "varchar", "binary", "varbinary", "tinyblob", "blob", "mediumblob", "longblob", "tinytext", "text", "mediumtext", "longtext", "enum", "set"], "string");
+  tsTypeMap.set(["boolean"], "boolean");
+  tsTypeMap.set(["date", "datetime", "timestamp", "time", "year"], "Date");
+  for (const [keys, value] of tsTypeMap.entries()) {
+    if (keys.includes(type)) {
+      return value;
+    }
+  }
+  throw new Error(`\u9519\u8BEF\u7684\u6570\u636E\u5E93\u5B57\u6BB5\u7C7B\u578B: ${type}`);
+};
+var parseColumns = (input) => {
+  return input.split(",").map((column) => {
+    const [nameAndType, defaultValue] = column.split("=");
+    const [name, type] = nameAndType.split(":");
+    return {
+      name,
+      type,
+      tsType: getTsType(type),
+      ...defaultValue ? { default: defaultValue } : { nullable: true }
+    };
+  });
+};
+var generateEntityClass = (columns) => {
+  return columns.map((column) => {
+    const nullable = column.nullable ? ", nullable: true" : "";
+    const defaultVal = column.default !== undefined ? `, default: ${column.default}` : "";
+    return `  @Column({ type: '${column.type}'${nullable}${defaultVal} })
+  ${column.name}${column.nullable ? "?" : "!"}: ${column.tsType}`;
+  }).join("\n\n").trimStart();
+};
+var generateFormConfig = (columns) => {
+  return columns.map((column) => {
+    const title = column.name.charAt(0).toUpperCase() + column.name.slice(1);
+    const validator = column.nullable ? "[]" : `['require']`;
+    const hideInSearch = column.tsType === "boolean" ? "true" : "false";
+    return `{
+      title: '${title}',
+      dataIndex: '${column.name}',
+      ellipsis: true,
+      ${validator.length ? `validator: ${validator},` : ""}
+      hideInSearch: ${hideInSearch}
+    }`;
+  }).join(",\n");
+};
+
+// src/commands/gen/index.ts
+var __dirname = "/Users/wangzhenyu/Code/newWork/libs/cli/src/commands/gen";
+var gen_default = (cli) => {
+  cli.command("g <type> <p> <cnName> <column>", "\u751F\u6210\u4EE3\u7801\u6587\u4EF6\uFF0C\u4F7F\u7528\u65B9\u5F0F\uFF1Ami g 3 /user User name:varchar,age:tinyint,isMan:boolean=1").action(async (type, p, cnName, column) => {
+    const paths = splitPath(p);
+    const columns = parseColumns(column);
+    const name = paths[paths.length - 1];
+    const modelName = capitalizeFirstLetter(name);
+    const pathModelName = paths.slice(0, -1).join("/") + (paths.slice(0, -1) ? "/" : "") + modelName;
+    const projectPath = process.cwd();
+    const templatesPath = `${__dirname}/templates`;
+    if (parseInt(type) >= 1) {
+      const modelPath = `${projectPath}/src/apis/entities/${pathModelName}.ts`;
+      if (!import_fs_extra2.existsSync(modelPath)) {
+        const modelTempPath = templatesPath + "/model.temp";
+        const modelIndexPath = `${projectPath}/src/apis/entities/index.ts`;
+        const content = generateEntityClass(columns);
+        await replaceAndCopyFile(modelTempPath, modelPath, [
+          [/\[modelName]/g, modelName],
+          [/\[content]/, content]
+        ]);
+        await replaceAndCopyFile(modelIndexPath, null, [
+          [/(?:\r?\n)+$/, `\r\nexport * from './${pathModelName}'\r\n`]
+        ]);
+        console.log(`${modelName}: Model \u521B\u5EFA\u6210\u529F`);
+      } else {
+        console.log(`${modelName} Model \u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7`);
+      }
+    }
+    if (parseInt(type) >= 2) {
+      const apiPath = `${projectPath}/src/apis/routes/${paths.join("/")}/index.ts`;
+      if (!import_fs_extra2.existsSync(apiPath)) {
+        const apiTempPath = templatesPath + "/api.temp";
+        const apiIndexPath = `${projectPath}/src/apis/index.ts`;
+        await replaceAndCopyFile(apiTempPath, apiPath, [
+          [/\[cnName]/g, cnName],
+          [/\[modelName]/g, modelName],
+          [/\[pathModelName]/g, pathModelName]
+        ]);
+        await replaceAndCopyFile(apiIndexPath, null, [
+          [/(?:\r?\n)+$/, `\r\nexport * as ${name} from './routes/${paths.join("/")}'\r\n`]
+        ]);
+        console.log(`${modelName}: Api \u521B\u5EFA\u6210\u529F`);
+      } else {
+        console.log(`${modelName} Api \u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7`);
+      }
+    }
+    if (parseInt(type) >= 3) {
+      const pagePath = `${projectPath}/src/pages/${pathModelName}/index.tsx`;
+      if (!import_fs_extra2.existsSync(pagePath)) {
+        const pageTempPath = templatesPath + "/page.temp";
+        const pageRoutesPath = `${projectPath}/config/routes.ts`;
+        const content = generateFormConfig(columns);
+        await replaceAndCopyFile(pageTempPath, pagePath, [
+          [/\[name]/g, name],
+          [/\[content]/, content]
+        ]);
+        await addRoute(pageRoutesPath, cnName, `/${paths.join("/")}`, `./${pathModelName}`);
+        console.log(`${modelName}: Page \u521B\u5EFA\u6210\u529F`);
+      } else {
+        console.log(`${modelName} Page \u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7`);
+      }
+    }
+  });
+};
+
+// src/commands/merge/script.ts
+import { exec } from "child_process";
+async function getLatestCommitMsg() {
+  return execGitCommand(`git log -1 --pretty=%B`);
+}
+function getContinuousCommitCount() {
+  return new Promise((resolve, reject) => {
+    exec(`git log --oneline --format=%s`, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const messages = stdout.split("\n");
+      const msg = messages[0];
+      let count = 0;
+      for (const item of messages) {
+        if (item !== msg) {
+          break;
+        }
+        count++;
+      }
+      resolve(count);
+    });
+  });
+}
+function execGitCommand(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+var script_default = async (options) => {
+  const hasChange = await execGitCommand("git status -s");
+  if (hasChange) {
+    if (options?.commit) {
+      console.log("commit success", await execGitCommand(`git commit -a -m "${(await getLatestCommitMsg()).trim()}"`));
+    } else {
+      console.log("stash success", await execGitCommand("git stash"));
+    }
+  }
+  const count = options?.count || await getContinuousCommitCount();
+  const command = `GIT_EDITOR=true GIT_SEQUENCE_EDITOR="sed -i -e '2,\\\$s/^pick/squash/'" git rebase -i HEAD~${count}`;
+  console.log("rebase success", await execGitCommand(command));
+  if (options?.push) {
+    console.log("push success", await execGitCommand("git push origin HEAD --force"));
+  }
+  if (hasChange && !options?.commit) {
+    await execGitCommand("git stash pop");
+  }
+};
+
+// src/commands/merge/index.ts
+var merge_default = (cli) => {
+  cli.command("m", "\u5408\u5E76 commit").option("--count [number]", "\u5408\u5E76\u51E0\u4E2Acommit\uFF0C\u4E0D\u586B\u4F1A\u81EA\u52A8\u8BA1\u7B97\u4E0E\u6700\u65B0commit\u76F8\u540C\u540D\u79F0\u7684\u6570\u91CF").option("--commit [boolean]", "\u662F\u5426\u5728\u5408\u5E76\u524D\u63D0\u4EA4\u4EE3\u7801").option("--push [boolean]", "\u662F\u5426\u5728\u5408\u5E76\u540E\u63A8\u9001\u4EE3\u7801").action(script_default);
+};
+
+// src/commands/summary/script.ts
+import fs from "fs";
+import path2 from "path";
+var __filename = "/Users/wangzhenyu/Code/newWork/libs/cli/src/commands/summary/script.ts";
+var defaultConfig = {
+  ignoreDirs: ["node_modules", ".git"],
+  ignoreFiles: [],
+  allowedExtensions: [".ts", ".js"],
+  includeHiddenDirs: false
+};
+var getAllFiles = (dirPath, config = defaultConfig, filesArray = []) => {
+  const files = fs.readdirSync(dirPath);
+  files.forEach((file) => {
+    const filePath = path2.join(dirPath, file);
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      const isHidden = path2.basename(filePath).startsWith(".");
+      if (!isHidden || config.includeHiddenDirs) {
+        if (!config.ignoreDirs?.some((dir) => filePath.includes(dir))) {
+          getAllFiles(filePath, config, filesArray);
+        }
+      }
+    } else if (config.allowedExtensions?.includes(path2.extname(file)) && !config.ignoreFiles?.some((ignoreFile) => filePath.includes(ignoreFile))) {
+      filesArray.push(filePath);
+    }
+  });
+  return filesArray;
+};
+var mergeCodeFiles = (dirPath, config = defaultConfig, maxSize) => {
+  let mergedContent = "";
+  const files = getAllFiles(dirPath, config);
+  files.forEach((filePath) => {
+    try {
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      if (fileContent.length <= maxSize) {
+        mergedContent += `### ${filePath.replace(dirPath, "")}\n\`\`\`${path2.extname(filePath).slice(1)}\n${fileContent}\n\`\`\`\n\n`;
+      }
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error);
+    }
+  });
+  return mergedContent;
+};
+var saveAsMarkdown = (content, outputFile) => {
+  try {
+    fs.writeFileSync(outputFile, content, "utf-8");
+    console.log(`Merged code saved as: ${outputFile}`);
+  } catch (error) {
+    console.error(`Error writing file ${outputFile}:`, error);
+  }
+};
+var script_default2 = async () => {
+  const projectDir = process.cwd();
+  const outputMarkdownFile = path2.resolve("./summary.md");
+  const currentScriptPath = path2.resolve(__filename);
+  const customConfig = {
+    ignoreDirs: ["node_modules", "dist", "linshi", "helper", "projects", "shells"],
+    ignoreFiles: [currentScriptPath],
+    allowedExtensions: [".ts", ".js", ".json"],
+    includeHiddenDirs: false
+  };
+  const mergedContent = mergeCodeFiles(projectDir, customConfig, 3000);
+  saveAsMarkdown(mergedContent, outputMarkdownFile);
+};
+
+// src/commands/summary/index.ts
+var summary_default = (cli) => {
+  cli.command("s", "\u751F\u6210\u9879\u76EE\u7684\u4EE3\u7801\u6458\u8981").action(script_default2);
+};
+
+// src/index.ts
+var cli = dist_default();
+merge_default(cli);
+gen_default(cli);
+summary_default(cli);
 cli.help();
-cli.version('0.0.3');
+cli.version("0.0.5");
 cli.parse();