create-react-router 0.0.0-experimental-16086cbff

package/dist/cli.js

@@ -0,0 +1,4563 @@
+#!/usr/bin/env node
+/**
+ * create-react-router v0.0.0-experimental-16086cbff
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports2) {
+    "use strict";
+    exports2.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) => {
+            fn.call(
+              this,
+              ...args,
+              (err, res) => err != null ? reject(err) : resolve(res)
+            );
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports2.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function") return fn.apply(this, args);
+        else fn.apply(this, args.slice(0, -1)).then((r) => cb(null, r), cb);
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    "use strict";
+    var constants = 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;
+    module2.exports = patch;
+    function patch(fs4) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs4);
+      }
+      if (!fs4.lutimes) {
+        patchLutimes(fs4);
+      }
+      fs4.chown = chownFix(fs4.chown);
+      fs4.fchown = chownFix(fs4.fchown);
+      fs4.lchown = chownFix(fs4.lchown);
+      fs4.chmod = chmodFix(fs4.chmod);
+      fs4.fchmod = chmodFix(fs4.fchmod);
+      fs4.lchmod = chmodFix(fs4.lchmod);
+      fs4.chownSync = chownFixSync(fs4.chownSync);
+      fs4.fchownSync = chownFixSync(fs4.fchownSync);
+      fs4.lchownSync = chownFixSync(fs4.lchownSync);
+      fs4.chmodSync = chmodFixSync(fs4.chmodSync);
+      fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
+      fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
+      fs4.stat = statFix(fs4.stat);
+      fs4.fstat = statFix(fs4.fstat);
+      fs4.lstat = statFix(fs4.lstat);
+      fs4.statSync = statFixSync(fs4.statSync);
+      fs4.fstatSync = statFixSync(fs4.fstatSync);
+      fs4.lstatSync = statFixSync(fs4.lstatSync);
+      if (fs4.chmod && !fs4.lchmod) {
+        fs4.lchmod = function(path4, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchmodSync = function() {
+        };
+      }
+      if (fs4.chown && !fs4.lchown) {
+        fs4.lchown = function(path4, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs4.rename = typeof fs4.rename !== "function" ? fs4.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 < 6e4) {
+                setTimeout(function() {
+                  fs4.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;
+        }(fs4.rename);
+      }
+      fs4.read = typeof fs4.read !== "function" ? fs4.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(fs4, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs4.read);
+      fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs4, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs4.readSync);
+      function patchLchmod(fs5) {
+        fs5.lchmod = function(path4, mode, callback) {
+          fs5.open(
+            path4,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs5.fchmod(fd, mode, function(err2) {
+                fs5.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs5.lchmodSync = function(path4, mode) {
+          var fd = fs5.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs5.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs5.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs5.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs5) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
+          fs5.lutimes = function(path4, at, mt, cb) {
+            fs5.open(path4, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs5.futimes(fd, at, mt, function(er2) {
+                fs5.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs5.lutimesSync = function(path4, at, mt) {
+            var fd = fs5.openSync(path4, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs5.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs5.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs5.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs5.futimes) {
+          fs5.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs5.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs4, 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(fs4, 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(fs4, 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(fs4, 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(fs4, target, options, callback) : orig.call(fs4, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, 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;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    "use strict";
+    var Stream = require("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs4) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path4, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path4, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path4;
+        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 !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs4.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(path4, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path4, options);
+        Stream.call(this);
+        this.path = path4;
+        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 !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs4.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = 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";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug2 = noop;
+    if (util.debuglog)
+      debug2 = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug2 = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs4[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs4, queue);
+      fs4.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs4, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs4.close);
+      fs4.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs4, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs4.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug2(fs4[gracefulQueue]);
+          require("assert").equal(fs4[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs4[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs4));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
+      module2.exports = patch(fs4);
+      fs4.__patched = true;
+    }
+    function patch(fs5) {
+      polyfills(fs5);
+      fs5.gracefulify = patch;
+      fs5.createReadStream = createReadStream;
+      fs5.createWriteStream = createWriteStream;
+      var fs$readFile = fs5.readFile;
+      fs5.readFile = readFile;
+      function readFile(path4, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path4, options, cb);
+        function go$readFile(path5, options2, cb2, startTime) {
+          return fs$readFile(path5, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path5, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs5.writeFile;
+      fs5.writeFile = writeFile;
+      function writeFile(path4, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path4, data, options, cb);
+        function go$writeFile(path5, data2, options2, cb2, startTime) {
+          return fs$writeFile(path5, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs5.appendFile;
+      if (fs$appendFile)
+        fs5.appendFile = appendFile;
+      function appendFile(path4, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path4, data, options, cb);
+        function go$appendFile(path5, data2, options2, cb2, startTime) {
+          return fs$appendFile(path5, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs5.copyFile;
+      if (fs$copyFile)
+        fs5.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 = fs5.readdir;
+      fs5.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path4, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, fs$readdirCallback(
+            path5,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, options2, fs$readdirCallback(
+            path5,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path4, options, cb);
+        function fs$readdirCallback(path5, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path5, 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(fs5);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs5.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs5.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs5, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs5, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs5, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs5, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path4, 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(path4, 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(path4, options) {
+        return new fs5.ReadStream(path4, options);
+      }
+      function createWriteStream(path4, options) {
+        return new fs5.WriteStream(path4, options);
+      }
+      var fs$open = fs5.open;
+      fs5.open = open;
+      function open(path4, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path4, flags, mode, cb);
+        function go$open(path5, flags2, mode2, cb2, startTime) {
+          return fs$open(path5, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path5, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs5;
+    }
+    function enqueue(elem) {
+      debug2("ENQUEUE", elem[0].name, elem[1]);
+      fs4[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
+        if (fs4[gracefulQueue][i].length > 2) {
+          fs4[gracefulQueue][i][3] = now;
+          fs4[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs4[gracefulQueue].length === 0)
+        return;
+      var elem = fs4[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug2("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug2("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) {
+          debug2("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs4[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/fs/index.js"(exports2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs4 = 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 fs4[key] === "function";
+    });
+    Object.assign(exports2, fs4);
+    api.forEach((method) => {
+      exports2[method] = u(fs4[method]);
+    });
+    exports2.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs4.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs4.exists(filename, resolve);
+      });
+    };
+    exports2.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs4.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs4.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    if (typeof fs4.writev === "function") {
+      exports2.writev = function(fd, buffers, ...args) {
+        if (typeof args[args.length - 1] === "function") {
+          return fs4.writev(fd, buffers, ...args);
+        }
+        return new Promise((resolve, reject) => {
+          fs4.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+            if (err) return reject(err);
+            resolve({ bytesWritten, buffers: buffers2 });
+          });
+        });
+      };
+    }
+    if (typeof fs4.realpath.native === "function") {
+      exports2.realpath.native = u(fs4.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
+    "use strict";
+    var path4 = require("path");
+    module2.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path4.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error2 = new Error(`Path contains invalid characters: ${pth}`);
+          error2.code = "EINVAL";
+          throw error2;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number") return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module2.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs4.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module2.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs4.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module2.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs4 = require_fs();
+    function pathExists(path4) {
+      return fs4.access(path4).then(() => true).catch(() => false);
+    }
+    module2.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs4.existsSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    function utimesMillis(path4, atime, mtime, callback) {
+      fs4.open(path4, "r+", (err, fd) => {
+        if (err) return callback(err);
+        fs4.futimes(fd, atime, mtime, (futimesErr) => {
+          fs4.close(fd, (closeErr) => {
+            if (callback) callback(futimesErr || closeErr);
+          });
+        });
+      });
+    }
+    function utimesMillisSync(path4, atime, mtime) {
+      const fd = fs4.openSync(path4, "r+");
+      fs4.futimesSync(fd, atime, mtime);
+      return fs4.closeSync(fd);
+    }
+    module2.exports = {
+      utimesMillis,
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_fs();
+    var path4 = require("path");
+    var util = require("util");
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs4.stat(file, { bigint: true }) : (file) => fs4.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) => fs4.statSync(file, { bigint: true }) : (file) => fs4.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 = path4.basename(src);
+            const destBaseName = path4.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 = path4.basename(src);
+          const destBaseName = path4.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 = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return cb();
+      fs4.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 = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = fs4.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 = path4.resolve(src).split(path4.sep).filter((i) => i);
+      const destArr = path4.resolve(dest).split(path4.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}'.`;
+    }
+    module2.exports = {
+      checkPaths,
+      checkPathsSync,
+      checkParentPaths,
+      checkParentPathsSync,
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdirs = require_mkdirs().mkdirs;
+    var pathExists = require_path_exists().pathExists;
+    var utimesMillis = require_utimes().utimesMillis;
+    var stat = require_stat();
+    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	see 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 = path4.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();
+      }, (error2) => cb(error2));
+    }
+    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 ? fs4.stat : fs4.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) {
+        fs4.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) {
+      fs4.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 fs4.chmod(dest, srcMode, cb);
+    }
+    function setDestTimestamps(src, dest, cb) {
+      fs4.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) {
+      fs4.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) {
+      fs4.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 = path4.join(src, item);
+      const destItem = path4.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) {
+      fs4.readlink(src, (err, resolvedSrc) => {
+        if (err) return cb(err);
+        if (opts.dereference) {
+          resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
+        }
+        if (!destStat) {
+          return fs4.symlink(resolvedSrc, dest, cb);
+        } else {
+          fs4.readlink(dest, (err2, resolvedDest) => {
+            if (err2) {
+              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs4.symlink(resolvedSrc, dest, cb);
+              return cb(err2);
+            }
+            if (opts.dereference) {
+              resolvedDest = path4.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) {
+      fs4.unlink(dest, (err) => {
+        if (err) return cb(err);
+        return fs4.symlink(resolvedSrc, dest, cb);
+      });
+    }
+    module2.exports = copy;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    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	see 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 = path4.dirname(dest);
+      if (!fs4.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 ? fs4.statSync : fs4.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) {
+        fs4.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs4.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 fs4.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs4.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) {
+      fs4.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs4.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path4.join(src, item);
+      const destItem = path4.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 = fs4.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs4.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs4.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs4.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path4.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (fs4.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs4.unlinkSync(dest);
+      return fs4.symlinkSync(resolvedSrc, dest);
+    }
+    module2.exports = copySync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/remove/rimraf.js
+var require_rimraf = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
+    var assert = require("assert");
+    var isWindows = process.platform === "win32";
+    function defaults(options) {
+      const methods = [
+        "unlink",
+        "chmod",
+        "stat",
+        "lstat",
+        "rmdir",
+        "readdir"
+      ];
+      methods.forEach((m) => {
+        options[m] = options[m] || fs4[m];
+        m = m + "Sync";
+        options[m] = options[m] || fs4[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(path4.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(path4.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;
+      }
+    }
+    module2.exports = rimraf;
+    rimraf.sync = rimrafSync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    var rimraf = require_rimraf();
+    function remove(path4, callback) {
+      if (fs4.rm) return fs4.rm(path4, { recursive: true, force: true }, callback);
+      rimraf(path4, callback);
+    }
+    function removeSync(path4) {
+      if (fs4.rmSync) return fs4.rmSync(path4, { recursive: true, force: true });
+      rimraf.sync(path4);
+    }
+    module2.exports = {
+      remove: u(remove),
+      removeSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs4 = require_fs();
+    var path4 = require("path");
+    var mkdir = require_mkdirs();
+    var remove = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs4.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path4.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs4.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path4.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module2.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs4 = require_graceful_fs();
+    var mkdir = require_mkdirs();
+    function createFile(file, callback) {
+      function makeFile() {
+        fs4.writeFile(file, "", (err) => {
+          if (err) return callback(err);
+          callback();
+        });
+      }
+      fs4.stat(file, (err, stats) => {
+        if (!err && stats.isFile()) return callback();
+        const dir = path4.dirname(file);
+        fs4.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 {
+            fs4.readdir(dir, (err3) => {
+              if (err3) return callback(err3);
+            });
+          }
+        });
+      });
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs4.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path4.dirname(file);
+      try {
+        if (!fs4.statSync(dir).isDirectory()) {
+          fs4.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+        else throw err;
+      }
+      fs4.writeFileSync(file, "");
+    }
+    module2.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs4 = require_graceful_fs();
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    var { areIdentical } = require_stat();
+    function createLink(srcpath, dstpath, callback) {
+      function makeLink(srcpath2, dstpath2) {
+        fs4.link(srcpath2, dstpath2, (err) => {
+          if (err) return callback(err);
+          callback(null);
+        });
+      }
+      fs4.lstat(dstpath, (_, dstStat) => {
+        fs4.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 = path4.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 = fs4.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs4.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat)) return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path4.dirname(dstpath);
+      const dirExists = fs4.existsSync(dir);
+      if (dirExists) return fs4.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs4.linkSync(srcpath, dstpath);
+    }
+    module2.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
+    "use strict";
+    var path4 = require("path");
+    var fs4 = require_graceful_fs();
+    var pathExists = require_path_exists().pathExists;
+    function symlinkPaths(srcpath, dstpath, callback) {
+      if (path4.isAbsolute(srcpath)) {
+        return fs4.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 = path4.dirname(dstpath);
+        const relativeToDst = path4.join(dstdir, srcpath);
+        return pathExists(relativeToDst, (err, exists) => {
+          if (err) return callback(err);
+          if (exists) {
+            return callback(null, {
+              toCwd: relativeToDst,
+              toDst: srcpath
+            });
+          } else {
+            return fs4.lstat(srcpath, (err2) => {
+              if (err2) {
+                err2.message = err2.message.replace("lstat", "ensureSymlink");
+                return callback(err2);
+              }
+              return callback(null, {
+                toCwd: srcpath,
+                toDst: path4.relative(dstdir, srcpath)
+              });
+            });
+          }
+        });
+      }
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      let exists;
+      if (path4.isAbsolute(srcpath)) {
+        exists = fs4.existsSync(srcpath);
+        if (!exists) throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      } else {
+        const dstdir = path4.dirname(dstpath);
+        const relativeToDst = path4.join(dstdir, srcpath);
+        exists = fs4.existsSync(relativeToDst);
+        if (exists) {
+          return {
+            toCwd: relativeToDst,
+            toDst: srcpath
+          };
+        } else {
+          exists = fs4.existsSync(srcpath);
+          if (!exists) throw new Error("relative srcpath does not exist");
+          return {
+            toCwd: srcpath,
+            toDst: path4.relative(dstdir, srcpath)
+          };
+        }
+      }
+    }
+    module2.exports = {
+      symlinkPaths,
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    function symlinkType(srcpath, type, callback) {
+      callback = typeof type === "function" ? type : callback;
+      type = typeof type === "function" ? false : type;
+      if (type) return callback(null, type);
+      fs4.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 = fs4.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module2.exports = {
+      symlinkType,
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs4 = 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();
+    function createSymlink(srcpath, dstpath, type, callback) {
+      callback = typeof type === "function" ? type : callback;
+      type = typeof type === "function" ? false : type;
+      fs4.lstat(dstpath, (err, stats) => {
+        if (!err && stats.isSymbolicLink()) {
+          Promise.all([
+            fs4.stat(srcpath),
+            fs4.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 = path4.dirname(dstpath);
+          pathExists(dir, (err3, dirExists) => {
+            if (err3) return callback(err3);
+            if (dirExists) return fs4.symlink(srcpath, dstpath, type2, callback);
+            mkdirs(dir, (err4) => {
+              if (err4) return callback(err4);
+              fs4.symlink(srcpath, dstpath, type2, callback);
+            });
+          });
+        });
+      });
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs4.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs4.statSync(srcpath);
+        const dstStat = fs4.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path4.dirname(dstpath);
+      const exists = fs4.existsSync(dir);
+      if (exists) return fs4.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs4.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+    "use strict";
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module2.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports2, module2) {
+    "use strict";
+    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/, "");
+    }
+    module2.exports = { stringify, stripBom };
+  }
+});
+
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports2, module2) {
+    "use strict";
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils2();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs4 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs4.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;
+    }
+    var readFile = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs4 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs4.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 fs4 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs4.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs4 = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs4.writeFileSync(file, str, options);
+    }
+    var jsonfile = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync
+    };
+    module2.exports = jsonfile;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module2.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    function outputFile(file, data, encoding, callback) {
+      if (typeof encoding === "function") {
+        callback = encoding;
+        encoding = "utf8";
+      }
+      const dir = path4.dirname(file);
+      pathExists(dir, (err, itDoes) => {
+        if (err) return callback(err);
+        if (itDoes) return fs4.writeFile(file, data, encoding, callback);
+        mkdir.mkdirs(dir, (err2) => {
+          if (err2) return callback(err2);
+          fs4.writeFile(file, data, encoding, callback);
+        });
+      });
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path4.dirname(file);
+      if (fs4.existsSync(dir)) {
+        return fs4.writeFileSync(file, ...args);
+      }
+      mkdir.mkdirsSync(dir);
+      fs4.writeFileSync(file, ...args);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module2.exports = outputJson;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module2.exports = outputJsonSync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+    "use strict";
+    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;
+    module2.exports = jsonFile;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path4 = 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();
+    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(path4.dirname(dest), (err3) => {
+            if (err3) return cb(err3);
+            return doRename(src, dest, overwrite, isChangingCase, cb);
+          });
+        });
+      });
+    }
+    function isParentRoot(dest) {
+      const parent = path4.dirname(dest);
+      const parsedPath = path4.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) {
+      fs4.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);
+      });
+    }
+    module2.exports = move;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    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(path4.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path4.dirname(dest);
+      const parsedPath = path4.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 (fs4.existsSync(dest)) throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs4.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);
+    }
+    module2.exports = moveSync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
+// cli.ts
+var import_node_process7 = __toESM(require("process"));
+
+// index.ts
+var import_node_process6 = __toESM(require("process"));
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_path3 = __toESM(require("path"));
+var import_fs_extra = __toESM(require_lib());
+var import_strip_ansi = __toESM(require("strip-ansi"));
+var import_execa = __toESM(require("execa"));
+var import_arg = __toESM(require("arg"));
+var semver = __toESM(require("semver"));
+var import_sort_package_json = __toESM(require("sort-package-json"));
+
+// package.json
+var version = "0.0.0-experimental-16086cbff";
+
+// prompt.ts
+var import_node_process3 = __toESM(require("process"));
+
+// prompts-confirm.ts
+var import_sisteransi3 = require("sisteransi");
+
+// prompts-prompt-base.ts
+var import_node_process2 = __toESM(require("process"));
+var import_node_events = __toESM(require("events"));
+var import_node_readline = __toESM(require("readline"));
+var import_sisteransi2 = require("sisteransi");
+
+// utils.ts
+var import_node_path = __toESM(require("path"));
+var import_node_process = __toESM(require("process"));
+var import_node_os = __toESM(require("os"));
+var import_node_fs = __toESM(require("fs"));
+var import_sisteransi = require("sisteransi");
+var import_chalk = __toESM(require("chalk"));
+var import_recursive_readdir = __toESM(require("recursive-readdir"));
+var SUPPORTS_COLOR = import_chalk.default.supportsColor && !import_node_process.default.env.NO_COLOR;
+var color = {
+  supportsColor: SUPPORTS_COLOR,
+  heading: safeColor(import_chalk.default.bold),
+  arg: safeColor(import_chalk.default.yellowBright),
+  error: safeColor(import_chalk.default.red),
+  warning: safeColor(import_chalk.default.yellow),
+  hint: safeColor(import_chalk.default.blue),
+  bold: safeColor(import_chalk.default.bold),
+  black: safeColor(import_chalk.default.black),
+  white: safeColor(import_chalk.default.white),
+  blue: safeColor(import_chalk.default.blue),
+  cyan: safeColor(import_chalk.default.cyan),
+  red: safeColor(import_chalk.default.red),
+  yellow: safeColor(import_chalk.default.yellow),
+  green: safeColor(import_chalk.default.green),
+  blackBright: safeColor(import_chalk.default.blackBright),
+  whiteBright: safeColor(import_chalk.default.whiteBright),
+  blueBright: safeColor(import_chalk.default.blueBright),
+  cyanBright: safeColor(import_chalk.default.cyanBright),
+  redBright: safeColor(import_chalk.default.redBright),
+  yellowBright: safeColor(import_chalk.default.yellowBright),
+  greenBright: safeColor(import_chalk.default.greenBright),
+  bgBlack: safeColor(import_chalk.default.bgBlack),
+  bgWhite: safeColor(import_chalk.default.bgWhite),
+  bgBlue: safeColor(import_chalk.default.bgBlue),
+  bgCyan: safeColor(import_chalk.default.bgCyan),
+  bgRed: safeColor(import_chalk.default.bgRed),
+  bgYellow: safeColor(import_chalk.default.bgYellow),
+  bgGreen: safeColor(import_chalk.default.bgGreen),
+  bgBlackBright: safeColor(import_chalk.default.bgBlackBright),
+  bgWhiteBright: safeColor(import_chalk.default.bgWhiteBright),
+  bgBlueBright: safeColor(import_chalk.default.bgBlueBright),
+  bgCyanBright: safeColor(import_chalk.default.bgCyanBright),
+  bgRedBright: safeColor(import_chalk.default.bgRedBright),
+  bgYellowBright: safeColor(import_chalk.default.bgYellowBright),
+  bgGreenBright: safeColor(import_chalk.default.bgGreenBright),
+  gray: safeColor(import_chalk.default.gray),
+  dim: safeColor(import_chalk.default.dim),
+  reset: safeColor(import_chalk.default.reset),
+  inverse: safeColor(import_chalk.default.inverse),
+  hex: (color2) => safeColor(import_chalk.default.hex(color2)),
+  underline: import_chalk.default.underline
+};
+function safeColor(style) {
+  return SUPPORTS_COLOR ? style : identity;
+}
+var unicode = { enabled: import_node_os.default.platform() !== "win32" };
+var shouldUseAscii = () => !unicode.enabled;
+function isInteractive() {
+  if ("CREATE_REACT_ROUTER_FORCE_INTERACTIVE" in import_node_process.default.env) {
+    return true;
+  }
+  return Boolean(
+    import_node_process.default.stdout.isTTY && import_node_process.default.env.TERM !== "dumb" && !("CI" in import_node_process.default.env)
+  );
+}
+function log(message) {
+  return import_node_process.default.stdout.write(message + "\n");
+}
+var stderr = import_node_process.default.stderr;
+function logError(message) {
+  return stderr.write(message + "\n");
+}
+function logBullet(logger, colorizePrefix, colorizeText, symbol, prefix, text) {
+  let textParts = Array.isArray(text) ? text : [text || ""].filter(Boolean);
+  let formattedText = textParts.map((textPart) => colorizeText(textPart)).join("");
+  if (import_node_process.default.stdout.columns < 80) {
+    logger(
+      `${" ".repeat(5)} ${colorizePrefix(symbol)}  ${colorizePrefix(prefix)}`
+    );
+    logger(`${" ".repeat(9)}${formattedText}`);
+  } else {
+    logger(
+      `${" ".repeat(5)} ${colorizePrefix(symbol)}  ${colorizePrefix(
+        prefix
+      )} ${formattedText}`
+    );
+  }
+}
+function debug(prefix, text) {
+  logBullet(log, color.yellow, color.dim, "\u25CF", prefix, text);
+}
+function info(prefix, text) {
+  logBullet(log, color.cyan, color.dim, "\u25FC", prefix, text);
+}
+function error(prefix, text) {
+  log("");
+  logBullet(logError, color.red, color.error, "\u25B2", prefix, text);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toValidProjectName(projectName) {
+  if (isValidProjectName(projectName)) {
+    return projectName;
+  }
+  return projectName.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z\d\-~]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function isValidProjectName(projectName) {
+  return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(
+    projectName
+  );
+}
+function identity(v) {
+  return v;
+}
+function strip(str) {
+  let pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
+  ].join("|");
+  let RGX = new RegExp(pattern, "g");
+  return typeof str === "string" ? str.replace(RGX, "") : str;
+}
+function reverse(arr) {
+  return [...arr].reverse();
+}
+function isValidJsonObject(obj) {
+  return !!(obj && typeof obj === "object" && !Array.isArray(obj));
+}
+async function directoryExists(p) {
+  try {
+    let stat = await import_node_fs.default.promises.stat(p);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectory(dir) {
+  if (!await directoryExists(dir)) {
+    await import_node_fs.default.promises.mkdir(dir, { recursive: true });
+  }
+}
+function isUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+function clear(prompt2, perLine) {
+  if (!perLine) return import_sisteransi.erase.line + import_sisteransi.cursor.to(0);
+  let rows = 0;
+  let lines2 = prompt2.split(/\r?\n/);
+  for (let line of lines2) {
+    rows += 1 + Math.floor(Math.max(strip(line).length - 1, 0) / perLine);
+  }
+  return import_sisteransi.erase.lines(rows);
+}
+function lines(msg, perLine) {
+  let lines2 = String(strip(msg) || "").split(/\r?\n/);
+  if (!perLine) return lines2.length;
+  return lines2.map((l) => Math.ceil(l.length / perLine)).reduce((a, b) => a + b);
+}
+function action(key, isSelect) {
+  if (key.meta && key.name !== "escape") return;
+  if (key.ctrl) {
+    if (key.name === "a") return "first";
+    if (key.name === "c") return "abort";
+    if (key.name === "d") return "abort";
+    if (key.name === "e") return "last";
+    if (key.name === "g") return "reset";
+  }
+  if (isSelect) {
+    if (key.name === "j") return "down";
+    if (key.name === "k") return "up";
+  }
+  if (key.name === "return") return "submit";
+  if (key.name === "enter") return "submit";
+  if (key.name === "backspace") return "delete";
+  if (key.name === "delete") return "deleteForward";
+  if (key.name === "abort") return "abort";
+  if (key.name === "escape") return "exit";
+  if (key.name === "tab") return "next";
+  if (key.name === "pagedown") return "nextPage";
+  if (key.name === "pageup") return "prevPage";
+  if (key.name === "home") return "home";
+  if (key.name === "end") return "end";
+  if (key.name === "up") return "up";
+  if (key.name === "down") return "down";
+  if (key.name === "right") return "right";
+  if (key.name === "left") return "left";
+  return false;
+}
+function stripDirectoryFromPath(dir, filePath) {
+  let stripped = filePath;
+  if (dir.endsWith(import_node_path.default.sep) && filePath.startsWith(dir) || !dir.endsWith(import_node_path.default.sep) && filePath.startsWith(dir + import_node_path.default.sep)) {
+    stripped = filePath.slice(dir.length);
+    if (stripped.startsWith(import_node_path.default.sep)) {
+      stripped = stripped.slice(1);
+    }
+  }
+  return stripped;
+}
+var IGNORED_TEMPLATE_DIRECTORIES = [".git", "node_modules"];
+async function getDirectoryFilesRecursive(dir) {
+  let files = await (0, import_recursive_readdir.default)(dir, [
+    (file) => {
+      let strippedFile = stripDirectoryFromPath(dir, file);
+      let parts = strippedFile.split(import_node_path.default.sep);
+      return parts.length > 1 && IGNORED_TEMPLATE_DIRECTORIES.includes(parts[0]);
+    }
+  ]);
+  return files.map((f) => stripDirectoryFromPath(dir, f));
+}
+
+// prompts-prompt-base.ts
+var Prompt = class extends import_node_events.default {
+  firstRender;
+  in;
+  out;
+  onRender;
+  close;
+  aborted;
+  exited;
+  closed;
+  name = "Prompt";
+  constructor(opts = {}) {
+    super();
+    this.firstRender = true;
+    this.in = opts.stdin || import_node_process2.default.stdin;
+    this.out = opts.stdout || import_node_process2.default.stdout;
+    this.onRender = (opts.onRender || (() => void 0)).bind(this);
+    let rl = import_node_readline.default.createInterface({
+      input: this.in,
+      escapeCodeTimeout: 50
+    });
+    import_node_readline.default.emitKeypressEvents(this.in, rl);
+    if (this.in.isTTY) this.in.setRawMode(true);
+    let isSelect = ["SelectPrompt", "MultiSelectPrompt"].indexOf(this.constructor.name) > -1;
+    let keypress = (str, key) => {
+      if (this.in.isTTY) this.in.setRawMode(true);
+      let a = action(key, isSelect);
+      if (a === false) {
+        try {
+          this._(str, key);
+        } catch (_) {
+        }
+      } else if (typeof this[a] === "function") {
+        this[a](key);
+      }
+    };
+    this.close = () => {
+      this.out.write(import_sisteransi2.cursor.show);
+      this.in.removeListener("keypress", keypress);
+      if (this.in.isTTY) this.in.setRawMode(false);
+      rl.close();
+      this.emit(
+        this.aborted ? "abort" : this.exited ? "exit" : "submit",
+        // @ts-expect-error
+        this.value
+      );
+      this.closed = true;
+    };
+    this.in.on("keypress", keypress);
+  }
+  get type() {
+    throw new Error("Method type not implemented.");
+  }
+  bell() {
+    this.out.write(import_sisteransi2.beep);
+  }
+  fire() {
+    this.emit("state", {
+      // @ts-expect-error
+      value: this.value,
+      aborted: !!this.aborted,
+      exited: !!this.exited
+    });
+  }
+  render() {
+    this.onRender(color);
+    if (this.firstRender) this.firstRender = false;
+  }
+  _(c, key) {
+    throw new Error("Method _ not implemented.");
+  }
+};
+
+// prompts-confirm.ts
+var ConfirmPrompt = class extends Prompt {
+  label;
+  msg;
+  value;
+  initialValue;
+  hint;
+  choices;
+  cursor;
+  done;
+  name = "ConfirmPrompt";
+  // set by render which is called in constructor
+  outputText;
+  constructor(opts) {
+    super(opts);
+    this.label = opts.label;
+    this.hint = opts.hint;
+    this.msg = opts.message;
+    this.value = opts.initial;
+    this.initialValue = !!opts.initial;
+    this.choices = [
+      { value: true, label: "Yes" },
+      { value: false, label: "No" }
+    ];
+    this.cursor = this.choices.findIndex((c) => c.value === this.initialValue);
+    this.render();
+  }
+  get type() {
+    return "confirm";
+  }
+  exit() {
+    this.abort();
+  }
+  abort() {
+    this.done = this.aborted = true;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  submit() {
+    this.value = this.value || false;
+    this.cursor = this.choices.findIndex((c) => c.value === this.value);
+    this.done = true;
+    this.aborted = false;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  moveCursor(n) {
+    this.cursor = n;
+    this.value = this.choices[n].value;
+    this.fire();
+  }
+  reset() {
+    this.moveCursor(0);
+    this.fire();
+    this.render();
+  }
+  first() {
+    this.moveCursor(0);
+    this.render();
+  }
+  last() {
+    this.moveCursor(this.choices.length - 1);
+    this.render();
+  }
+  left() {
+    if (this.cursor === 0) {
+      this.moveCursor(this.choices.length - 1);
+    } else {
+      this.moveCursor(this.cursor - 1);
+    }
+    this.render();
+  }
+  right() {
+    if (this.cursor === this.choices.length - 1) {
+      this.moveCursor(0);
+    } else {
+      this.moveCursor(this.cursor + 1);
+    }
+    this.render();
+  }
+  _(c, key) {
+    if (!Number.isNaN(Number.parseInt(c))) {
+      let n = Number.parseInt(c) - 1;
+      this.moveCursor(n);
+      this.render();
+      return this.submit();
+    }
+    if (c.toLowerCase() === "y") {
+      this.value = true;
+      return this.submit();
+    }
+    if (c.toLowerCase() === "n") {
+      this.value = false;
+      return this.submit();
+    }
+    return;
+  }
+  render() {
+    if (this.closed) {
+      return;
+    }
+    if (this.firstRender) {
+      this.out.write(import_sisteransi3.cursor.hide);
+    } else {
+      this.out.write(clear(this.outputText, this.out.columns));
+    }
+    super.render();
+    let outputText = [
+      "\n",
+      this.label,
+      " ",
+      this.msg,
+      this.done ? "" : this.hint ? color.dim(` (${this.hint})`) : "",
+      "\n"
+    ];
+    outputText.push(" ".repeat(strip(this.label).length));
+    if (this.done) {
+      outputText.push(" ", color.dim(`${this.choices[this.cursor].label}`));
+    } else {
+      outputText.push(
+        " ",
+        this.choices.map(
+          (choice, i) => i === this.cursor ? `${color.green("\u25CF")} ${choice.label} ` : color.dim(`\u25CB ${choice.label} `)
+        ).join(color.dim(" "))
+      );
+    }
+    this.outputText = outputText.join("");
+    this.out.write(import_sisteransi3.erase.line + import_sisteransi3.cursor.to(0) + this.outputText);
+  }
+};
+
+// prompts-select.ts
+var import_sisteransi4 = require("sisteransi");
+var SelectPrompt = class extends Prompt {
+  choices;
+  label;
+  msg;
+  hint;
+  value;
+  initialValue;
+  search;
+  done;
+  cursor;
+  name = "SelectPrompt";
+  _timeout;
+  // set by render which is called in constructor
+  outputText;
+  constructor(opts) {
+    if (!opts.choices || !Array.isArray(opts.choices) || opts.choices.length < 1) {
+      throw new Error("SelectPrompt must contain choices");
+    }
+    super(opts);
+    this.label = opts.label;
+    this.hint = opts.hint;
+    this.msg = opts.message;
+    this.value = opts.initial;
+    this.choices = opts.choices;
+    this.initialValue = opts.initial || this.choices[0].value;
+    this.cursor = this.choices.findIndex((c) => c.value === this.initialValue);
+    this.search = null;
+    this.render();
+  }
+  get type() {
+    return "select";
+  }
+  exit() {
+    this.abort();
+  }
+  abort() {
+    this.done = this.aborted = true;
+    this.cursor = this.choices.findIndex((c) => c.value === this.initialValue);
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  submit() {
+    this.value = this.value || void 0;
+    this.cursor = this.choices.findIndex((c) => c.value === this.value);
+    this.done = true;
+    this.aborted = false;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  delete() {
+    this.search = null;
+    this.render();
+  }
+  _(c, key) {
+    if (this._timeout) clearTimeout(this._timeout);
+    if (!Number.isNaN(Number.parseInt(c))) {
+      let n2 = Number.parseInt(c) - 1;
+      this.moveCursor(n2);
+      this.render();
+      return this.submit();
+    }
+    this.search = this.search || "";
+    this.search += c.toLowerCase();
+    let choices = !this.search ? this.choices.slice(this.cursor) : this.choices;
+    let n = choices.findIndex(
+      (c2) => c2.label.toLowerCase().includes(this.search)
+    );
+    if (n > -1) {
+      this.moveCursor(n);
+      this.render();
+    }
+    this._timeout = setTimeout(() => {
+      this.search = null;
+    }, 500);
+  }
+  moveCursor(n) {
+    this.cursor = n;
+    this.value = this.choices[n].value;
+    this.fire();
+  }
+  reset() {
+    this.moveCursor(0);
+    this.fire();
+    this.render();
+  }
+  first() {
+    this.moveCursor(0);
+    this.render();
+  }
+  last() {
+    this.moveCursor(this.choices.length - 1);
+    this.render();
+  }
+  up() {
+    if (this.cursor === 0) {
+      this.moveCursor(this.choices.length - 1);
+    } else {
+      this.moveCursor(this.cursor - 1);
+    }
+    this.render();
+  }
+  down() {
+    if (this.cursor === this.choices.length - 1) {
+      this.moveCursor(0);
+    } else {
+      this.moveCursor(this.cursor + 1);
+    }
+    this.render();
+  }
+  highlight(label) {
+    if (!this.search) return label;
+    let n = label.toLowerCase().indexOf(this.search.toLowerCase());
+    if (n === -1) return label;
+    return [
+      label.slice(0, n),
+      color.underline(label.slice(n, n + this.search.length)),
+      label.slice(n + this.search.length)
+    ].join("");
+  }
+  render() {
+    if (this.closed) return;
+    if (this.firstRender) this.out.write(import_sisteransi4.cursor.hide);
+    else this.out.write(clear(this.outputText, this.out.columns));
+    super.render();
+    let outputText = [
+      "\n",
+      this.label,
+      " ",
+      this.msg,
+      this.done ? "" : this.hint ? (this.out.columns < 80 ? "\n" + " ".repeat(8) : "") + color.dim(` (${this.hint})`) : "",
+      "\n"
+    ];
+    let prefix = " ".repeat(strip(this.label).length);
+    if (this.done) {
+      outputText.push(
+        `${prefix} `,
+        color.dim(`${this.choices[this.cursor]?.label}`)
+      );
+    } else {
+      outputText.push(
+        this.choices.map(
+          (choice, i) => i === this.cursor ? `${prefix} ${color.green(
+            shouldUseAscii() ? ">" : "\u25CF"
+          )} ${this.highlight(choice.label)} ${choice.hint ? color.dim(choice.hint) : ""}` : color.dim(
+            `${prefix} ${shouldUseAscii() ? "\u2014" : "\u25CB"} ${choice.label} `
+          )
+        ).join("\n")
+      );
+    }
+    this.outputText = outputText.join("");
+    this.out.write(import_sisteransi4.erase.line + import_sisteransi4.cursor.to(0) + this.outputText);
+  }
+};
+
+// prompts-multi-select.ts
+var import_sisteransi5 = require("sisteransi");
+var MultiSelectPrompt = class extends Prompt {
+  choices;
+  label;
+  msg;
+  hint;
+  value;
+  initialValue;
+  done;
+  cursor;
+  name = "MultiSelectPrompt";
+  // set by render which is called in constructor
+  outputText;
+  constructor(opts) {
+    if (!opts.choices || !Array.isArray(opts.choices) || opts.choices.length < 1) {
+      throw new Error("MultiSelectPrompt must contain choices");
+    }
+    super(opts);
+    this.label = opts.label;
+    this.msg = opts.message;
+    this.hint = opts.hint;
+    this.value = [];
+    this.choices = opts.choices.map((choice) => ({ ...choice, selected: false })) || [];
+    this.initialValue = opts.initial || this.choices[0].value;
+    this.cursor = this.choices.findIndex((c) => c.value === this.initialValue);
+    this.render();
+  }
+  get type() {
+    return "multiselect";
+  }
+  exit() {
+    this.abort();
+  }
+  abort() {
+    this.done = this.aborted = true;
+    this.cursor = this.choices.findIndex((c) => c.value === this.initialValue);
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  submit() {
+    return this.toggle();
+  }
+  finish() {
+    this.value = this.value;
+    this.done = true;
+    this.aborted = false;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  moveCursor(n) {
+    this.cursor = n;
+    this.fire();
+  }
+  toggle() {
+    let choice = this.choices[this.cursor];
+    if (!choice) return;
+    choice.selected = !choice.selected;
+    this.render();
+  }
+  _(c, key) {
+    if (c === " ") {
+      return this.toggle();
+    }
+    if (c.toLowerCase() === "c") {
+      return this.finish();
+    }
+    return;
+  }
+  reset() {
+    this.moveCursor(0);
+    this.fire();
+    this.render();
+  }
+  first() {
+    this.moveCursor(0);
+    this.render();
+  }
+  last() {
+    this.moveCursor(this.choices.length - 1);
+    this.render();
+  }
+  up() {
+    if (this.cursor === 0) {
+      this.moveCursor(this.choices.length - 1);
+    } else {
+      this.moveCursor(this.cursor - 1);
+    }
+    this.render();
+  }
+  down() {
+    if (this.cursor === this.choices.length - 1) {
+      this.moveCursor(0);
+    } else {
+      this.moveCursor(this.cursor + 1);
+    }
+    this.render();
+  }
+  render() {
+    if (this.closed) return;
+    if (this.firstRender) {
+      this.out.write(import_sisteransi5.cursor.hide);
+    } else {
+      this.out.write(clear(this.outputText, this.out.columns));
+    }
+    super.render();
+    let outputText = ["\n", this.label, " ", this.msg, "\n"];
+    let prefix = " ".repeat(strip(this.label).length);
+    if (this.done) {
+      outputText.push(
+        this.choices.map(
+          (choice) => choice.selected ? `${prefix} ${color.dim(`${choice.label}`)}
+` : ""
+        ).join("").trimEnd()
+      );
+    } else {
+      outputText.push(
+        this.choices.map(
+          (choice, i) => i === this.cursor ? `${prefix.slice(0, -2)}${color.cyanBright("\u25B6")}  ${choice.selected ? color.green("\u25A0") : color.whiteBright("\u25A1")} ${color.underline(choice.label)} ${choice.hint ? color.dim(choice.hint) : ""}` : color[choice.selected ? "reset" : "dim"](
+            `${prefix} ${choice.selected ? color.green("\u25A0") : "\u25A1"} ${choice.label} `
+          )
+        ).join("\n")
+      );
+      outputText.push(
+        `
+
+${prefix} Press ${color.inverse(" C ")} to continue`
+      );
+    }
+    this.outputText = outputText.join("");
+    this.out.write(import_sisteransi5.erase.line + import_sisteransi5.cursor.to(0) + this.outputText);
+  }
+};
+
+// prompts-text.ts
+var import_sisteransi6 = require("sisteransi");
+var TextPrompt = class extends Prompt {
+  transform;
+  label;
+  scale;
+  msg;
+  initial;
+  hint;
+  validator;
+  errorMsg;
+  cursor;
+  cursorOffset;
+  clear;
+  done;
+  error;
+  red;
+  outputError;
+  name = "TextPrompt";
+  // set by value setter, value is set in constructor
+  _value;
+  placeholder;
+  rendered;
+  // set by render which is called in constructor
+  outputText;
+  constructor(opts) {
+    super(opts);
+    this.transform = { render: (v) => v, scale: 1 };
+    this.label = opts.label;
+    this.scale = this.transform.scale;
+    this.msg = opts.message;
+    this.hint = opts.hint;
+    this.initial = opts.initial || "";
+    this.validator = opts.validate || (() => true);
+    this.value = "";
+    this.errorMsg = opts.error || "Please enter a valid value";
+    this.cursor = Number(!!this.initial);
+    this.cursorOffset = 0;
+    this.clear = clear(``, this.out.columns);
+    this.render();
+  }
+  get type() {
+    return "text";
+  }
+  set value(v) {
+    if (!v && this.initial) {
+      this.placeholder = true;
+      this.rendered = color.dim(this.initial);
+    } else {
+      this.placeholder = false;
+      this.rendered = this.transform.render(v);
+    }
+    this._value = v;
+    this.fire();
+  }
+  get value() {
+    return this._value;
+  }
+  reset() {
+    this.value = "";
+    this.cursor = Number(!!this.initial);
+    this.cursorOffset = 0;
+    this.fire();
+    this.render();
+  }
+  exit() {
+    this.abort();
+  }
+  abort() {
+    this.value = this.value || this.initial;
+    this.done = this.aborted = true;
+    this.error = false;
+    this.red = false;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  async validate() {
+    let valid2 = await this.validator(this.value);
+    if (typeof valid2 === `string`) {
+      this.errorMsg = valid2;
+      valid2 = false;
+    }
+    this.error = !valid2;
+  }
+  async submit() {
+    this.value = this.value || this.initial;
+    this.cursorOffset = 0;
+    this.cursor = this.rendered.length;
+    await this.validate();
+    if (this.error) {
+      this.red = true;
+      this.fire();
+      this.render();
+      return;
+    }
+    this.done = true;
+    this.aborted = false;
+    this.fire();
+    this.render();
+    this.out.write("\n");
+    this.close();
+  }
+  next() {
+    if (!this.placeholder) return this.bell();
+    this.value = this.initial;
+    this.cursor = this.rendered.length;
+    this.fire();
+    this.render();
+  }
+  moveCursor(n) {
+    if (this.placeholder) return;
+    this.cursor = this.cursor + n;
+    this.cursorOffset += n;
+  }
+  _(c, key) {
+    let s1 = this.value.slice(0, this.cursor);
+    let s2 = this.value.slice(this.cursor);
+    this.value = `${s1}${c}${s2}`;
+    this.red = false;
+    this.cursor = this.placeholder ? 0 : s1.length + 1;
+    this.render();
+  }
+  delete() {
+    if (this.isCursorAtStart()) return this.bell();
+    let s1 = this.value.slice(0, this.cursor - 1);
+    let s2 = this.value.slice(this.cursor);
+    this.value = `${s1}${s2}`;
+    this.red = false;
+    this.outputError = "";
+    this.error = false;
+    if (this.isCursorAtStart()) {
+      this.cursorOffset = 0;
+    } else {
+      this.cursorOffset++;
+      this.moveCursor(-1);
+    }
+    this.render();
+  }
+  deleteForward() {
+    if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+      return this.bell();
+    let s1 = this.value.slice(0, this.cursor);
+    let s2 = this.value.slice(this.cursor + 1);
+    this.value = `${s1}${s2}`;
+    this.red = false;
+    this.outputError = "";
+    this.error = false;
+    if (this.isCursorAtEnd()) {
+      this.cursorOffset = 0;
+    } else {
+      this.cursorOffset++;
+    }
+    this.render();
+  }
+  first() {
+    this.cursor = 0;
+    this.render();
+  }
+  last() {
+    this.cursor = this.value.length;
+    this.render();
+  }
+  left() {
+    if (this.cursor <= 0 || this.placeholder) return this.bell();
+    this.moveCursor(-1);
+    this.render();
+  }
+  right() {
+    if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+      return this.bell();
+    this.moveCursor(1);
+    this.render();
+  }
+  isCursorAtStart() {
+    return this.cursor === 0 || this.placeholder && this.cursor === 1;
+  }
+  isCursorAtEnd() {
+    return this.cursor === this.rendered.length || this.placeholder && this.cursor === this.rendered.length + 1;
+  }
+  render() {
+    if (this.closed) return;
+    if (!this.firstRender) {
+      if (this.outputError)
+        this.out.write(
+          import_sisteransi6.cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns)
+        );
+      this.out.write(clear(this.outputText, this.out.columns));
+    }
+    super.render();
+    this.outputError = "";
+    let prefix = " ".repeat(strip(this.label).length);
+    this.outputText = [
+      "\n",
+      this.label,
+      " ",
+      this.msg,
+      this.done ? "" : this.hint ? (this.out.columns < 80 ? "\n" + " ".repeat(8) : "") + color.dim(` (${this.hint})`) : "",
+      "\n" + prefix,
+      " ",
+      this.done ? color.dim(this.rendered) : this.rendered
+    ].join("");
+    if (this.error) {
+      this.outputError += `  ${color.redBright(
+        (shouldUseAscii() ? "> " : "\u25B6 ") + this.errorMsg
+      )}`;
+    }
+    this.out.write(
+      import_sisteransi6.erase.line + import_sisteransi6.cursor.to(0) + this.outputText + import_sisteransi6.cursor.save + this.outputError + import_sisteransi6.cursor.restore + import_sisteransi6.cursor.move(
+        this.placeholder ? (this.rendered.length - 9) * -1 : this.cursorOffset,
+        0
+      )
+    );
+  }
+};
+
+// prompt.ts
+var prompts = {
+  text: (args) => toPrompt(TextPrompt, args),
+  confirm: (args) => toPrompt(ConfirmPrompt, args),
+  select: (args) => toPrompt(SelectPrompt, args),
+  multiselect: (args) => toPrompt(MultiSelectPrompt, args)
+};
+async function prompt(questions, opts = {}) {
+  let {
+    onSubmit = identity,
+    onCancel = () => import_node_process3.default.exit(0),
+    stdin = import_node_process3.default.stdin,
+    stdout = import_node_process3.default.stdout
+  } = opts;
+  let answers = {};
+  let questionsArray = Array.isArray(questions) ? questions : [questions];
+  let answer;
+  let quit;
+  let name;
+  let type;
+  for (let question of questionsArray) {
+    ({ name, type } = question);
+    try {
+      answer = await prompts[type](Object.assign({ stdin, stdout }, question));
+      answers[name] = answer;
+      quit = await onSubmit(question, answer, answers);
+    } catch (err) {
+      quit = !await onCancel(question, answers);
+    }
+    if (quit) {
+      return answers;
+    }
+  }
+  return answers;
+}
+function toPrompt(el, args, opts = {}) {
+  if (el !== TextPrompt && el !== ConfirmPrompt && el !== SelectPrompt && el !== MultiSelectPrompt) {
+    throw new Error(`Invalid prompt type: ${el.name}`);
+  }
+  return new Promise((res, rej) => {
+    let p = new el(
+      args,
+      // @ts-expect-error
+      opts
+    );
+    let onAbort = args.onAbort || opts.onAbort || identity;
+    let onSubmit = args.onSubmit || opts.onSubmit || identity;
+    let onExit = args.onExit || opts.onExit || identity;
+    p.on("state", args.onState || identity);
+    p.on("submit", (x) => res(onSubmit(x)));
+    p.on("exit", (x) => res(onExit(x)));
+    p.on("abort", (x) => rej(onAbort(x)));
+  });
+}
+
+// loading-indicator.ts
+var import_node_process4 = __toESM(require("process"));
+var import_node_readline2 = __toESM(require("readline"));
+var import_sisteransi7 = require("sisteransi");
+var GRADIENT_COLORS = [
+  "#ffffff",
+  "#dadada",
+  "#dadada",
+  "#a8deaa",
+  "#a8deaa",
+  "#a8deaa",
+  "#d0f0bd",
+  "#d0f0bd",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#ffffed",
+  "#f7f8ca",
+  "#f7f8ca",
+  "#eae6ba",
+  "#eae6ba",
+  "#eae6ba",
+  "#dadada",
+  "#dadada",
+  "#ffffff"
+];
+var MAX_FRAMES = 8;
+var LEADING_FRAMES = Array.from(
+  { length: MAX_FRAMES * 2 },
+  () => GRADIENT_COLORS[0]
+);
+var TRAILING_FRAMES = Array.from(
+  { length: MAX_FRAMES * 2 },
+  () => GRADIENT_COLORS[GRADIENT_COLORS.length - 1]
+);
+var INDICATOR_FULL_FRAMES = [
+  ...LEADING_FRAMES,
+  ...GRADIENT_COLORS,
+  ...TRAILING_FRAMES,
+  ...reverse(GRADIENT_COLORS)
+];
+var INDICATOR_GRADIENT = reverse(
+  INDICATOR_FULL_FRAMES.map((_, i) => loadingIndicatorFrame(i))
+);
+async function renderLoadingIndicator({
+  start,
+  end,
+  while: update = () => sleep(100),
+  noMotion = false,
+  stdin = import_node_process4.default.stdin,
+  stdout = import_node_process4.default.stdout
+}) {
+  let act = update();
+  let tooSlow = /* @__PURE__ */ Object.create(null);
+  let result = await Promise.race([sleep(500).then(() => tooSlow), act]);
+  if (result === tooSlow) {
+    let loading = await gradient(color.green(start), {
+      stdin,
+      stdout,
+      noMotion
+    });
+    await act;
+    loading.stop();
+  }
+  stdout.write(`${" ".repeat(5)} ${color.green("\u2714")}  ${color.green(end)}
+`);
+}
+function loadingIndicatorFrame(offset = 0) {
+  let frames = INDICATOR_FULL_FRAMES.slice(offset, offset + (MAX_FRAMES - 2));
+  if (frames.length < MAX_FRAMES - 2) {
+    let filled = new Array(MAX_FRAMES - frames.length - 2).fill(
+      GRADIENT_COLORS[0]
+    );
+    frames.push(...filled);
+  }
+  return frames;
+}
+function getGradientAnimationFrames() {
+  return INDICATOR_GRADIENT.map(
+    (colors) => " " + colors.map((g, i) => color.hex(g)("\u2588")).join("")
+  );
+}
+async function gradient(text, { stdin = import_node_process4.default.stdin, stdout = import_node_process4.default.stdout, noMotion = false } = {}) {
+  let { createLogUpdate } = await import("log-update");
+  let logUpdate = createLogUpdate(stdout);
+  let frameIndex = 0;
+  let frames = getGradientAnimationFrames();
+  let interval;
+  let rl = import_node_readline2.default.createInterface({ input: stdin, escapeCodeTimeout: 50 });
+  import_node_readline2.default.emitKeypressEvents(stdin, rl);
+  if (stdin.isTTY) stdin.setRawMode(true);
+  function keypress(char) {
+    if (char === "") {
+      loadingIndicator2.stop();
+      import_node_process4.default.exit(0);
+    }
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdout.write(import_sisteransi7.cursor.hide + import_sisteransi7.erase.lines(1));
+  }
+  let done = false;
+  let loadingIndicator2 = {
+    start() {
+      stdout.write(import_sisteransi7.cursor.hide);
+      stdin.on("keypress", keypress);
+      logUpdate(`${frames[0]}  ${text}`);
+      async function loop() {
+        if (done) return;
+        if (frameIndex < frames.length - 1) {
+          frameIndex++;
+        } else {
+          frameIndex = 0;
+        }
+        let frame = frames[frameIndex];
+        logUpdate(
+          `${(noMotion ? getMotionlessFrame(frameIndex) : color.supportsColor ? frame : getColorlessFrame(frameIndex)).padEnd(MAX_FRAMES - 1, " ")}  ${text}`
+        );
+        if (!done) await sleep(20);
+        loop();
+      }
+      loop();
+    },
+    stop() {
+      done = true;
+      stdin.removeListener("keypress", keypress);
+      clearInterval(interval);
+      logUpdate.clear();
+      rl.close();
+    }
+  };
+  loadingIndicator2.start();
+  return loadingIndicator2;
+}
+function getColorlessFrame(frameIndex) {
+  return (frameIndex % 3 === 0 ? ".. .. " : frameIndex % 3 === 1 ? " .. .." : ". .. .").padEnd(MAX_FRAMES - 1 + 20, " ");
+}
+function getMotionlessFrame(frameIndex) {
+  return " ".repeat(MAX_FRAMES - 1);
+}
+
+// copy-template.ts
+var import_node_process5 = __toESM(require("process"));
+var import_node_url = __toESM(require("url"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_stream = __toESM(require("stream"));
+var import_node_util = require("util");
+var import_web_fetch = require("@remix-run/web-fetch");
+var import_gunzip_maybe = __toESM(require("gunzip-maybe"));
+var import_tar_fs = __toESM(require("tar-fs"));
+var import_proxy_agent = require("proxy-agent");
+var defaultAgent = new import_proxy_agent.ProxyAgent();
+var httpsAgent = new import_proxy_agent.ProxyAgent();
+httpsAgent.protocol = "https:";
+function agent(url2) {
+  return new URL(url2).protocol === "https:" ? httpsAgent : defaultAgent;
+}
+async function copyTemplate(template, destPath, options) {
+  let { log: log2 = () => {
+  } } = options;
+  try {
+    if (isLocalFilePath(template)) {
+      log2(`Using the template from local file at "${template}"`);
+      let filepath = template.startsWith("file://") ? import_node_url.default.fileURLToPath(template) : template;
+      let isLocalDir = await copyTemplateFromLocalFilePath(filepath, destPath);
+      return isLocalDir ? { localTemplateDirectory: filepath } : void 0;
+    }
+    if (isGithubRepoShorthand(template)) {
+      log2(`Using the template from the "${template}" repo`);
+      await copyTemplateFromGithubRepoShorthand(template, destPath, options);
+      return;
+    }
+    if (isValidGithubRepoUrl(template)) {
+      log2(`Using the template from "${template}"`);
+      await copyTemplateFromGithubRepoUrl(template, destPath, options);
+      return;
+    }
+    if (isUrl(template)) {
+      log2(`Using the template from "${template}"`);
+      await copyTemplateFromGenericUrl(template, destPath, options);
+      return;
+    }
+    throw new CopyTemplateError(
+      `"${color.bold(template)}" is an invalid template. Run ${color.bold(
+        "create-react-router --help"
+      )} to see supported template formats.`
+    );
+  } catch (error2) {
+    await options.onError(error2);
+  }
+}
+function isLocalFilePath(input) {
+  try {
+    return input.startsWith("file://") || import_node_fs2.default.existsSync(
+      import_node_path2.default.isAbsolute(input) ? input : import_node_path2.default.resolve(import_node_process5.default.cwd(), input)
+    );
+  } catch (_) {
+    return false;
+  }
+}
+async function copyTemplateFromRemoteTarball(url2, destPath, options) {
+  return await downloadAndExtractTarball(destPath, url2, options);
+}
+async function copyTemplateFromGithubRepoShorthand(repoShorthand, destPath, options) {
+  let [owner, name, ...path4] = repoShorthand.split("/");
+  let filePath = path4.length ? path4.join("/") : null;
+  await downloadAndExtractRepoTarball(
+    { owner, name, filePath },
+    destPath,
+    options
+  );
+}
+async function copyTemplateFromGithubRepoUrl(repoUrl, destPath, options) {
+  await downloadAndExtractRepoTarball(getRepoInfo(repoUrl), destPath, options);
+}
+async function copyTemplateFromGenericUrl(url2, destPath, options) {
+  await copyTemplateFromRemoteTarball(url2, destPath, options);
+}
+async function copyTemplateFromLocalFilePath(filePath, destPath) {
+  if (filePath.endsWith(".tar.gz") || filePath.endsWith(".tgz")) {
+    await extractLocalTarball(filePath, destPath);
+    return false;
+  }
+  if (import_node_fs2.default.statSync(filePath).isDirectory()) {
+    return true;
+  }
+  throw new CopyTemplateError(
+    "The provided template is not a valid local directory or tarball."
+  );
+}
+var pipeline = (0, import_node_util.promisify)(import_node_stream.default.pipeline);
+async function extractLocalTarball(tarballPath, destPath) {
+  try {
+    await pipeline(
+      import_node_fs2.default.createReadStream(tarballPath),
+      (0, import_gunzip_maybe.default)(),
+      import_tar_fs.default.extract(destPath, { strip: 1 })
+    );
+  } catch (error2) {
+    throw new CopyTemplateError(
+      `There was a problem extracting the file from the provided template.  Template filepath: \`${tarballPath}\`  Destination directory: \`${destPath}\`  ${error2}`
+    );
+  }
+}
+async function downloadAndExtractRepoTarball(repo, destPath, options) {
+  if (repo.branch && repo.filePath) {
+    let tarballURL = `https://codeload.github.com/${repo.owner}/${repo.name}/tar.gz/${repo.branch}`;
+    return await downloadAndExtractTarball(destPath, tarballURL, {
+      ...options,
+      filePath: repo.filePath
+    });
+  }
+  let url2 = `https://api.github.com/repos/${repo.owner}/${repo.name}/tarball`;
+  if (repo.branch) {
+    url2 += `/${repo.branch}`;
+  }
+  return await downloadAndExtractTarball(destPath, url2, {
+    ...options,
+    filePath: repo.filePath ?? null
+  });
+}
+async function downloadAndExtractTarball(downloadPath, tarballUrl, { token, filePath }) {
+  let resourceUrl = tarballUrl;
+  let headers = {};
+  let isGithubUrl = new URL(tarballUrl).host.endsWith("github.com");
+  if (token && isGithubUrl) {
+    headers.Authorization = `token ${token}`;
+  }
+  if (isGithubReleaseAssetUrl(tarballUrl)) {
+    let info2 = getGithubReleaseAssetInfo(tarballUrl);
+    headers.Accept = "application/vnd.github.v3+json";
+    let releaseUrl = info2.tag === "latest" ? `https://api.github.com/repos/${info2.owner}/${info2.name}/releases/latest` : `https://api.github.com/repos/${info2.owner}/${info2.name}/releases/tags/${info2.tag}`;
+    let response2 = await (0, import_web_fetch.fetch)(releaseUrl, {
+      agent: agent("https://api.github.com"),
+      headers
+    });
+    if (response2.status !== 200) {
+      throw new CopyTemplateError(
+        `There was a problem fetching the file from GitHub. The request responded with a ${response2.status} status. Please try again later.`
+      );
+    }
+    let body = await response2.json();
+    if (!body || typeof body !== "object" || !body.assets || !Array.isArray(body.assets)) {
+      throw new CopyTemplateError(
+        "There was a problem fetching the file from GitHub. No asset was found at that url. Please try again later."
+      );
+    }
+    let assetId = body.assets.find((asset) => {
+      return info2.tag === "latest" ? asset?.browser_download_url?.includes(info2.asset) : asset?.browser_download_url === tarballUrl;
+    })?.id;
+    if (assetId == null) {
+      throw new CopyTemplateError(
+        "There was a problem fetching the file from GitHub. No asset was found at that url. Please try again later."
+      );
+    }
+    resourceUrl = `https://api.github.com/repos/${info2.owner}/${info2.name}/releases/assets/${assetId}`;
+    headers.Accept = "application/octet-stream";
+  }
+  let response = await (0, import_web_fetch.fetch)(resourceUrl, {
+    agent: agent(resourceUrl),
+    headers
+  });
+  if (!response.body || response.status !== 200) {
+    if (token) {
+      throw new CopyTemplateError(
+        `There was a problem fetching the file${isGithubUrl ? " from GitHub" : ""}. The request responded with a ${response.status} status. Perhaps your \`--token\`is expired or invalid.`
+      );
+    }
+    throw new CopyTemplateError(
+      `There was a problem fetching the file${isGithubUrl ? " from GitHub" : ""}. The request responded with a ${response.status} status. Please try again later.`
+    );
+  }
+  if (filePath) {
+    filePath = filePath.split(import_node_path2.default.sep).join(import_node_path2.default.posix.sep);
+  }
+  let filePathHasFiles = false;
+  try {
+    let input = new import_node_stream.default.PassThrough();
+    writeReadableStreamToWritable(response.body, input);
+    await pipeline(
+      input,
+      (0, import_gunzip_maybe.default)(),
+      import_tar_fs.default.extract(downloadPath, {
+        map(header) {
+          let originalDirName = header.name.split("/")[0];
+          header.name = header.name.replace(`${originalDirName}/`, "");
+          if (filePath) {
+            if (filePath.endsWith(import_node_path2.default.posix.sep) && header.name.startsWith(filePath) || !filePath.endsWith(import_node_path2.default.posix.sep) && header.name.startsWith(filePath + import_node_path2.default.posix.sep)) {
+              filePathHasFiles = true;
+              header.name = header.name.replace(filePath, "");
+            } else {
+              header.name = "__IGNORE__";
+            }
+          }
+          return header;
+        },
+        ignore(_filename, header) {
+          if (!header) {
+            throw Error("Header is undefined");
+          }
+          return header.name === "__IGNORE__";
+        }
+      })
+    );
+  } catch (_) {
+    throw new CopyTemplateError(
+      `There was a problem extracting the file from the provided template.  Template URL: \`${tarballUrl}\`  Destination directory: \`${downloadPath}\``
+    );
+  }
+  if (filePath && !filePathHasFiles) {
+    throw new CopyTemplateError(
+      `The path "${filePath}" was not found in this ${isGithubUrl ? "GitHub repo." : "tarball."}`
+    );
+  }
+}
+async function writeReadableStreamToWritable(stream2, writable) {
+  let reader = stream2.getReader();
+  let flushable = writable;
+  try {
+    while (true) {
+      let { done, value } = await reader.read();
+      if (done) {
+        writable.end();
+        break;
+      }
+      writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+    }
+  } catch (error2) {
+    writable.destroy(error2);
+    throw error2;
+  }
+}
+function isValidGithubRepoUrl(input) {
+  if (!isUrl(input)) {
+    return false;
+  }
+  try {
+    let url2 = new URL(input);
+    let pathSegments = url2.pathname.slice(1).split("/");
+    return url2.protocol === "https:" && url2.hostname === "github.com" && // The pathname must have at least 2 segments. If it has more than 2, the
+    // third must be "tree" and it must have at least 4 segments.
+    // https://github.com/:owner/:repo
+    // https://github.com/:owner/:repo/tree/:ref
+    pathSegments.length >= 2 && (pathSegments.length > 2 ? pathSegments[2] === "tree" && pathSegments.length >= 4 : true);
+  } catch (_) {
+    return false;
+  }
+}
+function isGithubRepoShorthand(value) {
+  if (isUrl(value)) {
+    return false;
+  }
+  return /^[\w-]+\/[\w-.]+(\/[\w-.]+)*$/.test(value);
+}
+function isGithubReleaseAssetUrl(url2) {
+  return url2.startsWith("https://github.com") && (url2.includes("/releases/download/") || url2.includes("/releases/latest/download/"));
+}
+function getGithubReleaseAssetInfo(browserUrl) {
+  let url2 = new URL(browserUrl);
+  let [, owner, name, , downloadOrLatest, tag, asset] = url2.pathname.split("/");
+  if (downloadOrLatest === "latest" && tag === "download") {
+    tag = "latest";
+  }
+  return {
+    browserUrl,
+    owner,
+    name,
+    asset,
+    tag
+  };
+}
+function getRepoInfo(validatedGithubUrl) {
+  let url2 = new URL(validatedGithubUrl);
+  let [, owner, name, tree, branch, ...file] = url2.pathname.split("/");
+  let filePath = file.join("/");
+  if (tree === void 0) {
+    return {
+      owner,
+      name,
+      branch: null,
+      filePath: null
+    };
+  }
+  return {
+    owner,
+    name,
+    // If we've validated the GitHub URL and there is a tree, there will also be
+    // a branch
+    branch,
+    filePath: filePath === "" || filePath === "/" ? null : filePath
+  };
+}
+var CopyTemplateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CopyTemplateError";
+  }
+};
+
+// index.ts
+async function createReactRouter(argv2) {
+  let ctx = await getContext(argv2);
+  if (ctx.help) {
+    printHelp(ctx);
+    return;
+  }
+  if (ctx.versionRequested) {
+    log(version);
+    return;
+  }
+  let steps = [
+    introStep,
+    projectNameStep,
+    copyTemplateToTempDirStep,
+    copyTempDirToAppDirStep,
+    gitInitQuestionStep,
+    installDependenciesQuestionStep,
+    installDependenciesStep,
+    gitInitStep,
+    doneStep
+  ];
+  try {
+    for (let step of steps) {
+      await step(ctx);
+    }
+  } catch (err) {
+    if (ctx.debug) {
+      console.error(err);
+    }
+    throw err;
+  }
+}
+async function getContext(argv2) {
+  let flags = (0, import_arg.default)(
+    {
+      "--debug": Boolean,
+      "--react-router-version": String,
+      "-v": "--react-router-version",
+      "--template": String,
+      "--token": String,
+      "--yes": Boolean,
+      "-y": "--yes",
+      "--install": Boolean,
+      "--no-install": Boolean,
+      "--package-manager": String,
+      "--show-install-output": Boolean,
+      "--git-init": Boolean,
+      "--no-git-init": Boolean,
+      "--help": Boolean,
+      "-h": "--help",
+      "--version": Boolean,
+      "--V": "--version",
+      "--no-color": Boolean,
+      "--no-motion": Boolean,
+      "--overwrite": Boolean
+    },
+    { argv: argv2, permissive: true }
+  );
+  let {
+    "--debug": debug2 = false,
+    "--help": help = false,
+    "--react-router-version": selectedReactRouterVersion,
+    "--template": template,
+    "--token": token,
+    "--install": install,
+    "--no-install": noInstall,
+    "--package-manager": pkgManager,
+    "--show-install-output": showInstallOutput = false,
+    "--git-init": git,
+    "--no-git-init": noGit,
+    "--no-motion": noMotion,
+    "--yes": yes,
+    "--version": versionRequested,
+    "--overwrite": overwrite
+  } = flags;
+  let cwd = flags["_"][0];
+  let interactive = isInteractive();
+  let projectName = cwd;
+  if (!interactive) {
+    yes = true;
+  }
+  if (selectedReactRouterVersion) {
+    if (semver.valid(selectedReactRouterVersion)) {
+    } else if (semver.coerce(selectedReactRouterVersion)) {
+      selectedReactRouterVersion = semver.coerce(
+        selectedReactRouterVersion
+      ).version;
+    } else {
+      log(
+        `
+${color.warning(
+          `${selectedReactRouterVersion} is an invalid version specifier. Using React Router v${version}.`
+        )}`
+      );
+      selectedReactRouterVersion = void 0;
+    }
+  }
+  let context = {
+    tempDir: import_node_path3.default.join(
+      await import_node_fs3.default.promises.realpath(import_node_os2.default.tmpdir()),
+      `create-react-router--${Math.random().toString(36).substr(2, 8)}`
+    ),
+    cwd,
+    overwrite,
+    interactive,
+    debug: debug2,
+    git: git ?? (noGit ? false : yes),
+    help,
+    install: install ?? (noInstall ? false : yes),
+    showInstallOutput,
+    noMotion,
+    pkgManager: validatePackageManager(
+      pkgManager ?? // npm, pnpm, Yarn, and Bun set the user agent environment variable that can be used
+      // to determine which package manager ran the command.
+      (import_node_process6.default.env.npm_config_user_agent ?? "npm").split("/")[0]
+    ),
+    projectName,
+    prompt,
+    reactRouterVersion: selectedReactRouterVersion || version,
+    template,
+    token,
+    versionRequested
+  };
+  return context;
+}
+async function introStep(ctx) {
+  log(
+    `
+${" ".repeat(9)}${color.green(
+      color.bold("create-react-router")
+    )} ${color.bold(`v${ctx.reactRouterVersion}`)}`
+  );
+  if (!ctx.interactive) {
+    log("");
+    info("Shell is not interactive.", [
+      `Using default options. This is equivalent to running with the `,
+      color.reset("--yes"),
+      ` flag.`
+    ]);
+  }
+}
+async function projectNameStep(ctx) {
+  if (!ctx.interactive && !ctx.cwd) {
+    error("Oh no!", "No project directory provided");
+    throw new Error("No project directory provided");
+  }
+  if (ctx.cwd) {
+    await sleep(100);
+    info("Directory:", [
+      "Using ",
+      color.reset(ctx.cwd),
+      " as project directory"
+    ]);
+  }
+  if (!ctx.cwd) {
+    let { name: name2 } = await ctx.prompt({
+      name: "name",
+      type: "text",
+      label: title("dir"),
+      message: "Where should we create your new project?",
+      initial: "./my-react-router-app"
+    });
+    ctx.cwd = name2;
+    ctx.projectName = toValidProjectName(name2);
+    return;
+  }
+  let name = ctx.cwd;
+  if (name === "." || name === "./") {
+    let parts = import_node_process6.default.cwd().split(import_node_path3.default.sep);
+    name = parts[parts.length - 1];
+  } else if (name.startsWith("./") || name.startsWith("../")) {
+    let parts = name.split("/");
+    name = parts[parts.length - 1];
+  }
+  ctx.projectName = toValidProjectName(name);
+}
+async function copyTemplateToTempDirStep(ctx) {
+  if (ctx.template) {
+    log("");
+    info("Template:", ["Using ", color.reset(ctx.template), "..."]);
+  } else {
+    log("");
+    info("Using basic template");
+  }
+  let template = ctx.template ?? // TODO: (v7) Update to main branch
+  "https://github.com/remix-run/react-router/tree/dev/templates/basic";
+  await loadingIndicator({
+    start: "Template copying...",
+    end: "Template copied",
+    while: async () => {
+      await ensureDirectory(ctx.tempDir);
+      if (ctx.debug) {
+        debug(`Extracting to: ${ctx.tempDir}`);
+      }
+      let result = await copyTemplate(template, ctx.tempDir, {
+        debug: ctx.debug,
+        token: ctx.token,
+        async onError(err) {
+          error(
+            "Oh no!",
+            err instanceof CopyTemplateError ? err.message : "Something went wrong. Run `create-react-router --debug` to see more info.\n\nOpen an issue to report the problem at https://github.com/remix-run/react-router/issues/new"
+          );
+          throw err;
+        },
+        async log(message) {
+          if (ctx.debug) {
+            debug(message);
+            await sleep(500);
+          }
+        }
+      });
+      if (result?.localTemplateDirectory) {
+        ctx.tempDir = import_node_path3.default.resolve(result.localTemplateDirectory);
+      }
+    },
+    ctx
+  });
+}
+async function copyTempDirToAppDirStep(ctx) {
+  await ensureDirectory(ctx.cwd);
+  let files1 = await getDirectoryFilesRecursive(ctx.tempDir);
+  let files2 = await getDirectoryFilesRecursive(ctx.cwd);
+  let collisions = files1.filter((f) => files2.includes(f)).sort((a, b) => a.localeCompare(b));
+  if (collisions.length > 0) {
+    let getFileList = (prefix) => {
+      let moreFiles = collisions.length - 5;
+      let lines2 = ["", ...collisions.slice(0, 5)];
+      if (moreFiles > 0) {
+        lines2.push(`and ${moreFiles} more...`);
+      }
+      return lines2.join(`
+${prefix}`);
+    };
+    if (ctx.overwrite) {
+      info(
+        "Overwrite:",
+        `overwriting files due to \`--overwrite\`:${getFileList("           ")}`
+      );
+    } else if (!ctx.interactive) {
+      error(
+        "Oh no!",
+        `Destination directory contains files that would be overwritten
+         and no \`--overwrite\` flag was included in a non-interactive
+         environment. The following files would be overwritten:` + getFileList("           ")
+      );
+      throw new Error(
+        "File collisions detected in a non-interactive environment"
+      );
+    } else {
+      if (ctx.debug) {
+        debug(`Colliding files:${getFileList("          ")}`);
+      }
+      let { overwrite } = await ctx.prompt({
+        name: "overwrite",
+        type: "confirm",
+        label: title("overwrite"),
+        message: `Your project directory contains files that will be overwritten by
+             this template (you can force with \`--overwrite\`)
+
+             Files that would be overwritten:${getFileList("               ")}
+
+             Do you wish to continue?
+             `,
+        initial: false
+      });
+      if (!overwrite) {
+        throw new Error("Exiting to avoid overwriting files");
+      }
+    }
+  }
+  await import_fs_extra.default.copy(ctx.tempDir, ctx.cwd, {
+    filter(src, dest) {
+      let file = stripDirectoryFromPath(ctx.tempDir, src);
+      let isIgnored = IGNORED_TEMPLATE_DIRECTORIES.includes(file);
+      if (isIgnored) {
+        if (ctx.debug) {
+          debug(`Skipping copy of ${file} directory from template`);
+        }
+        return false;
+      }
+      return true;
+    }
+  });
+  await updatePackageJSON(ctx);
+}
+async function installDependenciesQuestionStep(ctx) {
+  if (ctx.install === void 0) {
+    let { deps = true } = await ctx.prompt({
+      name: "deps",
+      type: "confirm",
+      label: title("deps"),
+      message: `Install dependencies with ${ctx.pkgManager}?`,
+      hint: "recommended",
+      initial: true
+    });
+    ctx.install = deps;
+  }
+}
+async function installDependenciesStep(ctx) {
+  let { install, pkgManager, showInstallOutput, cwd } = ctx;
+  if (!install) {
+    await sleep(100);
+    info("Skipping install step.", [
+      "Remember to install dependencies after setup with ",
+      color.reset(`${pkgManager} install`),
+      "."
+    ]);
+    return;
+  }
+  function runInstall() {
+    return installDependencies({
+      cwd,
+      pkgManager,
+      showInstallOutput
+    });
+  }
+  if (showInstallOutput) {
+    log("");
+    info(`Install`, `Dependencies installing with ${pkgManager}...`);
+    log("");
+    await runInstall();
+    log("");
+    return;
+  }
+  log("");
+  await loadingIndicator({
+    start: `Dependencies installing with ${pkgManager}...`,
+    end: "Dependencies installed",
+    while: runInstall,
+    ctx
+  });
+}
+async function gitInitQuestionStep(ctx) {
+  if (import_node_fs3.default.existsSync(import_node_path3.default.join(ctx.cwd, ".git"))) {
+    info("Nice!", `Git has already been initialized`);
+    return;
+  }
+  let git = ctx.git;
+  if (ctx.git === void 0) {
+    ({ git } = await ctx.prompt({
+      name: "git",
+      type: "confirm",
+      label: title("git"),
+      message: `Initialize a new git repository?`,
+      hint: "recommended",
+      initial: true
+    }));
+  }
+  ctx.git = git ?? false;
+}
+async function gitInitStep(ctx) {
+  if (!ctx.git) {
+    return;
+  }
+  if (import_node_fs3.default.existsSync(import_node_path3.default.join(ctx.cwd, ".git"))) {
+    log("");
+    info("Nice!", `Git has already been initialized`);
+    return;
+  }
+  log("");
+  await loadingIndicator({
+    start: "Git initializing...",
+    end: "Git initialized",
+    while: async () => {
+      let options = { cwd: ctx.cwd, stdio: "ignore" };
+      let commitMsg = "Initial commit from create-react-router";
+      try {
+        await (0, import_execa.default)("git", ["init"], options);
+        await (0, import_execa.default)("git", ["add", "."], options);
+        await (0, import_execa.default)("git", ["commit", "-m", commitMsg], options);
+      } catch (err) {
+        error("Oh no!", "Failed to initialize git.");
+        throw err;
+      }
+    },
+    ctx
+  });
+}
+async function doneStep(ctx) {
+  let projectDir = import_node_path3.default.relative(import_node_process6.default.cwd(), ctx.cwd);
+  let max = import_node_process6.default.stdout.columns;
+  let prefix = max < 80 ? " " : " ".repeat(9);
+  await sleep(200);
+  log(`
+ ${color.bgWhite(color.black(" done "))}  That's it!`);
+  await sleep(100);
+  if (projectDir !== "") {
+    let enter = [
+      `
+${prefix}Enter your project directory using`,
+      color.cyan(`cd .${import_node_path3.default.sep}${projectDir}`)
+    ];
+    let len = enter[0].length + (0, import_strip_ansi.default)(enter[1]).length;
+    log(enter.join(len > max ? "\n" + prefix : " "));
+  }
+  log(
+    `${prefix}Check out ${color.bold(
+      "README.md"
+    )} for development and deploy instructions.`
+  );
+  await sleep(100);
+  log(
+    `
+${prefix}Join the community at ${color.cyan(`https://rmx.as/discord`)}
+`
+  );
+  await sleep(200);
+}
+var packageManagerExecScript = {
+  npm: "npx",
+  yarn: "yarn",
+  pnpm: "pnpm exec",
+  bun: "bunx"
+};
+function validatePackageManager(pkgManager) {
+  return packageManagerExecScript.hasOwnProperty(pkgManager) ? pkgManager : "npm";
+}
+async function installDependencies({
+  pkgManager,
+  cwd,
+  showInstallOutput
+}) {
+  try {
+    await (0, import_execa.default)(pkgManager, ["install"], {
+      cwd,
+      stdio: showInstallOutput ? "inherit" : "ignore"
+    });
+  } catch (err) {
+    error("Oh no!", "Failed to install dependencies.");
+    throw err;
+  }
+}
+async function updatePackageJSON(ctx) {
+  let packageJSONPath = import_node_path3.default.join(ctx.cwd, "package.json");
+  if (!import_node_fs3.default.existsSync(packageJSONPath)) {
+    let relativePath = import_node_path3.default.relative(import_node_process6.default.cwd(), ctx.cwd);
+    error(
+      "Oh no!",
+      `The provided template must be a React Router project with a \`package.json\` file, but that file does not exist in ${color.bold(relativePath)}.`
+    );
+    throw new Error(`package.json does not exist in ${ctx.cwd}`);
+  }
+  let contents = await import_node_fs3.default.promises.readFile(packageJSONPath, "utf-8");
+  let packageJSON;
+  try {
+    packageJSON = JSON.parse(contents);
+    if (!isValidJsonObject(packageJSON)) {
+      throw Error();
+    }
+  } catch (err) {
+    error(
+      "Oh no!",
+      `The provided template must be a React Router project with a \`package.json\` file, but that file is invalid.`
+    );
+    throw err;
+  }
+  for (let pkgKey of ["dependencies", "devDependencies"]) {
+    let dependencies = packageJSON[pkgKey];
+    if (!dependencies) continue;
+    if (!isValidJsonObject(dependencies)) {
+      error(
+        "Oh no!",
+        `The provided template must be a React Router project with a \`package.json\` file, but its ${pkgKey} value is invalid.`
+      );
+      throw new Error(`package.json ${pkgKey} are invalid`);
+    }
+    for (let dependency in dependencies) {
+      let version2 = dependencies[dependency];
+      if ((dependency.startsWith("@react-router/") || dependency === "react-router" || dependency === "react-router-dom") && version2 === "*") {
+        dependencies[dependency] = semver.prerelease(ctx.reactRouterVersion) ? (
+          // Templates created from prereleases should pin to a specific version
+          ctx.reactRouterVersion
+        ) : "^" + ctx.reactRouterVersion;
+      }
+    }
+  }
+  packageJSON.name = ctx.projectName;
+  import_node_fs3.default.promises.writeFile(
+    packageJSONPath,
+    JSON.stringify((0, import_sort_package_json.default)(packageJSON), null, 2),
+    "utf-8"
+  );
+}
+async function loadingIndicator(args) {
+  let { ctx, ...rest } = args;
+  await renderLoadingIndicator({
+    ...rest,
+    noMotion: args.ctx.noMotion
+  });
+}
+function title(text) {
+  return align(color.bgWhite(` ${color.black(text)} `), "end", 7) + " ";
+}
+function printHelp(ctx) {
+  let output = `
+${title("create-react-router")}
+
+${color.heading("Usage")}:
+
+${color.dim("$")} ${color.greenBright("create-react-router")} ${color.arg("<projectDir>")} ${color.arg("<...options>")}
+
+${color.heading("Values")}:
+
+${color.arg("projectDir")}          ${color.dim(`The React Router project directory`)}
+
+${color.heading("Options")}:
+
+${color.arg("--help, -h")}          ${color.dim(`Print this help message and exit`)}
+${color.arg("--version, -V")}       ${color.dim(`Print the CLI version and exit`)}
+${color.arg("--no-color")}          ${color.dim(`Disable ANSI colors in console output`)}
+${color.arg("--no-motion")}         ${color.dim(`Disable animations in console output`)}
+
+${color.arg("--template <name>")}   ${color.dim(`The project template to use`)}
+${color.arg("--[no-]install")}      ${color.dim(`Whether or not to install dependencies after creation`)}
+${color.arg("--package-manager")}   ${color.dim(`The package manager to use`)}
+${color.arg("--show-install-output")}   ${color.dim(`Whether to show the output of the install process`)}
+${color.arg("--[no-]git-init")}     ${color.dim(`Whether or not to initialize a Git repository`)}
+${color.arg("--yes, -y")}           ${color.dim(`Skip all option prompts and run setup`)}
+${color.arg("--react-router-version, -v")}     ${color.dim(`The version of React Router to use`)}
+
+${color.heading("Creating a new project")}:
+
+React Router projects are created from templates. A template can be:
+
+- a GitHub repo shorthand, :username/:repo or :username/:repo/:directory
+- the URL of a GitHub repo (or directory within it)
+- the URL of a tarball
+- a file path to a directory of files
+- a file path to a tarball
+${[
+    "remix-run/react-router/templates/basic",
+    "remix-run/react-router/examples/basic",
+    ":username/:repo",
+    ":username/:repo/:directory",
+    "https://github.com/:username/:repo",
+    "https://github.com/:username/:repo/tree/:branch",
+    "https://github.com/:username/:repo/tree/:branch/:directory",
+    "https://github.com/:username/:repo/archive/refs/tags/:tag.tar.gz",
+    "https://example.com/template.tar.gz",
+    "./path/to/template",
+    "./path/to/template.tar.gz"
+  ].reduce((str, example) => {
+    return `${str}
+${color.dim("$")} ${color.greenBright("create-react-router")} my-app ${color.arg(`--template ${example}`)}`;
+  }, "")}
+
+To create a new project from a template in a private GitHub repo,
+pass the \`token\` flag with a personal access token with access
+to that repo.
+`;
+  log(output);
+}
+function align(text, dir, len) {
+  let pad = Math.max(len - strip(text).length, 0);
+  switch (dir) {
+    case "start":
+      return text + " ".repeat(pad);
+    case "end":
+      return " ".repeat(pad) + text;
+    case "center":
+      return " ".repeat(Math.floor(pad / 2)) + text + " ".repeat(Math.floor(pad / 2));
+    default:
+      return text;
+  }
+}
+
+// cli.ts
+import_node_process7.default.on("SIGINT", () => import_node_process7.default.exit(0));
+import_node_process7.default.on("SIGTERM", () => import_node_process7.default.exit(0));
+var argv = import_node_process7.default.argv.slice(2).filter((arg2) => arg2 !== "--");
+createReactRouter(argv).then(
+  () => import_node_process7.default.exit(0),
+  () => import_node_process7.default.exit(1)
+);
+/**
+ * Adapted from https://github.com/withastro/cli-kit
+ * @license MIT License Copyright (c) 2022 Nate Moore
+ */