@create-node-app/core 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,3794 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../../node_modules/universalify/index.js"(exports2) {
+    "use strict";
+    exports2.fromCallback = function(fn) {
+      return Object.defineProperty(function() {
+        if (typeof arguments[arguments.length - 1] === "function") fn.apply(this, arguments);
+        else {
+          return new Promise((resolve, reject) => {
+            arguments[arguments.length] = (err, res) => {
+              if (err) return reject(err);
+              resolve(res);
+            };
+            arguments.length++;
+            fn.apply(this, arguments);
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports2.fromPromise = function(fn) {
+      return Object.defineProperty(function() {
+        const cb = arguments[arguments.length - 1];
+        if (typeof cb !== "function") return fn.apply(this, arguments);
+        else fn.apply(this, arguments).then((r) => cb(null, r), cb);
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../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(fs5) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs5);
+      }
+      if (!fs5.lutimes) {
+        patchLutimes(fs5);
+      }
+      fs5.chown = chownFix(fs5.chown);
+      fs5.fchown = chownFix(fs5.fchown);
+      fs5.lchown = chownFix(fs5.lchown);
+      fs5.chmod = chmodFix(fs5.chmod);
+      fs5.fchmod = chmodFix(fs5.fchmod);
+      fs5.lchmod = chmodFix(fs5.lchmod);
+      fs5.chownSync = chownFixSync(fs5.chownSync);
+      fs5.fchownSync = chownFixSync(fs5.fchownSync);
+      fs5.lchownSync = chownFixSync(fs5.lchownSync);
+      fs5.chmodSync = chmodFixSync(fs5.chmodSync);
+      fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
+      fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
+      fs5.stat = statFix(fs5.stat);
+      fs5.fstat = statFix(fs5.fstat);
+      fs5.lstat = statFix(fs5.lstat);
+      fs5.statSync = statFixSync(fs5.statSync);
+      fs5.fstatSync = statFixSync(fs5.fstatSync);
+      fs5.lstatSync = statFixSync(fs5.lstatSync);
+      if (fs5.chmod && !fs5.lchmod) {
+        fs5.lchmod = function(path4, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs5.lchmodSync = function() {
+        };
+      }
+      if (fs5.chown && !fs5.lchown) {
+        fs5.lchown = function(path4, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs5.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs5.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;
+        })(fs5.rename);
+      }
+      fs5.read = typeof fs5.read !== "function" ? fs5.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, _3, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs5.read);
+      fs5.readSync = typeof fs5.readSync !== "function" ? fs5.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs5, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs5.readSync);
+      function patchLchmod(fs6) {
+        fs6.lchmod = function(path4, mode, callback) {
+          fs6.open(
+            path4,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs6.fchmod(fd, mode, function(err2) {
+                fs6.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs6.lchmodSync = function(path4, mode) {
+          var fd = fs6.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs6.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs6.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs6.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs6) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+          fs6.lutimes = function(path4, at, mt, cb) {
+            fs6.open(path4, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs6.futimes(fd, at, mt, function(er2) {
+                fs6.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs6.lutimesSync = function(path4, at, mt) {
+            var fd = fs6.openSync(path4, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs6.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs6.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs6.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs6.futimes) {
+          fs6.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs6.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs5, 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(fs5, 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(fs5, 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(fs5, 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(fs5, target, options, callback) : orig.call(fs5, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs5, target, options) : orig.call(fs5, 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/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    "use strict";
+    var Stream = require("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs5) {
+      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;
+        }
+        fs5.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 = fs5.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../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 copy2 = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy2 = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy2, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy2;
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    "use strict";
+    var fs5 = 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 (!fs5[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs5, queue);
+      fs5.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs5, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs5.close);
+      fs5.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs5, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs5.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug2(fs5[gracefulQueue]);
+          require("assert").equal(fs5[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs5[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs5));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
+      module2.exports = patch(fs5);
+      fs5.__patched = true;
+    }
+    function patch(fs6) {
+      polyfills(fs6);
+      fs6.gracefulify = patch;
+      fs6.createReadStream = createReadStream;
+      fs6.createWriteStream = createWriteStream;
+      var fs$readFile = fs6.readFile;
+      fs6.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 = fs6.writeFile;
+      fs6.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 = fs6.appendFile;
+      if (fs$appendFile)
+        fs6.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 = fs6.copyFile;
+      if (fs$copyFile)
+        fs6.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 = fs6.readdir;
+      fs6.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(fs6);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs6.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs6.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs6, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs6, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs6, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs6, "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 fs6.ReadStream(path4, options);
+      }
+      function createWriteStream(path4, options) {
+        return new fs6.WriteStream(path4, options);
+      }
+      var fs$open = fs6.open;
+      fs6.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 fs6;
+    }
+    function enqueue(elem) {
+      debug2("ENQUEUE", elem[0].name, elem[1]);
+      fs5[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs5[gracefulQueue].length; ++i) {
+        if (fs5[gracefulQueue][i].length > 2) {
+          fs5[gracefulQueue][i][3] = now;
+          fs5[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs5[gracefulQueue].length === 0)
+        return;
+      var elem = fs5[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 {
+          fs5[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs5 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchown",
+      "lchmod",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "readFile",
+      "readdir",
+      "readlink",
+      "realpath",
+      "rename",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs5[key] === "function";
+    });
+    Object.keys(fs5).forEach((key) => {
+      if (key === "promises") {
+        return;
+      }
+      exports2[key] = fs5[key];
+    });
+    api.forEach((method) => {
+      exports2[method] = u(fs5[method]);
+    });
+    exports2.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs5.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs5.exists(filename, resolve);
+      });
+    };
+    exports2.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs5.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs5.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 fs5.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs5.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/win32.js
+var require_win32 = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/win32.js"(exports2, module2) {
+    "use strict";
+    var path4 = require("path");
+    function getRootPath(p) {
+      p = path4.normalize(path4.resolve(p)).split(path4.sep);
+      if (p.length > 0) return p[0];
+      return null;
+    }
+    var INVALID_PATH_CHARS = /[<>:"|?*]/;
+    function invalidWin32Path(p) {
+      const rp = getRootPath(p);
+      p = p.replace(rp, "");
+      return INVALID_PATH_CHARS.test(p);
+    }
+    module2.exports = {
+      getRootPath,
+      invalidWin32Path
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/mkdirs.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/mkdirs.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var invalidWin32Path = require_win32().invalidWin32Path;
+    var o777 = parseInt("0777", 8);
+    function mkdirs(p, opts, callback, made) {
+      if (typeof opts === "function") {
+        callback = opts;
+        opts = {};
+      } else if (!opts || typeof opts !== "object") {
+        opts = { mode: opts };
+      }
+      if (process.platform === "win32" && invalidWin32Path(p)) {
+        const errInval = new Error(p + " contains invalid WIN32 path characters.");
+        errInval.code = "EINVAL";
+        return callback(errInval);
+      }
+      let mode = opts.mode;
+      const xfs = opts.fs || fs5;
+      if (mode === void 0) {
+        mode = o777 & ~process.umask();
+      }
+      if (!made) made = null;
+      callback = callback || function() {
+      };
+      p = path4.resolve(p);
+      xfs.mkdir(p, mode, (er) => {
+        if (!er) {
+          made = made || p;
+          return callback(null, made);
+        }
+        switch (er.code) {
+          case "ENOENT":
+            if (path4.dirname(p) === p) return callback(er);
+            mkdirs(path4.dirname(p), opts, (er2, made2) => {
+              if (er2) callback(er2, made2);
+              else mkdirs(p, opts, callback, made2);
+            });
+            break;
+          // In the case of any other error, just see if there's a dir
+          // there already.  If so, then hooray!  If not, then something
+          // is borked.
+          default:
+            xfs.stat(p, (er2, stat) => {
+              if (er2 || !stat.isDirectory()) callback(er, made);
+              else callback(null, made);
+            });
+            break;
+        }
+      });
+    }
+    module2.exports = mkdirs;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js
+var require_mkdirs_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var invalidWin32Path = require_win32().invalidWin32Path;
+    var o777 = parseInt("0777", 8);
+    function mkdirsSync(p, opts, made) {
+      if (!opts || typeof opts !== "object") {
+        opts = { mode: opts };
+      }
+      let mode = opts.mode;
+      const xfs = opts.fs || fs5;
+      if (process.platform === "win32" && invalidWin32Path(p)) {
+        const errInval = new Error(p + " contains invalid WIN32 path characters.");
+        errInval.code = "EINVAL";
+        throw errInval;
+      }
+      if (mode === void 0) {
+        mode = o777 & ~process.umask();
+      }
+      if (!made) made = null;
+      p = path4.resolve(p);
+      try {
+        xfs.mkdirSync(p, mode);
+        made = made || p;
+      } catch (err0) {
+        if (err0.code === "ENOENT") {
+          if (path4.dirname(p) === p) throw err0;
+          made = mkdirsSync(path4.dirname(p), opts, made);
+          mkdirsSync(p, opts, made);
+        } else {
+          let stat;
+          try {
+            stat = xfs.statSync(p);
+          } catch (err1) {
+            throw err0;
+          }
+          if (!stat.isDirectory()) throw err0;
+        }
+      }
+      return made;
+    }
+    module2.exports = mkdirsSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs2 = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var mkdirs = u(require_mkdirs());
+    var mkdirsSync = require_mkdirs_sync();
+    module2.exports = {
+      mkdirs,
+      mkdirsSync,
+      // alias
+      mkdirp: mkdirs,
+      mkdirpSync: mkdirsSync,
+      ensureDir: mkdirs,
+      ensureDirSync: mkdirsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var os4 = require("os");
+    var path4 = require("path");
+    function hasMillisResSync() {
+      let tmpfile = path4.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
+      tmpfile = path4.join(os4.tmpdir(), tmpfile);
+      const d = /* @__PURE__ */ new Date(1435410243862);
+      fs5.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
+      const fd = fs5.openSync(tmpfile, "r+");
+      fs5.futimesSync(fd, d, d);
+      fs5.closeSync(fd);
+      return fs5.statSync(tmpfile).mtime > 1435410243e3;
+    }
+    function hasMillisRes(callback) {
+      let tmpfile = path4.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
+      tmpfile = path4.join(os4.tmpdir(), tmpfile);
+      const d = /* @__PURE__ */ new Date(1435410243862);
+      fs5.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
+        if (err) return callback(err);
+        fs5.open(tmpfile, "r+", (err2, fd) => {
+          if (err2) return callback(err2);
+          fs5.futimes(fd, d, d, (err3) => {
+            if (err3) return callback(err3);
+            fs5.close(fd, (err4) => {
+              if (err4) return callback(err4);
+              fs5.stat(tmpfile, (err5, stats) => {
+                if (err5) return callback(err5);
+                callback(null, stats.mtime > 1435410243e3);
+              });
+            });
+          });
+        });
+      });
+    }
+    function timeRemoveMillis(timestamp) {
+      if (typeof timestamp === "number") {
+        return Math.floor(timestamp / 1e3) * 1e3;
+      } else if (timestamp instanceof Date) {
+        return new Date(Math.floor(timestamp.getTime() / 1e3) * 1e3);
+      } else {
+        throw new Error("fs-extra: timeRemoveMillis() unknown parameter type");
+      }
+    }
+    function utimesMillis(path5, atime, mtime, callback) {
+      fs5.open(path5, "r+", (err, fd) => {
+        if (err) return callback(err);
+        fs5.futimes(fd, atime, mtime, (futimesErr) => {
+          fs5.close(fd, (closeErr) => {
+            if (callback) callback(futimesErr || closeErr);
+          });
+        });
+      });
+    }
+    function utimesMillisSync(path5, atime, mtime) {
+      const fd = fs5.openSync(path5, "r+");
+      fs5.futimesSync(fd, atime, mtime);
+      return fs5.closeSync(fd);
+    }
+    module2.exports = {
+      hasMillisRes,
+      hasMillisResSync,
+      timeRemoveMillis,
+      utimesMillis,
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/buffer.js
+var require_buffer = __commonJS({
+  "../../node_modules/fs-extra/lib/util/buffer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(size) {
+      if (typeof Buffer.allocUnsafe === "function") {
+        try {
+          return Buffer.allocUnsafe(size);
+        } catch (e) {
+          return new Buffer(size);
+        }
+      }
+      return new Buffer(size);
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy-sync/copy-sync.js
+var require_copy_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdirpSync = require_mkdirs2().mkdirsSync;
+    var utimesSync = require_utimes().utimesMillisSync;
+    var notExist = Symbol("notExist");
+    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") {
+        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
+
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+      }
+      const destStat = checkPaths(src, dest);
+      if (opts.filter && !opts.filter(src, dest)) return;
+      const destParent = path4.dirname(dest);
+      if (!fs5.existsSync(destParent)) mkdirpSync(destParent);
+      return startCopy(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 ? fs5.statSync : fs5.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);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (destStat === notExist) return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs5.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      if (typeof fs5.copyFileSync === "function") {
+        fs5.copyFileSync(src, dest);
+        fs5.chmodSync(dest, srcStat.mode);
+        if (opts.preserveTimestamps) {
+          return utimesSync(dest, srcStat.atime, srcStat.mtime);
+        }
+        return;
+      }
+      return copyFileFallback(srcStat, src, dest, opts);
+    }
+    function copyFileFallback(srcStat, src, dest, opts) {
+      const BUF_LENGTH = 64 * 1024;
+      const _buff = require_buffer()(BUF_LENGTH);
+      const fdr = fs5.openSync(src, "r");
+      const fdw = fs5.openSync(dest, "w", srcStat.mode);
+      let pos = 0;
+      while (pos < srcStat.size) {
+        const bytesRead = fs5.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs5.writeSync(fdw, _buff, 0, bytesRead);
+        pos += bytesRead;
+      }
+      if (opts.preserveTimestamps) fs5.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+      fs5.closeSync(fdr);
+      fs5.closeSync(fdw);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (destStat === notExist) return mkDirAndCopy(srcStat, src, dest, opts);
+      if (destStat && !destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+      }
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcStat, src, dest, opts) {
+      fs5.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return fs5.chmodSync(dest, srcStat.mode);
+    }
+    function copyDir(src, dest, opts) {
+      fs5.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 = checkPaths(srcItem, destItem);
+      return startCopy(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs5.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
+      }
+      if (destStat === notExist) {
+        return fs5.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs5.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs5.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path4.resolve(process.cwd(), resolvedDest);
+        }
+        if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (fs5.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs5.unlinkSync(dest);
+      return fs5.symlinkSync(resolvedSrc, dest);
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArray = path4.resolve(src).split(path4.sep);
+      const destArray = path4.resolve(dest).split(path4.sep);
+      return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
+    }
+    function checkStats(src, dest) {
+      const srcStat = fs5.statSync(src);
+      let destStat;
+      try {
+        destStat = fs5.statSync(dest);
+      } catch (err) {
+        if (err.code === "ENOENT") return { srcStat, destStat: notExist };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    function checkPaths(src, dest) {
+      const { srcStat, destStat } = checkStats(src, dest);
+      if (destStat.ino && destStat.ino === srcStat.ino) {
+        throw new Error("Source and destination must not be the same.");
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`);
+      }
+      return destStat;
+    }
+    module2.exports = copySync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy-sync/index.js
+var require_copy_sync2 = __commonJS({
+  "../../node_modules/fs-extra/lib/copy-sync/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
+    function pathExists(path4) {
+      return fs5.access(path4).then(() => true).catch(() => false);
+    }
+    module2.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs5.existsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdirp = require_mkdirs2().mkdirs;
+    var pathExists = require_path_exists().pathExists;
+    var utimes = require_utimes().utimesMillis;
+    var notExist = Symbol("notExist");
+    function copy2(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") {
+        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
+
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+      }
+      checkPaths(src, dest, (err, destStat) => {
+        if (err) return cb(err);
+        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 startCopy(destStat, src, dest, opts, cb);
+        mkdirp(destParent, (err2) => {
+          if (err2) return cb(err2);
+          return startCopy(destStat, src, dest, opts, cb);
+        });
+      });
+    }
+    function handleFilter(onInclude, destStat, src, dest, opts, cb) {
+      Promise.resolve(opts.filter(src, dest)).then((include) => {
+        if (include) {
+          if (destStat) return onInclude(destStat, src, dest, opts, cb);
+          return onInclude(src, dest, opts, cb);
+        }
+        return cb();
+      }, (error) => cb(error));
+    }
+    function startCopy(destStat, src, dest, opts, cb) {
+      if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb);
+      return getStats(destStat, src, dest, opts, cb);
+    }
+    function getStats(destStat, src, dest, opts, cb) {
+      const stat = opts.dereference ? fs5.stat : fs5.lstat;
+      stat(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);
+      });
+    }
+    function onFile(srcStat, destStat, src, dest, opts, cb) {
+      if (destStat === notExist) return copyFile(srcStat, src, dest, opts, cb);
+      return mayCopyFile(srcStat, src, dest, opts, cb);
+    }
+    function mayCopyFile(srcStat, src, dest, opts, cb) {
+      if (opts.overwrite) {
+        fs5.unlink(dest, (err) => {
+          if (err) return cb(err);
+          return copyFile(srcStat, src, dest, opts, cb);
+        });
+      } else if (opts.errorOnExist) {
+        return cb(new Error(`'${dest}' already exists`));
+      } else return cb();
+    }
+    function copyFile(srcStat, src, dest, opts, cb) {
+      if (typeof fs5.copyFile === "function") {
+        return fs5.copyFile(src, dest, (err) => {
+          if (err) return cb(err);
+          return setDestModeAndTimestamps(srcStat, dest, opts, cb);
+        });
+      }
+      return copyFileFallback(srcStat, src, dest, opts, cb);
+    }
+    function copyFileFallback(srcStat, src, dest, opts, cb) {
+      const rs = fs5.createReadStream(src);
+      rs.on("error", (err) => cb(err)).once("open", () => {
+        const ws = fs5.createWriteStream(dest, { mode: srcStat.mode });
+        ws.on("error", (err) => cb(err)).on("open", () => rs.pipe(ws)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
+      });
+    }
+    function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
+      fs5.chmod(dest, srcStat.mode, (err) => {
+        if (err) return cb(err);
+        if (opts.preserveTimestamps) {
+          return utimes(dest, srcStat.atime, srcStat.mtime, cb);
+        }
+        return cb();
+      });
+    }
+    function onDir(srcStat, destStat, src, dest, opts, cb) {
+      if (destStat === notExist) return mkDirAndCopy(srcStat, src, dest, opts, cb);
+      if (destStat && !destStat.isDirectory()) {
+        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
+      }
+      return copyDir(src, dest, opts, cb);
+    }
+    function mkDirAndCopy(srcStat, src, dest, opts, cb) {
+      fs5.mkdir(dest, (err) => {
+        if (err) return cb(err);
+        copyDir(src, dest, opts, (err2) => {
+          if (err2) return cb(err2);
+          return fs5.chmod(dest, srcStat.mode, cb);
+        });
+      });
+    }
+    function copyDir(src, dest, opts, cb) {
+      fs5.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);
+      checkPaths(srcItem, destItem, (err, destStat) => {
+        if (err) return cb(err);
+        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) {
+      fs5.readlink(src, (err, resolvedSrc) => {
+        if (err) return cb(err);
+        if (opts.dereference) {
+          resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
+        }
+        if (destStat === notExist) {
+          return fs5.symlink(resolvedSrc, dest, cb);
+        } else {
+          fs5.readlink(dest, (err2, resolvedDest) => {
+            if (err2) {
+              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs5.symlink(resolvedSrc, dest, cb);
+              return cb(err2);
+            }
+            if (opts.dereference) {
+              resolvedDest = path4.resolve(process.cwd(), resolvedDest);
+            }
+            if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+              return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
+            }
+            if (destStat.isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+              return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
+            }
+            return copyLink(resolvedSrc, dest, cb);
+          });
+        }
+      });
+    }
+    function copyLink(resolvedSrc, dest, cb) {
+      fs5.unlink(dest, (err) => {
+        if (err) return cb(err);
+        return fs5.symlink(resolvedSrc, dest, cb);
+      });
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArray = path4.resolve(src).split(path4.sep);
+      const destArray = path4.resolve(dest).split(path4.sep);
+      return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
+    }
+    function checkStats(src, dest, cb) {
+      fs5.stat(src, (err, srcStat) => {
+        if (err) return cb(err);
+        fs5.stat(dest, (err2, destStat) => {
+          if (err2) {
+            if (err2.code === "ENOENT") return cb(null, { srcStat, destStat: notExist });
+            return cb(err2);
+          }
+          return cb(null, { srcStat, destStat });
+        });
+      });
+    }
+    function checkPaths(src, dest, cb) {
+      checkStats(src, dest, (err, stats) => {
+        if (err) return cb(err);
+        const { srcStat, destStat } = stats;
+        if (destStat.ino && destStat.ino === srcStat.ino) {
+          return cb(new Error("Source and destination must not be the same."));
+        }
+        if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+          return cb(new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`));
+        }
+        return cb(null, destStat);
+      });
+    }
+    module2.exports = copy2;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      copy: u(require_copy())
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/remove/rimraf.js
+var require_rimraf = __commonJS({
+  "../../node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
+    "use strict";
+    var fs5 = 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] || fs5[m];
+        m = m + "Sync";
+        options[m] = options[m] || fs5[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");
+      if (er) {
+        assert(er instanceof Error);
+      }
+      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);
+      if (er) {
+        assert(er instanceof Error);
+      }
+      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);
+      if (originalEr) {
+        assert(originalEr instanceof Error);
+      }
+      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);
+      if (originalEr) {
+        assert(originalEr instanceof Error);
+      }
+      try {
+        options.rmdirSync(p);
+      } catch (er) {
+        if (er.code === "ENOTDIR") {
+          throw originalEr;
+        } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") {
+          rmkidsSync(p, options);
+        } else if (er.code !== "ENOENT") {
+          throw er;
+        }
+      }
+    }
+    function rmkidsSync(p, options) {
+      assert(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 (er) {
+          }
+        } while (Date.now() - startTime < 500);
+      } else {
+        const ret = options.rmdirSync(p, options);
+        return ret;
+      }
+    }
+    module2.exports = rimraf;
+    rimraf.sync = rimrafSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var rimraf = require_rimraf();
+    module2.exports = {
+      remove: u(rimraf),
+      removeSync: rimraf.sync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs5 = require("fs");
+    var path4 = require("path");
+    var mkdir = require_mkdirs2();
+    var remove = require_remove();
+    var emptyDir = u(function emptyDir2(dir, callback) {
+      callback = callback || function() {
+      };
+      fs5.readdir(dir, (err, items) => {
+        if (err) return mkdir.mkdirs(dir, callback);
+        items = items.map((item) => path4.join(dir, item));
+        deleteItem();
+        function deleteItem() {
+          const item = items.pop();
+          if (!item) return callback();
+          remove.remove(item, (err2) => {
+            if (err2) return callback(err2);
+            deleteItem();
+          });
+        }
+      });
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs5.readdirSync(dir);
+      } catch (err) {
+        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/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs5 = require_graceful_fs();
+    var mkdir = require_mkdirs2();
+    var pathExists = require_path_exists().pathExists;
+    function createFile(file, callback) {
+      function makeFile() {
+        fs5.writeFile(file, "", (err) => {
+          if (err) return callback(err);
+          callback();
+        });
+      }
+      fs5.stat(file, (err, stats) => {
+        if (!err && stats.isFile()) return callback();
+        const dir = path4.dirname(file);
+        pathExists(dir, (err2, dirExists) => {
+          if (err2) return callback(err2);
+          if (dirExists) return makeFile();
+          mkdir.mkdirs(dir, (err3) => {
+            if (err3) return callback(err3);
+            makeFile();
+          });
+        });
+      });
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs5.statSync(file);
+      } catch (e) {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path4.dirname(file);
+      if (!fs5.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs5.writeFileSync(file, "");
+    }
+    module2.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs5 = require_graceful_fs();
+    var mkdir = require_mkdirs2();
+    var pathExists = require_path_exists().pathExists;
+    function createLink(srcpath, dstpath, callback) {
+      function makeLink(srcpath2, dstpath2) {
+        fs5.link(srcpath2, dstpath2, (err) => {
+          if (err) return callback(err);
+          callback(null);
+        });
+      }
+      pathExists(dstpath, (err, destinationExists) => {
+        if (err) return callback(err);
+        if (destinationExists) return callback(null);
+        fs5.lstat(srcpath, (err2) => {
+          if (err2) {
+            err2.message = err2.message.replace("lstat", "ensureLink");
+            return callback(err2);
+          }
+          const dir = path4.dirname(dstpath);
+          pathExists(dir, (err3, dirExists) => {
+            if (err3) return callback(err3);
+            if (dirExists) return makeLink(srcpath, dstpath);
+            mkdir.mkdirs(dir, (err4) => {
+              if (err4) return callback(err4);
+              makeLink(srcpath, dstpath);
+            });
+          });
+        });
+      });
+    }
+    function createLinkSync(srcpath, dstpath) {
+      const destinationExists = fs5.existsSync(dstpath);
+      if (destinationExists) return void 0;
+      try {
+        fs5.lstatSync(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path4.dirname(dstpath);
+      const dirExists = fs5.existsSync(dir);
+      if (dirExists) return fs5.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs5.linkSync(srcpath, dstpath);
+    }
+    module2.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
+    "use strict";
+    var path4 = require("path");
+    var fs5 = require_graceful_fs();
+    var pathExists = require_path_exists().pathExists;
+    function symlinkPaths(srcpath, dstpath, callback) {
+      if (path4.isAbsolute(srcpath)) {
+        return fs5.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 fs5.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 = fs5.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 = fs5.existsSync(relativeToDst);
+        if (exists) {
+          return {
+            "toCwd": relativeToDst,
+            "toDst": srcpath
+          };
+        } else {
+          exists = fs5.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/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+    "use strict";
+    var fs5 = 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);
+      fs5.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 = fs5.lstatSync(srcpath);
+      } catch (e) {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module2.exports = {
+      symlinkType,
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path4 = require("path");
+    var fs5 = require_graceful_fs();
+    var _mkdirs = require_mkdirs2();
+    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;
+    function createSymlink(srcpath, dstpath, type, callback) {
+      callback = typeof type === "function" ? type : callback;
+      type = typeof type === "function" ? false : type;
+      pathExists(dstpath, (err, destinationExists) => {
+        if (err) return callback(err);
+        if (destinationExists) return callback(null);
+        symlinkPaths(srcpath, dstpath, (err2, relative) => {
+          if (err2) return callback(err2);
+          srcpath = relative.toDst;
+          symlinkType(relative.toCwd, type, (err3, type2) => {
+            if (err3) return callback(err3);
+            const dir = path4.dirname(dstpath);
+            pathExists(dir, (err4, dirExists) => {
+              if (err4) return callback(err4);
+              if (dirExists) return fs5.symlink(srcpath, dstpath, type2, callback);
+              mkdirs(dir, (err5) => {
+                if (err5) return callback(err5);
+                fs5.symlink(srcpath, dstpath, type2, callback);
+              });
+            });
+          });
+        });
+      });
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      const destinationExists = fs5.existsSync(dstpath);
+      if (destinationExists) return void 0;
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path4.dirname(dstpath);
+      const exists = fs5.existsSync(dir);
+      if (exists) return fs5.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs5.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+    "use strict";
+    var file = require_file();
+    var link = require_link();
+    var symlink = require_symlink();
+    module2.exports = {
+      // file
+      createFile: file.createFile,
+      createFileSync: file.createFileSync,
+      ensureFile: file.createFile,
+      ensureFileSync: file.createFileSync,
+      // link
+      createLink: link.createLink,
+      createLinkSync: link.createLinkSync,
+      ensureLink: link.createLink,
+      ensureLinkSync: link.createLinkSync,
+      // symlink
+      createSymlink: symlink.createSymlink,
+      createSymlinkSync: symlink.createSymlinkSync,
+      ensureSymlink: symlink.createSymlink,
+      ensureSymlinkSync: symlink.createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../../node_modules/jsonfile/index.js"(exports2, module2) {
+    "use strict";
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_3) {
+      _fs = require("fs");
+    }
+    function readFile(file, options, callback) {
+      if (callback == null) {
+        callback = options;
+        options = {};
+      }
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      options = options || {};
+      var fs5 = options.fs || _fs;
+      var shouldThrow = true;
+      if ("throws" in options) {
+        shouldThrow = options.throws;
+      }
+      fs5.readFile(file, options, function(err, data) {
+        if (err) return callback(err);
+        data = stripBom(data);
+        var obj;
+        try {
+          obj = JSON.parse(data, options ? options.reviver : null);
+        } catch (err2) {
+          if (shouldThrow) {
+            err2.message = file + ": " + err2.message;
+            return callback(err2);
+          } else {
+            return callback(null, null);
+          }
+        }
+        callback(null, obj);
+      });
+    }
+    function readFileSync(file, options) {
+      options = options || {};
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      var fs5 = options.fs || _fs;
+      var shouldThrow = true;
+      if ("throws" in options) {
+        shouldThrow = options.throws;
+      }
+      try {
+        var content = fs5.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = file + ": " + err.message;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    function stringify(obj, options) {
+      var spaces;
+      var EOL = "\n";
+      if (typeof options === "object" && options !== null) {
+        if (options.spaces) {
+          spaces = options.spaces;
+        }
+        if (options.EOL) {
+          EOL = options.EOL;
+        }
+      }
+      var str = JSON.stringify(obj, options ? options.replacer : null, spaces);
+      return str.replace(/\n/g, EOL) + EOL;
+    }
+    function writeFile(file, obj, options, callback) {
+      if (callback == null) {
+        callback = options;
+        options = {};
+      }
+      options = options || {};
+      var fs5 = options.fs || _fs;
+      var str = "";
+      try {
+        str = stringify(obj, options);
+      } catch (err) {
+        if (callback) callback(err, null);
+        return;
+      }
+      fs5.writeFile(file, str, options, callback);
+    }
+    function writeFileSync(file, obj, options) {
+      options = options || {};
+      var fs5 = options.fs || _fs;
+      var str = stringify(obj, options);
+      return fs5.writeFileSync(file, str, options);
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content)) content = content.toString("utf8");
+      content = content.replace(/^\uFEFF/, "");
+      return content;
+    }
+    var jsonfile = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync
+    };
+    module2.exports = jsonfile;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var jsonFile = require_jsonfile();
+    module2.exports = {
+      // jsonfile exports
+      readJson: u(jsonFile.readFile),
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: u(jsonFile.writeFile),
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+    "use strict";
+    var path4 = require("path");
+    var mkdir = require_mkdirs2();
+    var pathExists = require_path_exists().pathExists;
+    var jsonFile = require_jsonfile2();
+    function outputJson(file, data, options, callback) {
+      if (typeof options === "function") {
+        callback = options;
+        options = {};
+      }
+      const dir = path4.dirname(file);
+      pathExists(dir, (err, itDoes) => {
+        if (err) return callback(err);
+        if (itDoes) return jsonFile.writeJson(file, data, options, callback);
+        mkdir.mkdirs(dir, (err2) => {
+          if (err2) return callback(err2);
+          jsonFile.writeJson(file, data, options, callback);
+        });
+      });
+    }
+    module2.exports = outputJson;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdir = require_mkdirs2();
+    var jsonFile = require_jsonfile2();
+    function outputJsonSync(file, data, options) {
+      const dir = path4.dirname(file);
+      if (!fs5.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      jsonFile.writeJsonSync(file, data, options);
+    }
+    module2.exports = outputJsonSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    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/fs-extra/lib/move-sync/index.js
+var require_move_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/move-sync/index.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var copySync = require_copy_sync2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs2().mkdirsSync;
+    var buffer = require_buffer();
+    function moveSync(src, dest, options) {
+      options = options || {};
+      const overwrite = options.overwrite || options.clobber || false;
+      src = path4.resolve(src);
+      dest = path4.resolve(dest);
+      if (src === dest) return fs5.accessSync(src);
+      if (isSrcSubdir(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`);
+      mkdirpSync(path4.dirname(dest));
+      tryRenameSync();
+      function tryRenameSync() {
+        if (overwrite) {
+          try {
+            return fs5.renameSync(src, dest);
+          } catch (err) {
+            if (err.code === "ENOTEMPTY" || err.code === "EEXIST" || err.code === "EPERM") {
+              removeSync(dest);
+              options.overwrite = false;
+              return moveSync(src, dest, options);
+            }
+            if (err.code !== "EXDEV") throw err;
+            return moveSyncAcrossDevice(src, dest, overwrite);
+          }
+        } else {
+          try {
+            fs5.linkSync(src, dest);
+            return fs5.unlinkSync(src);
+          } catch (err) {
+            if (err.code === "EXDEV" || err.code === "EISDIR" || err.code === "EPERM" || err.code === "ENOTSUP") {
+              return moveSyncAcrossDevice(src, dest, overwrite);
+            }
+            throw err;
+          }
+        }
+      }
+    }
+    function moveSyncAcrossDevice(src, dest, overwrite) {
+      const stat = fs5.statSync(src);
+      if (stat.isDirectory()) {
+        return moveDirSyncAcrossDevice(src, dest, overwrite);
+      } else {
+        return moveFileSyncAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveFileSyncAcrossDevice(src, dest, overwrite) {
+      const BUF_LENGTH = 64 * 1024;
+      const _buff = buffer(BUF_LENGTH);
+      const flags = overwrite ? "w" : "wx";
+      const fdr = fs5.openSync(src, "r");
+      const stat = fs5.fstatSync(fdr);
+      const fdw = fs5.openSync(dest, flags, stat.mode);
+      let pos = 0;
+      while (pos < stat.size) {
+        const bytesRead = fs5.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs5.writeSync(fdw, _buff, 0, bytesRead);
+        pos += bytesRead;
+      }
+      fs5.closeSync(fdr);
+      fs5.closeSync(fdw);
+      return fs5.unlinkSync(src);
+    }
+    function moveDirSyncAcrossDevice(src, dest, overwrite) {
+      const options = {
+        overwrite: false
+      };
+      if (overwrite) {
+        removeSync(dest);
+        tryCopySync();
+      } else {
+        tryCopySync();
+      }
+      function tryCopySync() {
+        copySync(src, dest, options);
+        return removeSync(src);
+      }
+    }
+    function isSrcSubdir(src, dest) {
+      try {
+        return fs5.statSync(src).isDirectory() && src !== dest && dest.indexOf(src) > -1 && dest.split(path4.dirname(src) + path4.sep)[1].split(path4.sep)[0] === path4.basename(src);
+      } catch (e) {
+        return false;
+      }
+    }
+    module2.exports = {
+      moveSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/index.js
+var require_move = __commonJS({
+  "../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var copy2 = require_copy2().copy;
+    var remove = require_remove().remove;
+    var mkdirp = require_mkdirs2().mkdirp;
+    var pathExists = require_path_exists().pathExists;
+    function move(src, dest, opts, cb) {
+      if (typeof opts === "function") {
+        cb = opts;
+        opts = {};
+      }
+      const overwrite = opts.overwrite || opts.clobber || false;
+      src = path4.resolve(src);
+      dest = path4.resolve(dest);
+      if (src === dest) return fs5.access(src, cb);
+      fs5.stat(src, (err, st) => {
+        if (err) return cb(err);
+        if (st.isDirectory() && isSrcSubdir(src, dest)) {
+          return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`));
+        }
+        mkdirp(path4.dirname(dest), (err2) => {
+          if (err2) return cb(err2);
+          return doRename(src, dest, overwrite, cb);
+        });
+      });
+    }
+    function doRename(src, dest, overwrite, cb) {
+      if (overwrite) {
+        return remove(dest, (err) => {
+          if (err) return cb(err);
+          return rename(src, dest, overwrite, cb);
+        });
+      }
+      pathExists(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) {
+      fs5.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
+      };
+      copy2(src, dest, opts, (err) => {
+        if (err) return cb(err);
+        return remove(src, cb);
+      });
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArray = src.split(path4.sep);
+      const destArray = dest.split(path4.sep);
+      return srcArray.reduce((acc, current, i) => {
+        return acc && destArray[i] === current;
+      }, true);
+    }
+    module2.exports = {
+      move: u(move)
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/output/index.js
+var require_output = __commonJS({
+  "../../node_modules/fs-extra/lib/output/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs5 = require_graceful_fs();
+    var path4 = require("path");
+    var mkdir = require_mkdirs2();
+    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 fs5.writeFile(file, data, encoding, callback);
+        mkdir.mkdirs(dir, (err2) => {
+          if (err2) return callback(err2);
+          fs5.writeFile(file, data, encoding, callback);
+        });
+      });
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path4.dirname(file);
+      if (fs5.existsSync(dir)) {
+        return fs5.writeFileSync(file, ...args);
+      }
+      mkdir.mkdirsSync(dir);
+      fs5.writeFileSync(file, ...args);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object.assign(
+      {},
+      // Export promiseified graceful-fs:
+      require_fs(),
+      // Export extra methods:
+      require_copy_sync2(),
+      require_copy2(),
+      require_empty(),
+      require_ensure(),
+      require_json(),
+      require_mkdirs2(),
+      require_move_sync(),
+      require_move(),
+      require_output(),
+      require_path_exists(),
+      require_remove()
+    );
+    var fs5 = require("fs");
+    if (Object.getOwnPropertyDescriptor(fs5, "promises")) {
+      Object.defineProperty(module2.exports, "promises", {
+        get() {
+          return fs5.promises;
+        }
+      });
+    }
+  }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  checkForLatestVersion: () => checkForLatestVersion,
+  checkNodeVersion: () => checkNodeVersion,
+  createNodeApp: () => createNodeApp,
+  printEnvInfo: () => printEnvInfo
+});
+module.exports = __toCommonJS(index_exports);
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_envinfo = __toESM(require("envinfo"), 1);
+var import_semver3 = __toESM(require("semver"), 1);
+var import_child_process3 = require("child_process");
+
+// installer.ts
+var import_underscore2 = __toESM(require("underscore"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_os3 = __toESM(require("os"), 1);
+var import_semver2 = __toESM(require("semver"), 1);
+var import_child_process2 = require("child_process");
+
+// helpers.ts
+var import_child_process = require("child_process");
+var import_cross_spawn = __toESM(require("cross-spawn"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_semver = __toESM(require("semver"), 1);
+var import_dns = __toESM(require("dns"), 1);
+var import_url = require("url");
+var shouldUseYarn = () => {
+  const { hasMinYarnPnp, hasMaxYarnPnp, yarnVersion } = checkYarnVersion();
+  if (!hasMinYarnPnp) {
+    console.log(
+      import_picocolors.default.yellow(
+        `You are using yarn version ${import_picocolors.default.bold(
+          yarnVersion
+        )} which is not supported yet. To use Yarn, install v1.12.0 or higher and lower than v2.0.0. See https://yarnpkg.com for instructions on how to update.`
+      )
+    );
+    return false;
+  }
+  if (!hasMaxYarnPnp) {
+    console.log(
+      import_picocolors.default.yellow(
+        `You are using a pre-release version of Yarn which is not supported yet. To use Yarn, install v1.12.0 or higher and lower than v2.0.0. See https://yarnpkg.com for instructions on how to update.`
+      )
+    );
+    return false;
+  }
+  return true;
+};
+var shouldUsePnpm = () => {
+  const { hasMinPnpm, pnpmVersion } = checkPnpmVersion();
+  if (!hasMinPnpm) {
+    console.log(
+      import_picocolors.default.yellow(
+        `You are using pnpm version ${import_picocolors.default.bold(
+          pnpmVersion
+        )} which is not supported yet. To use pnpm, install v5.0.0 or higher. See https://pnpm.js.org for instructions on how to update.`
+      )
+    );
+    return false;
+  }
+  return true;
+};
+var checkThatNpmCanReadCwd = () => {
+  const cwd = process.cwd();
+  let childOutput = null;
+  try {
+    childOutput = import_cross_spawn.default.sync("npm", ["config", "list"]).output.join("");
+  } catch (err) {
+    return true;
+  }
+  if (typeof childOutput !== "string") {
+    return true;
+  }
+  const lines = childOutput.split("\n");
+  const prefix = "; cwd = ";
+  const line = lines.find((line2) => line2.startsWith(prefix));
+  if (typeof line !== "string") {
+    return true;
+  }
+  const npmCWD = line.substring(prefix.length);
+  if (npmCWD === cwd) {
+    return true;
+  }
+  console.error(
+    import_picocolors.default.red(
+      `Could not start an npm process in the right directory.
+
+The current directory is: ${import_picocolors.default.bold(cwd)}
+However, a newly started npm process runs in: ${import_picocolors.default.bold(npmCWD)}
+
+This is probably caused by a misconfigured system terminal shell.`
+    )
+  );
+  if (process.platform === "win32") {
+    console.error(
+      import_picocolors.default.red(`On Windows, this can usually be fixed by running:
+
+`) + `  ${import_picocolors.default.cyan(
+        "reg"
+      )} delete "HKCU\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+  ${import_picocolors.default.cyan(
+        "reg"
+      )} delete "HKLM\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+
+` + import_picocolors.default.red(`Try to run the above two lines in the terminal.
+`) + import_picocolors.default.red(
+        `To learn more about this problem, read: https://blogs.msdn.microsoft.com/oldnewthing/20071121-00/?p=24433/`
+      )
+    );
+  }
+  return false;
+};
+var checkPnpmVersion = () => {
+  const minPnpm = "5.0.0";
+  let hasMinPnpm = false;
+  let pnpmVersion = null;
+  try {
+    pnpmVersion = (0, import_child_process.execSync)("pnpm --version").toString().trim();
+    if (import_semver.default.valid(pnpmVersion)) {
+      hasMinPnpm = import_semver.default.gte(pnpmVersion, minPnpm);
+    } else {
+      const trimmedPnpmVersionMatch = /^(.*?)[-+].+$/.exec(pnpmVersion);
+      if (trimmedPnpmVersionMatch && trimmedPnpmVersionMatch[1]) {
+        hasMinPnpm = import_semver.default.gte(trimmedPnpmVersionMatch[1], minPnpm);
+      }
+    }
+  } catch (e) {
+  }
+  return { hasMinPnpm, pnpmVersion };
+};
+var checkYarnVersion = () => {
+  const minYarnPnp = "1.12.0";
+  const maxYarnPnp = "2.0.0";
+  let hasMinYarnPnp = false;
+  let hasMaxYarnPnp = false;
+  let yarnVersion = null;
+  try {
+    yarnVersion = (0, import_child_process.execSync)("yarnpkg --version").toString().trim();
+    if (import_semver.default.valid(yarnVersion)) {
+      hasMinYarnPnp = import_semver.default.gte(yarnVersion, minYarnPnp);
+      hasMaxYarnPnp = import_semver.default.lt(yarnVersion, maxYarnPnp);
+    } else {
+      const trimmedYarnVersionMatch = /^(.+?)[-+].+$/.exec(yarnVersion);
+      if (trimmedYarnVersionMatch) {
+        const trimmedYarnVersion = trimmedYarnVersionMatch.pop();
+        if (trimmedYarnVersion) {
+          hasMinYarnPnp = import_semver.default.gte(trimmedYarnVersion, minYarnPnp);
+          hasMaxYarnPnp = import_semver.default.lt(trimmedYarnVersion, maxYarnPnp);
+        }
+      }
+    }
+  } catch (err) {
+  }
+  return {
+    hasMinYarnPnp,
+    hasMaxYarnPnp,
+    yarnVersion
+  };
+};
+var checkNpmVersion = () => {
+  let hasMinNpm = false;
+  let npmVersion = null;
+  try {
+    npmVersion = (0, import_child_process.execSync)("npm --version").toString().trim();
+    hasMinNpm = import_semver.default.gte(npmVersion, "6.0.0");
+  } catch (err) {
+  }
+  return {
+    hasMinNpm,
+    npmVersion
+  };
+};
+var getProxy = () => {
+  if (process.env.HTTPS_PROXY) {
+    return process.env.HTTPS_PROXY;
+  }
+  try {
+    const httpsProxy = (0, import_child_process.execSync)("npm config get https-proxy").toString().trim();
+    return httpsProxy !== "null" ? httpsProxy : void 0;
+  } catch (e) {
+  }
+  return "";
+};
+var checkIfOnline = (useYarn) => {
+  if (!useYarn) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    import_dns.default.lookup("registry.yarnpkg.com", (err) => {
+      let proxy;
+      if (err != null && (proxy = getProxy())) {
+        import_dns.default.lookup(new import_url.URL(proxy).hostname, (proxyErr) => {
+          resolve(!proxyErr);
+        });
+      } else {
+        resolve(!err);
+      }
+    });
+  });
+};
+
+// package.ts
+var import_fs3 = require("fs");
+var import_lodash = __toESM(require("lodash.merge"), 1);
+
+// paths.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// git.ts
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_debug = __toESM(require("debug"), 1);
+var import_simple_git = __toESM(require("simple-git"), 1);
+var fse = __toESM(require_lib(), 1);
+var log = (0, import_debug.default)("cna:git");
+var filterGit = (src) => {
+  return !/(\\|\/)\.git\b/.test(src);
+};
+var gitOperationMap = /* @__PURE__ */ new Map();
+var completedTargetIds = /* @__PURE__ */ new Map();
+var downloadRepository = async ({
+  url = "",
+  offline = false,
+  target = "./",
+  branch = "main",
+  targetId,
+  cacheDir: optsCacheDir
+}) => {
+  const absoluteTarget = import_path.default.isAbsolute(target) ? target : import_path.default.resolve(target);
+  const isGithub = /^[^/]+\/[^/]+$/.test(url);
+  const gitUrl = isGithub ? `https://github.com/${url}` : url;
+  const id = targetId || Buffer.from(`${gitUrl}@${branch}`).toString("base64");
+  let cacheDir = optsCacheDir || import_path.default.join(import_os.default.homedir(), ".cache", "cna", id);
+  cacheDir = import_path.default.isAbsolute(cacheDir) ? cacheDir : import_path.default.resolve(cacheDir);
+  log("cache folder: %s", cacheDir);
+  if (completedTargetIds.has(id)) {
+    log(
+      `Git checkout for target ID '${id}' has already been completed. Skipping.`
+    );
+    await fse.copy(cacheDir, absoluteTarget, {
+      overwrite: true,
+      filter: filterGit
+    });
+    return;
+  }
+  if (gitOperationMap.has(id)) {
+    log(
+      `Git operation for target ID '${id}' is already in progress. Waiting...`
+    );
+    await gitOperationMap.get(id);
+    log(`Git operation for target ID '${id}' has completed.`);
+    return;
+  }
+  const gitOperationPromise = (async () => {
+    let git = (0, import_simple_git.default)();
+    const cloneOptions = {
+      "--depth": 1,
+      "--branch": branch,
+      "--single-branch": null,
+      "--no-tags": null
+    };
+    try {
+      const cached = import_fs.default.existsSync(cacheDir);
+      if (!cached) {
+        log("Cloning repository...");
+        await git.clone(gitUrl, cacheDir, cloneOptions);
+      }
+      git = (0, import_simple_git.default)(cacheDir);
+      if (!offline) {
+        log("Pulling repository...");
+        await git.checkout(["-f", branch]);
+        await git.pull();
+      }
+      await fse.copy(cacheDir, absoluteTarget, {
+        overwrite: true,
+        filter: filterGit
+      });
+      completedTargetIds.set(id, true);
+    } catch (error) {
+      console.error("Error during repository download:", error);
+    } finally {
+      gitOperationMap.delete(id);
+    }
+  })();
+  gitOperationMap.set(id, gitOperationPromise);
+  await gitOperationPromise;
+};
+
+// paths.ts
+var solveValuesFromTemplateOrExtensionUrl = (templateOrExtension) => {
+  const url = new URL(templateOrExtension);
+  const origin = `${url.protocol}//${url.host}`;
+  const [org, repo, , branch = "", ...subdir] = url.pathname.slice(1).split("/");
+  const ignorePackage = url.searchParams.get("ignorePackage") === "true";
+  return {
+    url: `${origin}/${org}/${repo}`,
+    branch,
+    subdir: subdir.join("/"),
+    protocol: url.protocol,
+    host: url.host,
+    pathname: url.pathname,
+    ignorePackage
+  };
+};
+var solveRepositoryPath = async ({
+  url,
+  branch,
+  subdir
+}) => {
+  const targetId = Buffer.from(`${url}#${branch}`).toString("base64");
+  const targetWithSubdir = Buffer.from(`${url}#${branch}#${subdir}`).toString(
+    "base64"
+  );
+  const target = import_path2.default.join(import_os2.default.homedir(), ".cna", targetWithSubdir);
+  try {
+    await downloadRepository({
+      url,
+      branch,
+      target,
+      targetId
+    });
+  } catch {
+  }
+  return { dir: target, subdir };
+};
+var solveTemplateOrExtensionPath = async (templateOrExtension) => {
+  try {
+    const { url, branch, subdir, protocol, host, pathname, ignorePackage } = solveValuesFromTemplateOrExtensionUrl(templateOrExtension);
+    if (protocol === "file:") {
+      return {
+        dir: import_path2.default.resolve(host, pathname),
+        subdir
+      };
+    }
+    const gitData = await solveRepositoryPath({
+      url,
+      branch,
+      subdir
+    });
+    return { ...gitData, ignorePackage };
+  } catch {
+    return {
+      dir: import_path2.default.resolve(
+        __dirname,
+        "..",
+        "templatesOrExtensions",
+        templateOrExtension
+      ),
+      ignorePackage: void 0
+    };
+  }
+};
+var getPackagePath = async (templateOrExtension, name = "package", ignorePackage = false) => {
+  const {
+    dir,
+    subdir,
+    ignorePackage: templateOrExtensionIgnorePackage
+  } = await solveTemplateOrExtensionPath(templateOrExtension);
+  if (name === "package.json" && (ignorePackage || templateOrExtensionIgnorePackage)) {
+    throw new Error(
+      "package.json should be ignored for file templateOrExtension"
+    );
+  }
+  if (subdir) {
+    return import_path2.default.resolve(dir, subdir, name);
+  }
+  return import_path2.default.resolve(dir, name);
+};
+var getTemplateDirPath = async (templateOrExtensionUrl) => {
+  const { dir, subdir = "" } = await solveTemplateOrExtensionPath(
+    templateOrExtensionUrl
+  );
+  let templateDirPath = import_path2.default.resolve(dir, subdir);
+  const templateDirPathWithTemplate = import_path2.default.resolve(templateDirPath, "template");
+  return new Promise((resolve) => {
+    import_fs2.default.stat(templateDirPathWithTemplate, (_err, stats) => {
+      if (_err) {
+        resolve(templateDirPath);
+        return;
+      }
+      if (stats.isDirectory()) {
+        templateDirPath = templateDirPathWithTemplate;
+      }
+      resolve(templateDirPath);
+    });
+  });
+};
+
+// package.ts
+var getInstallableSetup = ({
+  dependencies,
+  devDependencies,
+  ...packageJson
+}) => {
+  const getInstallableDeps = (deps = {}) => Object.entries(deps).map(([dep, version]) => `${dep}@${version}`);
+  return {
+    packageJson,
+    dependencies: getInstallableDeps(dependencies),
+    devDependencies: getInstallableDeps(devDependencies)
+  };
+};
+var requireIfExists = (path4) => {
+  if ((0, import_fs3.existsSync)(path4)) {
+    return require(path4);
+  }
+  throw new Error(`File ${path4} does not exist`);
+};
+var loadPackages = async ({
+  templatesOrExtensions = [],
+  ignorePackage: globalIgnorePackage = false,
+  ...config
+}) => {
+  const setup = await Promise.all(
+    templatesOrExtensions.map(async ({ url: templateOrExtension }) => {
+      try {
+        const template = requireIfExists(
+          await getPackagePath(templateOrExtension, "template.json")
+        );
+        return template.package || {};
+      } catch {
+        return {};
+      }
+    })
+  );
+  const mergedSetup = (0, import_lodash.default)(
+    {
+      name: config.appName,
+      dependencies: {},
+      devDependencies: {},
+      scripts: {}
+    },
+    ...setup
+  );
+  const finalSetup = await Promise.all(
+    templatesOrExtensions.map(
+      async ({ url: templateOrExtension, ignorePackage }) => {
+        try {
+          const templateOrExtensionPackageJson = requireIfExists(
+            await getPackagePath(
+              templateOrExtension,
+              "package.json",
+              globalIgnorePackage || ignorePackage
+            )
+          );
+          return templateOrExtensionPackageJson;
+        } catch {
+          return {};
+        }
+      }
+    )
+  );
+  const resolvedSetup = await Promise.all(
+    templatesOrExtensions.map(async ({ url: templateOrExtension }) => {
+      try {
+        const resolveTemplateOrExtensionPackage = requireIfExists(
+          await getPackagePath(templateOrExtension)
+        );
+        return resolveTemplateOrExtensionPackage(mergedSetup, config);
+      } catch {
+        return {};
+      }
+    })
+  );
+  const packageJson = (0, import_lodash.default)(mergedSetup, ...finalSetup, ...resolvedSetup);
+  return getInstallableSetup({
+    ...packageJson,
+    name: config.appName
+  });
+};
+
+// loaders.ts
+var import_underscore = __toESM(require("underscore"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+var import_readdirp = require("readdirp");
+var import_path3 = require("path");
+var import_util = require("util");
+var writeFileAsync = (0, import_util.promisify)(import_fs4.default.writeFile);
+var copyFileAsync = (0, import_util.promisify)(import_fs4.default.copyFile);
+var SRC_PATH_PATTERN = "[src]/";
+var DEFAULT_SRC_PATH = "src/";
+var getSrcDirPattern = (srcDir) => srcDir === "." ? "" : srcDir + "/";
+var makeDirectory = (dirPath) => {
+  if (!import_fs4.default.existsSync(dirPath)) {
+    import_fs4.default.mkdirSync(dirPath, { recursive: true });
+  }
+};
+var getModeFromPath = (path4 = "") => {
+  const matchExts = (...exts) => exts.find((ext) => path4.endsWith(ext));
+  if (matchExts(".append")) {
+    return "append";
+  }
+  if (matchExts(".append.template", ".template.append")) {
+    return "appendTemplate";
+  }
+  if (matchExts(".template")) {
+    return "copyTemplate";
+  }
+  return "copy";
+};
+var batchedCopyFiles = async (operations) => {
+  const batchedPromises = operations.map(async (operation) => {
+    try {
+      makeDirectory((0, import_path3.dirname)(operation.dest));
+      await copyFileAsync(operation.src, operation.dest);
+      if (operation.verbose) {
+        console.log(
+          import_picocolors2.default.green(
+            `Added "${operation.dest}" from "${operation.src}" successfully`
+          )
+        );
+      }
+    } catch (err) {
+      console.log(
+        import_picocolors2.default.red(`Cannot copy file ${operation.src} to ${operation.dest}`)
+      );
+      if (operation.verbose) {
+        console.log(import_picocolors2.default.red(String(err)));
+      }
+      throw err;
+    }
+  });
+  await Promise.all(batchedPromises);
+};
+var batchedWriteFiles = async (operations) => {
+  const batchedPromises = operations.map(async (operation) => {
+    try {
+      makeDirectory((0, import_path3.dirname)(operation.path));
+      await writeFileAsync(operation.path, operation.content, {
+        flag: operation.flag,
+        mode: operation.mode
+      });
+      if (operation.verbose) {
+        console.log(import_picocolors2.default.green(`Added "${operation.path}" successfully`));
+      }
+    } catch (err) {
+      console.log(import_picocolors2.default.red(`Cannot write file ${operation.path}`));
+      if (operation.verbose) {
+        console.log(import_picocolors2.default.red(String(err)));
+      }
+      throw err;
+    }
+  });
+  await Promise.all(batchedPromises);
+};
+var batchedAppendFiles = async (operations) => {
+  const batchedPromises = operations.map(async (operation) => {
+    try {
+      const content = await (0, import_util.promisify)(import_fs4.default.readFile)(operation.src, "utf8");
+      const fileMode = (await (0, import_util.promisify)(import_fs4.default.stat)(operation.src)).mode;
+      await batchedWriteFiles([
+        {
+          path: operation.dest,
+          content,
+          flag: "a+",
+          verbose: operation.verbose,
+          mode: fileMode
+        }
+      ]);
+    } catch (err) {
+      console.log(
+        import_picocolors2.default.red(`Cannot append file ${operation.src} to ${operation.dest}`)
+      );
+      if (operation.verbose) {
+        console.log(import_picocolors2.default.red(String(err)));
+      }
+      throw err;
+    }
+  });
+  await Promise.all(batchedPromises);
+};
+var copyLoader = ({ root, templateDir, verbose, srcDir }) => async ({ path: path4 }) => {
+  const operations = [];
+  try {
+    const newPath = path4.replace(/.if-(npm|yarn|pnpm)$/, "").replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir));
+    operations.push({
+      src: `${templateDir}/${path4}`,
+      dest: `${root}/${newPath}`,
+      verbose
+    });
+  } catch (err) {
+    if (verbose) {
+      console.log(err);
+    }
+    throw err;
+  }
+  await batchedCopyFiles(operations);
+};
+var appendLoader = ({ root, templateDir, verbose, srcDir }) => async ({ path: path4 }) => {
+  const operations = [];
+  try {
+    const newPath = path4.replace(/.append$/, "").replace(/.if-(npm|yarn|pnpm)$/, "").replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir));
+    operations.push({
+      src: `${templateDir}/${path4}`,
+      dest: `${root}/${newPath}`,
+      verbose
+    });
+  } catch (err) {
+    if (verbose) {
+      console.log(err);
+    }
+    throw err;
+  }
+  await batchedAppendFiles(operations);
+};
+var templateLoader = ({
+  root,
+  templateDir,
+  appName,
+  verbose,
+  mode = "",
+  srcDir,
+  runCommand,
+  installCommand,
+  ...customOptions
+}) => async ({ path: path4 }) => {
+  const operations = [];
+  try {
+    const flag = mode.includes("append") ? "a+" : "w";
+    const filePath = `${templateDir}/${path4}`;
+    const file = await (0, import_util.promisify)(import_fs4.default.readFile)(filePath, "utf8");
+    const fileMode = (await (0, import_util.promisify)(import_fs4.default.stat)(filePath)).mode;
+    const newFile = import_underscore.default.template(file);
+    const newPath = path4.replace(/.template$/, "").replace(/.append$/, "").replace(/.if-(npm|yarn|pnpm)$/, "").replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir));
+    operations.push({
+      path: `${root}/${newPath}`,
+      content: newFile({
+        projectName: appName,
+        srcDir: srcDir || ".",
+        runCommand,
+        installCommand,
+        ...customOptions
+      }),
+      flag,
+      verbose,
+      mode: fileMode
+    });
+  } catch (err) {
+    if (verbose) {
+      console.log(err);
+    }
+    throw err;
+  }
+  await batchedWriteFiles(operations);
+};
+var fileLoader = ({
+  root,
+  templateDir,
+  appName,
+  originalDirectory,
+  verbose,
+  useYarn,
+  usePnpm,
+  srcDir = DEFAULT_SRC_PATH,
+  runCommand,
+  installCommand,
+  ...customOptions
+}) => async ({ path: path4 }) => {
+  try {
+    const mode = getModeFromPath(path4);
+    const loaders = {
+      copy: copyLoader,
+      append: appendLoader,
+      copyTemplate: templateLoader,
+      appendTemplate: appendLoader
+    };
+    await loaders[mode]({
+      root,
+      templateDir,
+      appName,
+      originalDirectory,
+      verbose,
+      useYarn: !!useYarn,
+      usePnpm: !!usePnpm,
+      mode,
+      srcDir,
+      runCommand,
+      installCommand,
+      ...customOptions
+    })({
+      path: path4
+    });
+  } catch (err) {
+    if (verbose) {
+      console.log(err);
+    }
+    throw err;
+  }
+};
+var loadFiles = async ({
+  root,
+  templatesOrExtensions = [],
+  appName,
+  originalDirectory,
+  verbose,
+  useYarn = false,
+  usePnpm = false,
+  srcDir = DEFAULT_SRC_PATH,
+  runCommand,
+  installCommand,
+  ...customOptions
+}) => {
+  try {
+    const operations = [];
+    for await (const { url: templateOrExtensionUrl } of templatesOrExtensions) {
+      const templateDir = await getTemplateDirPath(templateOrExtensionUrl);
+      if (import_fs4.default.existsSync(templateDir) && import_fs4.default.statSync(templateDir).isDirectory()) {
+        for await (const entry of (0, import_readdirp.readdirp)(templateDir, {
+          fileFilter: [
+            "!package.js",
+            "!package.json",
+            "!package-lock.json",
+            "!template.json",
+            "!yarn.lock",
+            "!pnpm-lock.yaml",
+            // based on the package manager we want to ignore files containing
+            // the other package as condition.
+            // For example, if `usePnpm` is true, the we need to ignore
+            // all files with `.if-npm` or `.if-yarn` somewhere in the name.
+            ...usePnpm ? ["!*.if-npm.*", "!*.if-yarn.*"] : useYarn ? ["!*.if-npm.*", "!*.if-pnpm.*"] : ["!*.if-yarn.*", "!*.if-pnpm.*"]
+          ],
+          directoryFilter: ["!package"]
+        })) {
+          operations.push({
+            root,
+            templateDir,
+            appName,
+            originalDirectory,
+            verbose,
+            useYarn,
+            usePnpm,
+            srcDir,
+            runCommand,
+            installCommand,
+            entry,
+            ...customOptions
+          });
+        }
+      }
+    }
+    await Promise.all(
+      operations.map((operation) => fileLoader(operation)(operation.entry))
+    );
+  } catch (err) {
+    if (verbose) {
+      console.log(err);
+    }
+    throw err;
+  }
+};
+
+// installer.ts
+var install = async (root, useYarn = false, usePnpm = false, dependencies = [], verbose = false, isOnline = true, isDevDependencies = false) => {
+  let command;
+  let args;
+  if (useYarn) {
+    command = "yarnpkg";
+    args = ["add", "--ignore-workspace-root-check"];
+    if (!isOnline) {
+      args.push("--offline");
+    }
+    if (isDevDependencies) {
+      args.push("--dev");
+    }
+    args.push(...dependencies);
+    args.push("--cwd");
+    args.push(root);
+    if (!isOnline) {
+      console.log(import_picocolors3.default.yellow("You appear to be offline."));
+      console.log(import_picocolors3.default.yellow("Falling back to the local Yarn cache."));
+      console.log();
+    }
+  } else if (usePnpm) {
+    command = "pnpm";
+    args = ["install", "--ignore-workspace", "--loglevel", "error"];
+    if (isDevDependencies) {
+      args.push("--save-dev");
+    } else {
+      args.push("--save");
+    }
+    args.push(...dependencies);
+  } else {
+    command = "npm";
+    args = ["install", "--loglevel", "error"];
+    if (isDevDependencies) {
+      args.push("--save-dev");
+    } else {
+      args.push("--save");
+    }
+    args.push(...dependencies);
+  }
+  if (verbose) {
+    args.push("--verbose");
+  }
+  try {
+    (0, import_child_process2.execSync)(`${command} ${args.join(" ")}`, {
+      cwd: root,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    throw new Error(`${command} ${args.join(" ")}`);
+  }
+};
+var runCommandInProjectDir = async (root, command, args = [], successMessage = "Operation completed successfully.", errorMessage = "Operation failed.") => {
+  try {
+    (0, import_child_process2.execSync)(`${command} ${args.join(" ")}`, {
+      cwd: root,
+      stdio: "ignore"
+    });
+    console.log(import_picocolors3.default.green(successMessage));
+  } catch (error) {
+    console.log();
+    console.log(import_picocolors3.default.red(errorMessage));
+    console.log();
+  }
+};
+function extractNameAndVersion(dependencyString) {
+  const lastIndex = dependencyString.lastIndexOf("@");
+  if (lastIndex !== -1) {
+    const name = dependencyString.substring(0, lastIndex);
+    const version = dependencyString.substring(lastIndex + 1);
+    return { name, version };
+  } else {
+    return { name: dependencyString, version: "" };
+  }
+}
+var run = async ({
+  root,
+  appName,
+  originalDirectory,
+  verbose = false,
+  useYarn = false,
+  usePnpm = false,
+  templatesOrExtensions = [],
+  dependencies = [],
+  devDependencies = [],
+  installDependencies = true,
+  runCommand = "",
+  installCommand = "",
+  ...customOptions
+}) => {
+  const isOnline = useYarn ? await checkIfOnline(useYarn) : true;
+  if (import_underscore2.default.isEmpty(templatesOrExtensions)) {
+    console.log();
+    console.log(
+      import_picocolors3.default.yellow(
+        "No templates or extensions specified to bootstrap application."
+      )
+    );
+    console.log();
+    process.exit(0);
+  }
+  console.log();
+  console.log("Scaffolding project in " + root + "...");
+  await loadFiles({
+    root,
+    templatesOrExtensions,
+    appName,
+    originalDirectory,
+    verbose,
+    useYarn,
+    usePnpm,
+    runCommand,
+    installCommand,
+    ...customOptions
+  });
+  console.log();
+  console.log(import_picocolors3.default.green("Successfully scaffolded project."));
+  console.log();
+  if (installDependencies) {
+    console.log(
+      import_picocolors3.default.green("Installing packages. This might take a couple of minutes.")
+    );
+    console.log(import_picocolors3.default.green("Installing dependencies..."));
+    console.log();
+    await install(
+      root,
+      useYarn,
+      usePnpm,
+      dependencies,
+      verbose,
+      isOnline,
+      false
+    );
+    if (devDependencies.length > 0) {
+      console.log();
+      console.log(import_picocolors3.default.green("Installing devDependencies..."));
+      console.log();
+      await install(
+        root,
+        useYarn,
+        usePnpm,
+        devDependencies,
+        verbose,
+        isOnline,
+        true
+      );
+    }
+  } else {
+    console.log(import_picocolors3.default.yellow("Skip package installation."));
+    const packageJson2 = JSON.parse(
+      import_fs5.default.readFileSync(`${root}/package.json`, "utf8")
+    );
+    const updateDependencies = (deps) => {
+      return deps.reduce(
+        (dep, elem) => {
+          const nextDep = dep;
+          if (/.+@(\^|~)?[0-9a-zA-Z-.]+$/.test(elem)) {
+            const { name, version } = extractNameAndVersion(elem);
+            nextDep[name] = version;
+          } else {
+            nextDep[elem] = "*";
+          }
+          return nextDep;
+        },
+        {}
+      );
+    };
+    packageJson2.dependencies = updateDependencies(dependencies);
+    packageJson2.devDependencies = updateDependencies(devDependencies);
+    import_fs5.default.writeFileSync(
+      import_path4.default.join(root, "package.json"),
+      JSON.stringify(packageJson2, null, 2) + import_os3.default.EOL
+    );
+    console.log();
+    console.log(import_picocolors3.default.green("Successfully updated package.json."));
+    console.log(import_picocolors3.default.yellow(`Run ${import_picocolors3.default.cyan(installCommand)} to install.`));
+  }
+  console.log();
+  console.log("Initializing git repository...");
+  try {
+    const { simpleGit: simpleGit2 } = await import("simple-git");
+    const git = simpleGit2(root);
+    await git.init();
+    console.log(import_picocolors3.default.green("Successfully initialized git repository."));
+  } catch (error) {
+    console.log();
+    console.log(
+      import_picocolors3.default.red(
+        "Failed to initialize git repository. Run `git init` to initialize git repository after the process is completed."
+      )
+    );
+    console.log();
+  }
+  if (installDependencies && isOnline) {
+    const packageJson2 = JSON.parse(
+      import_fs5.default.readFileSync(`${root}/package.json`, "utf8")
+    );
+    const runFormat = async () => {
+      try {
+        await runCommandInProjectDir(
+          root,
+          runCommand,
+          ["format"],
+          "Successfully formatted code.",
+          `Failed to format code. Run \`${runCommand} format\` to format code after the process is completed.`
+        );
+      } catch {
+      }
+    };
+    const runLintFix = async () => {
+      try {
+        await runCommandInProjectDir(
+          root,
+          runCommand,
+          ["lint:fix"],
+          "Successfully fixed linting errors.",
+          `Failed to fix linting errors. Run \`${runCommand} lint:fix\` to fix linting errors after the process is completed.`
+        );
+      } catch {
+      }
+    };
+    if (packageJson2.scripts && packageJson2.scripts["format"]) {
+      await runFormat();
+    }
+    if (packageJson2.scripts && packageJson2.scripts["lint:fix"]) {
+      await runLintFix();
+    }
+  }
+  console.log();
+  console.log(import_picocolors3.default.green("Successfully created project " + appName + "."));
+  console.log();
+  console.log("Done! Now run:");
+  console.log();
+  console.log(import_picocolors3.default.cyan(`  cd ${appName}`));
+  console.log(import_picocolors3.default.cyan(`  ${installCommand}`));
+  const packageJson = JSON.parse(
+    import_fs5.default.readFileSync(`${root}/package.json`, "utf8")
+  );
+  const lookForScripts = ["compose:up", "sls:offline", "dev", "start"];
+  for (const script of lookForScripts) {
+    if (packageJson.scripts && packageJson.scripts[script]) {
+      console.log(import_picocolors3.default.cyan(`  ${runCommand} ${script}`));
+      break;
+    }
+  }
+  console.log();
+  console.log(import_picocolors3.default.green("Happy hacking!"));
+};
+var createApp = async ({
+  name,
+  verbose = false,
+  templatesOrExtensions = [],
+  installDependencies = true,
+  ignorePackage = false,
+  ...customOptions
+}) => {
+  const root = import_path4.default.resolve(name);
+  const appName = import_path4.default.basename(root);
+  import_fs5.default.mkdirSync(name, {
+    recursive: true
+  });
+  console.log(`Creating a new Node app in ${import_picocolors3.default.green(root)}.`);
+  console.log();
+  const useYarn = customOptions.packageManager === "yarn" && shouldUseYarn();
+  const usePnpm = customOptions.packageManager === "pnpm" && shouldUsePnpm();
+  const runCommand = useYarn ? "yarn" : usePnpm ? "pnpm run" : "npm run";
+  const installCommand = useYarn ? "yarn" : usePnpm ? "pnpm install" : "npm install";
+  const { packageJson, dependencies, devDependencies } = await loadPackages({
+    templatesOrExtensions,
+    appName,
+    usePnpm,
+    useYarn,
+    runCommand,
+    ignorePackage
+  });
+  import_fs5.default.writeFileSync(
+    import_path4.default.join(root, "package.json"),
+    JSON.stringify(packageJson, null, 2) + import_os3.default.EOL
+  );
+  const originalDirectory = process.cwd();
+  process.chdir(root);
+  if (!useYarn && !checkThatNpmCanReadCwd()) {
+    process.exit(1);
+  }
+  if (!import_semver2.default.satisfies(process.version, ">=18.0.0")) {
+    console.log(
+      import_picocolors3.default.yellow(
+        `You are using Node ${process.version} so the project will be bootstrapped with an old unsupported version of tools.
+
+Please update to Node 18 or higher for a better, fully supported experience.
+`
+      )
+    );
+  }
+  if (!useYarn) {
+    const npmInfo = checkNpmVersion();
+    if (!npmInfo.hasMinNpm) {
+      if (npmInfo.npmVersion) {
+        console.log(
+          import_picocolors3.default.yellow(
+            `You are using npm ${npmInfo.npmVersion} so the project will be bootstrapped with an old unsupported version of tools.
+
+Please update to npm 3 or higher for a better, fully supported experience.
+`
+          )
+        );
+      }
+    }
+  }
+  if (useYarn) {
+    let yarnUsesDefaultRegistry = true;
+    try {
+      yarnUsesDefaultRegistry = (0, import_child_process2.execSync)("yarnpkg config get registry").toString().trim() === "https://registry.yarnpkg.com";
+    } catch (e) {
+    }
+    if (false) {
+      import_fs5.default.cpSync(
+        null,
+        import_path4.default.join(root, "yarn.lock"),
+        { force: true }
+      );
+    }
+  }
+  return run({
+    root,
+    appName,
+    originalDirectory,
+    verbose,
+    useYarn,
+    usePnpm,
+    templatesOrExtensions,
+    dependencies,
+    devDependencies,
+    installDependencies,
+    runCommand,
+    installCommand,
+    ...customOptions
+  });
+};
+
+// index.ts
+var checkNodeVersion = (requiredVersion, packageName) => {
+  if (!import_semver3.default.satisfies(process.version, requiredVersion)) {
+    console.error(
+      import_picocolors4.default.red(
+        `You are running Node ${process.version}.
+${packageName} requires Node ${requiredVersion}.
+Please update your version of Node.`
+      )
+    );
+    process.exit(1);
+  }
+};
+var checkForLatestVersion = async (packageName) => {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/-/package/${packageName}/dist-tags`
+    );
+    if (!response.ok) {
+      throw new Error("Registry request failed");
+    }
+    const json = await response.json();
+    if (json && typeof json === "object" && "latest" in json) {
+      return String(json["latest"]);
+    }
+    return null;
+  } catch (error) {
+    try {
+      return (0, import_child_process3.execSync)(`npm view ${packageName} version`).toString().trim();
+    } catch {
+    }
+  }
+  return null;
+};
+var printEnvInfo = async () => {
+  console.log(import_picocolors4.default.bold("\nEnvironment Info:"));
+  const info = await import_envinfo.default.run(
+    {
+      System: ["OS", "CPU", "Memory", "Shell"],
+      Binaries: ["Node", "npm", "pnpm", "Yarn", "Watchman"],
+      Browsers: ["Chrome", "Edge", "Internet Explorer", "Firefox", "Safari"]
+    },
+    {
+      duplicates: true,
+      showNotFound: true
+    }
+  );
+  console.log(info);
+  process.exit(0);
+};
+var createNodeApp = async (programName, options, transformOptions) => {
+  if (options.info) {
+    await printEnvInfo();
+  }
+  if (typeof options.projectName === "undefined") {
+    console.error("Please specify the project directory:");
+    console.log(`  ${import_picocolors4.default.cyan(programName)} ${import_picocolors4.default.green("[project-directory]")}`);
+    console.log();
+    console.log("For example:");
+    console.log(`  ${import_picocolors4.default.cyan(programName)} ${import_picocolors4.default.green("my-app")}`);
+    console.log();
+    console.log(`Run ${import_picocolors4.default.cyan(`${programName} --help`)} to see all options.`);
+    process.exit(1);
+  }
+  const appOptions = await transformOptions(options);
+  await createApp({
+    ...appOptions,
+    name: appOptions.projectName,
+    installDependencies: options.install ?? true
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkForLatestVersion,
+  checkNodeVersion,
+  createNodeApp,
+  printEnvInfo
+});