@storm-software/config-tools 1.27.31 → 1.28.2

package/index.js

@@ -31,6 +31,2205 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js"(exports) {
+    "use strict";
+    exports.fromCallback = function(fn) {
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function")
+          fn.apply(this, args);
+        else {
+          return new Promise((resolve, reject) => {
+            args.push((err, res) => err != null ? reject(err) : resolve(res));
+            fn.apply(this, args);
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function")
+          return fn.apply(this, args);
+        else {
+          args.pop();
+          fn.apply(this, args).then((r) => cb(null, r), cb);
+        }
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
+    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;
+    module.exports = patch;
+    function patch(fs) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs);
+      }
+      if (!fs.lutimes) {
+        patchLutimes(fs);
+      }
+      fs.chown = chownFix(fs.chown);
+      fs.fchown = chownFix(fs.fchown);
+      fs.lchown = chownFix(fs.lchown);
+      fs.chmod = chmodFix(fs.chmod);
+      fs.fchmod = chmodFix(fs.fchmod);
+      fs.lchmod = chmodFix(fs.lchmod);
+      fs.chownSync = chownFixSync(fs.chownSync);
+      fs.fchownSync = chownFixSync(fs.fchownSync);
+      fs.lchownSync = chownFixSync(fs.lchownSync);
+      fs.chmodSync = chmodFixSync(fs.chmodSync);
+      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+      fs.stat = statFix(fs.stat);
+      fs.fstat = statFix(fs.fstat);
+      fs.lstat = statFix(fs.lstat);
+      fs.statSync = statFixSync(fs.statSync);
+      fs.fstatSync = statFixSync(fs.fstatSync);
+      fs.lstatSync = statFixSync(fs.lstatSync);
+      if (fs.chmod && !fs.lchmod) {
+        fs.lchmod = function(path, mode, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs.lchmodSync = function() {
+        };
+      }
+      if (fs.chown && !fs.lchown) {
+        fs.lchown = function(path, uid, gid, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb)
+                cb(er);
+            });
+          }
+          if (Object.setPrototypeOf)
+            Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs.rename);
+      }
+      fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf)
+          Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs.read);
+      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs.readSync);
+      function patchLchmod(fs2) {
+        fs2.lchmod = function(path, mode, callback) {
+          fs2.open(
+            path,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback)
+                  callback(err);
+                return;
+              }
+              fs2.fchmod(fd, mode, function(err2) {
+                fs2.close(fd, function(err22) {
+                  if (callback)
+                    callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs2.lchmodSync = function(path, mode) {
+          var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs2.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs2.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs2.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs2) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+          fs2.lutimes = function(path, at, mt, cb) {
+            fs2.open(path, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb)
+                  cb(er);
+                return;
+              }
+              fs2.futimes(fd, at, mt, function(er2) {
+                fs2.close(fd, function(er22) {
+                  if (cb)
+                    cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs2.lutimesSync = function(path, at, mt) {
+            var fd = fs2.openSync(path, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs2.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs2.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs2.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs2.futimes) {
+          fs2.lutimes = function(_a, _b, _c, cb) {
+            if (cb)
+              process.nextTick(cb);
+          };
+          fs2.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs, target, mode, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs, target, mode);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs, target, uid, gid, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0)
+                stats.uid += 4294967296;
+              if (stats.gid < 0)
+                stats.gid += 4294967296;
+            }
+            if (cb)
+              cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+          if (stats) {
+            if (stats.uid < 0)
+              stats.uid += 4294967296;
+            if (stats.gid < 0)
+              stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path, options) {
+        if (!(this instanceof ReadStream))
+          return new ReadStream(path, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding)
+          this.setEncoding(this.encoding);
+        if (this.start !== 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;
+        }
+        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path, options) {
+        if (!(this instanceof WriteStream))
+          return new WriteStream(path, options);
+        Stream.call(this);
+        this.path = path;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== 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 = fs.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
+    "use strict";
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
+    var fs = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util2 = __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 debug = noop;
+    if (util2.debuglog)
+      debug = util2.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util2.format.apply(util2, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs, queue);
+      fs.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs.close);
+      fs.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs[gracefulQueue]);
+          __require("assert").equal(fs[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+      module.exports = patch(fs);
+      fs.__patched = true;
+    }
+    function patch(fs2) {
+      polyfills(fs2);
+      fs2.gracefulify = patch;
+      fs2.createReadStream = createReadStream;
+      fs2.createWriteStream = createWriteStream;
+      var fs$readFile = fs2.readFile;
+      fs2.readFile = readFile2;
+      function readFile2(path, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path, options, cb);
+        function go$readFile(path2, options2, cb2, startTime) {
+          return fs$readFile(path2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs2.writeFile;
+      fs2.writeFile = writeFile;
+      function writeFile(path, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path, data, options, cb);
+        function go$writeFile(path2, data2, options2, cb2, startTime) {
+          return fs$writeFile(path2, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs2.appendFile;
+      if (fs$appendFile)
+        fs2.appendFile = appendFile;
+      function appendFile(path, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path, data, options, cb);
+        function go$appendFile(path2, data2, options2, cb2, startTime) {
+          return fs$appendFile(path2, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs2.copyFile;
+      if (fs$copyFile)
+        fs2.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs2.readdir;
+      fs2.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path2, options2, cb2, startTime) {
+          return fs$readdir(path2, fs$readdirCallback(
+            path2,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path2, options2, cb2, startTime) {
+          return fs$readdir(path2, options2, fs$readdirCallback(
+            path2,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path, options, cb);
+        function fs$readdirCallback(path2, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path2, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs2);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs2.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs2.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs2, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs2, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs2, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs2, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path, options) {
+        return new fs2.ReadStream(path, options);
+      }
+      function createWriteStream(path, options) {
+        return new fs2.WriteStream(path, options);
+      }
+      var fs$open = fs2.open;
+      fs2.open = open;
+      function open(path, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path, flags, mode, cb);
+        function go$open(path2, flags2, mode2, cb2, startTime) {
+          return fs$open(path2, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs2;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+        if (fs[gracefulQueue][i].length > 2) {
+          fs[gracefulQueue][i][3] = now;
+          fs[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs[gracefulQueue].length === 0)
+        return;
+      var elem = fs[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs[key] === "function";
+    });
+    Object.assign(exports, fs);
+    api.forEach((method) => {
+      exports[method] = u(fs[method]);
+    });
+    exports.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs.exists(filename, resolve);
+      });
+    };
+    exports.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs.realpath.native === "function") {
+      exports.realpath.native = u(fs.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    module.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number")
+        return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs = require_fs();
+    function pathExists(path) {
+      return fs.access(path).then(() => true).catch(() => false);
+    }
+    module.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs.existsSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path, atime, mtime) {
+      const fd = await fs.open(path, "r+");
+      let closeErr = null;
+      try {
+        await fs.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
+    }
+    function utimesMillisSync(path, atime, mtime) {
+      const fd = fs.openSync(path, "r+");
+      fs.futimesSync(fd, atime, mtime);
+      return fs.closeSync(fd);
+    }
+    module.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var path = __require("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT")
+            return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs.statSync(file, { bigint: true }) : (file) => fs.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path.basename(src);
+          const destBaseName = path.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path.basename(src);
+          const destBaseName = path.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src, srcStat, dest, funcName) {
+      const srcParent = path.resolve(path.dirname(src));
+      const destParent = path.resolve(path.dirname(dest));
+      if (destParent === srcParent || destParent === path.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = await fs.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path.resolve(path.dirname(src));
+      const destParent = path.resolve(path.dirname(dest));
+      if (destParent === srcParent || destParent === path.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = fs.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path.resolve(src).split(path.sep).filter((i) => i);
+      const destArr = path.resolve(dest).split(path.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var path = __require("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat2 = require_stat();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat2.checkPaths(src, dest, "copy", opts);
+      await stat2.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include)
+        return;
+      const destParent = path.dirname(dest);
+      const dirExists = await pathExists(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter)
+        return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs.stat : fs.lstat;
+      const srcStat = await statFn(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs.mkdir(dest);
+      }
+      const items = await fs.readdir(src);
+      await Promise.all(items.map(async (item) => {
+        const srcItem = path.join(src, item);
+        const destItem = path.join(dest, item);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (!include)
+          return;
+        const { destStat: destStat2 } = await stat2.checkPaths(srcItem, destItem, "copy", opts);
+        return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+      }));
+      if (!destStat) {
+        await fs.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN")
+          return fs.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path.resolve(process.cwd(), resolvedDest);
+      }
+      if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
+      await fs.unlink(dest);
+      return fs.symlink(resolvedSrc, dest);
+    }
+    module.exports = copy;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
+    "use strict";
+    var fs = require_graceful_fs();
+    var path = __require("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat2 = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
+      }
+      const { srcStat, destStat } = stat2.checkPathsSync(src, dest, "copy", opts);
+      stat2.checkParentPathsSync(src, srcStat, dest, "copy");
+      if (opts.filter && !opts.filter(src, dest))
+        return;
+      const destParent = path.dirname(dest);
+      if (!fs.existsSync(destParent))
+        mkdirsSync(destParent);
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync = opts.dereference ? fs.statSync : fs.lstatSync;
+      const srcStat = statSync(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs.copyFileSync(src, dest);
+      if (opts.preserveTimestamps)
+        handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode))
+        makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path.join(src, item);
+      const destItem = path.join(dest, item);
+      if (opts.filter && !opts.filter(srcItem, destItem))
+        return;
+      const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
+      return getStats(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN")
+            return fs.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs.unlinkSync(dest);
+      return fs.symlinkSync(resolvedSrc, dest);
+    }
+    module.exports = copySync;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
+    "use strict";
+    var fs = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove(path, callback) {
+      fs.rm(path, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path) {
+      fs.rmSync(path, { recursive: true, force: true });
+    }
+    module.exports = {
+      remove: u(remove),
+      removeSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs = require_fs();
+    var path = __require("path");
+    var mkdir = require_mkdirs();
+    var remove = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path = __require("path");
+    var fs = require_fs();
+    var mkdir = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs.writeFile(file, "");
+      } else {
+        await fs.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path.dirname(file);
+      try {
+        if (!fs.statSync(dir).isDirectory()) {
+          fs.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT")
+          mkdir.mkdirsSync(dir);
+        else
+          throw err;
+      }
+      fs.writeFileSync(file, "");
+    }
+    module.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path = __require("path");
+    var fs = require_fs();
+    var mkdir = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs.lstat(dstpath);
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat))
+        return;
+      const dir = path.dirname(dstpath);
+      const dirExists = await pathExists(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat))
+          return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path.dirname(dstpath);
+      const dirExists = fs.existsSync(dir);
+      if (dirExists)
+        return fs.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs.linkSync(srcpath, dstpath);
+    }
+    module.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    var fs = require_fs();
+    var { pathExists } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path.isAbsolute(srcpath)) {
+        try {
+          await fs.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path.dirname(dstpath);
+      const relativeToDst = path.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path.isAbsolute(srcpath)) {
+        const exists2 = fs.existsSync(srcpath);
+        if (!exists2)
+          throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path.dirname(dstpath);
+      const relativeToDst = path.join(dstdir, srcpath);
+      const exists = fs.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs.existsSync(srcpath);
+      if (!srcExists)
+        throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path.relative(dstdir, srcpath)
+      };
+    }
+    module.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = await fs.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = fs.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path = __require("path");
+    var fs = require_fs();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs.stat(srcpath),
+          fs.stat(dstpath)
+        ]);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative.toDst;
+      const toType = await symlinkType(relative.toCwd, type);
+      const dir = path.dirname(dstpath);
+      if (!await pathExists(dir)) {
+        await mkdirs(dir);
+      }
+      return fs.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs.statSync(srcpath);
+        const dstStat = fs.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path.dirname(dstpath);
+      const exists = fs.existsSync(dir);
+      if (exists)
+        return fs.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs.symlinkSync(srcpath, dstpath, type);
+    }
+    module.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
+    "use strict";
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS({
+  "node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module) {
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content))
+        content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module.exports = { stringify, stripBom };
+  }
+});
+
+// node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports, module) {
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = __require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils2();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile2 = universalify.fromPromise(_readFile);
+    function readFileSync2(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs.writeFileSync(file, str, options);
+    }
+    var jsonfile = {
+      readFile: readFile2,
+      readFileSync: readFileSync2,
+      writeFile,
+      writeFileSync
+    };
+    module.exports = jsonfile;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs = require_fs();
+    var path = __require("path");
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path.dirname(file);
+      if (!await pathExists(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path.dirname(file);
+      if (!fs.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs.writeFileSync(file, ...args);
+    }
+    module.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module.exports = outputJson;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module.exports = outputJsonSync;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module.exports = jsonFile;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js"(exports, module) {
+    "use strict";
+    var fs = require_fs();
+    var path = __require("path");
+    var { copy } = require_copy2();
+    var { remove } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var stat2 = require_stat();
+    async function move(src, dest, opts = {}) {
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat2.checkPaths(src, dest, "move", opts);
+      await stat2.checkParentPaths(src, srcStat, dest, "move");
+      const destParent = path.dirname(dest);
+      const parsedParentPath = path.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove(dest);
+        } else if (await pathExists(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove(src);
+    }
+    module.exports = move;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
+    "use strict";
+    var fs = require_graceful_fs();
+    var path = __require("path");
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat2 = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
+      stat2.checkParentPathsSync(src, srcStat, dest, "move");
+      if (!isParentRoot(dest))
+        mkdirpSync(path.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path.dirname(dest);
+      const parsedPath = path.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase)
+        return rename(src, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs.existsSync(dest))
+        throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV")
+          throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module.exports = moveSync;
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
 // node_modules/.pnpm/resolve-from@4.0.0/node_modules/resolve-from/index.js
 var require_resolve_from = __commonJS({
   "node_modules/.pnpm/resolve-from@4.0.0/node_modules/resolve-from/index.js"(exports, module) {
@@ -593,7 +2792,7 @@ var require_keyword = __commonJS({
 });
 
 // node_modules/.pnpm/@babel+helper-validator-identifier@7.22.20/node_modules/@babel/helper-validator-identifier/lib/index.js
-var require_lib = __commonJS({
+var require_lib2 = __commonJS({
   "node_modules/.pnpm/@babel+helper-validator-identifier@7.22.20/node_modules/@babel/helper-validator-identifier/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", {
@@ -975,23 +3174,23 @@ var require_conversions = __commonJS({
       b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
       const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
       const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
-      const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
-      return [x * 100, y * 100, z * 100];
+      const z2 = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z2 * 100];
     };
     convert.rgb.lab = function(rgb) {
       const xyz = convert.rgb.xyz(rgb);
       let x = xyz[0];
       let y = xyz[1];
-      let z = xyz[2];
+      let z2 = xyz[2];
       x /= 95.047;
       y /= 100;
-      z /= 108.883;
+      z2 /= 108.883;
       x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
       y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
-      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;
       const l = 116 * y - 16;
       const a = 500 * (x - y);
-      const b = 200 * (y - z);
+      const b = 200 * (y - z2);
       return [l, a, b];
     };
     convert.hsl.rgb = function(hsl) {
@@ -1155,13 +3354,13 @@ var require_conversions = __commonJS({
     convert.xyz.rgb = function(xyz) {
       const x = xyz[0] / 100;
       const y = xyz[1] / 100;
-      const z = xyz[2] / 100;
+      const z2 = xyz[2] / 100;
       let r;
       let g;
       let b;
-      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
-      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
-      b = x * 0.0557 + y * -0.204 + z * 1.057;
+      r = x * 3.2406 + y * -1.5372 + z2 * -0.4986;
+      g = x * -0.9689 + y * 1.8758 + z2 * 0.0415;
+      b = x * 0.0557 + y * -0.204 + z2 * 1.057;
       r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
       g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
       b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
@@ -1173,16 +3372,16 @@ var require_conversions = __commonJS({
     convert.xyz.lab = function(xyz) {
       let x = xyz[0];
       let y = xyz[1];
-      let z = xyz[2];
+      let z2 = xyz[2];
       x /= 95.047;
       y /= 100;
-      z /= 108.883;
+      z2 /= 108.883;
       x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
       y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
-      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;
       const l = 116 * y - 16;
       const a = 500 * (x - y);
-      const b = 200 * (y - z);
+      const b = 200 * (y - z2);
       return [l, a, b];
     };
     convert.lab.xyz = function(lab) {
@@ -1191,20 +3390,20 @@ var require_conversions = __commonJS({
       const b = lab[2];
       let x;
       let y;
-      let z;
+      let z2;
       y = (l + 16) / 116;
       x = a / 500 + y;
-      z = y - b / 200;
+      z2 = y - b / 200;
       const y2 = y ** 3;
       const x2 = x ** 3;
-      const z2 = z ** 3;
+      const z22 = z2 ** 3;
       y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
       x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
-      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+      z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787;
       x *= 95.047;
       y *= 100;
-      z *= 108.883;
-      return [x, y, z];
+      z2 *= 108.883;
+      return [x, y, z2];
     };
     convert.lab.lch = function(lab) {
       const l = lab[0];
@@ -2200,7 +4399,7 @@ var require_source = __commonJS({
 });
 
 // node_modules/.pnpm/@babel+highlight@7.23.4/node_modules/@babel/highlight/lib/index.js
-var require_lib2 = __commonJS({
+var require_lib3 = __commonJS({
   "node_modules/.pnpm/@babel+highlight@7.23.4/node_modules/@babel/highlight/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", {
@@ -2209,7 +4408,7 @@ var require_lib2 = __commonJS({
     exports.default = highlight;
     exports.shouldHighlight = shouldHighlight;
     var _jsTokens = require_js_tokens();
-    var _helperValidatorIdentifier = require_lib();
+    var _helperValidatorIdentifier = require_lib2();
     var _chalk = _interopRequireWildcard(require_source(), true);
     function _getRequireWildcardCache(e) {
       if ("function" != typeof WeakMap)
@@ -2330,7 +4529,7 @@ var require_lib2 = __commonJS({
 });
 
 // node_modules/.pnpm/@babel+code-frame@7.23.5/node_modules/@babel/code-frame/lib/index.js
-var require_lib3 = __commonJS({
+var require_lib4 = __commonJS({
   "node_modules/.pnpm/@babel+code-frame@7.23.5/node_modules/@babel/code-frame/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", {
@@ -2338,7 +4537,7 @@ var require_lib3 = __commonJS({
     });
     exports.codeFrameColumns = codeFrameColumns;
     exports.default = _default;
-    var _highlight = require_lib2();
+    var _highlight = require_lib3();
     var _chalk = _interopRequireWildcard(require_source(), true);
     function _getRequireWildcardCache(e) {
       if ("function" != typeof WeakMap)
@@ -2519,7 +4718,7 @@ var require_parse_json = __commonJS({
     var errorEx = require_error_ex();
     var fallback = require_json_parse_even_better_errors();
     var { default: LinesAndColumns } = require_build();
-    var { codeFrameColumns } = require_lib3();
+    var { codeFrameColumns } = require_lib4();
     var JSONError = errorEx("JSONError", {
       fileName: errorEx.append("in %s"),
       codeFrame: errorEx.append("\n\n%s\n")
@@ -3253,7 +5452,7 @@ var require_float = __commonJS({
 });
 
 // node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/lib/schema/json.js
-var require_json = __commonJS({
+var require_json2 = __commonJS({
   "node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/lib/schema/json.js"(exports, module) {
     "use strict";
     module.exports = require_failsafe().extend({
@@ -3271,7 +5470,7 @@ var require_json = __commonJS({
 var require_core = __commonJS({
   "node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/lib/schema/core.js"(exports, module) {
     "use strict";
-    module.exports = require_json();
+    module.exports = require_json2();
   }
 });
 
@@ -5400,7 +7599,7 @@ var require_js_yaml = __commonJS({
     module.exports.Type = require_type();
     module.exports.Schema = require_schema();
     module.exports.FAILSAFE_SCHEMA = require_failsafe();
-    module.exports.JSON_SCHEMA = require_json();
+    module.exports.JSON_SCHEMA = require_json2();
     module.exports.CORE_SCHEMA = require_core();
     module.exports.DEFAULT_SCHEMA = require_default();
     module.exports.load = loader.load;
@@ -5611,7 +7810,7 @@ var require_util2 = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join3(aRoot, aPath) {
+    function join4(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -5643,7 +7842,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports.join = join3;
+    exports.join = join4;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -5816,7 +8015,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join3(urlGenerate(parsed), sourceURL);
+        sourceURL = join4(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -14131,7 +16330,7 @@ ${lanes.join("\n")}
                 writeOutputIsTTY() {
                   return process.stdout.isTTY;
                 },
-                readFile,
+                readFile: readFile2,
                 writeFile: writeFile2,
                 watchFile: watchFile2,
                 watchDirectory,
@@ -14171,9 +16370,9 @@ ${lanes.join("\n")}
                 },
                 getFileSize(path) {
                   try {
-                    const stat = statSync(path);
-                    if (stat == null ? void 0 : stat.isFile()) {
-                      return stat.size;
+                    const stat2 = statSync(path);
+                    if (stat2 == null ? void 0 : stat2.isFile()) {
+                      return stat2.size;
                     }
                   } catch {
                   }
@@ -14366,7 +16565,7 @@ ${lanes.join("\n")}
                 }
                 return buffer.toString("utf8");
               }
-              function readFile(fileName, _encoding) {
+              function readFile2(fileName, _encoding) {
                 var _a, _b;
                 (_a = perfLogger) == null ? void 0 : _a.logStartReadFile(fileName);
                 const file = readFileWorker(fileName, _encoding);
@@ -14407,23 +16606,23 @@ ${lanes.join("\n")}
                     if (entry === "." || entry === "..") {
                       continue;
                     }
-                    let stat;
+                    let stat2;
                     if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                       const name = combinePaths(path, entry);
                       try {
-                        stat = statSync(name);
-                        if (!stat) {
+                        stat2 = statSync(name);
+                        if (!stat2) {
                           continue;
                         }
                       } catch (e) {
                         continue;
                       }
                     } else {
-                      stat = dirent;
+                      stat2 = dirent;
                     }
-                    if (stat.isFile()) {
+                    if (stat2.isFile()) {
                       files.push(entry);
-                    } else if (stat.isDirectory()) {
+                    } else if (stat2.isDirectory()) {
                       directories.push(entry);
                     }
                   }
@@ -14441,15 +16640,15 @@ ${lanes.join("\n")}
                 const originalStackTraceLimit = Error.stackTraceLimit;
                 Error.stackTraceLimit = 0;
                 try {
-                  const stat = statSync(path);
-                  if (!stat) {
+                  const stat2 = statSync(path);
+                  if (!stat2) {
                     return false;
                   }
                   switch (entryKind) {
                     case 0:
-                      return stat.isFile();
+                      return stat2.isFile();
                     case 1:
-                      return stat.isDirectory();
+                      return stat2.isDirectory();
                     default:
                       return false;
                   }
@@ -46754,7 +48953,7 @@ ${lanes.join("\n")}
         const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
         return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
       }
-      function parseCommandLineWorker(diagnostics, commandLine, readFile) {
+      function parseCommandLineWorker(diagnostics, commandLine, readFile2) {
         const options = {};
         let watchOptions;
         const fileNames = [];
@@ -46802,7 +49001,7 @@ ${lanes.join("\n")}
           }
         }
         function parseResponseFile(fileName) {
-          const text = tryReadFile(fileName, readFile || ((fileName2) => sys.readFile(fileName2)));
+          const text = tryReadFile(fileName, readFile2 || ((fileName2) => sys.readFile(fileName2)));
           if (!isString(text)) {
             errors.push(text);
             return;
@@ -46902,8 +49101,8 @@ ${lanes.join("\n")}
         }
         return i;
       }
-      function parseCommandLine(commandLine, readFile) {
-        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
+      function parseCommandLine(commandLine, readFile2) {
+        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile2);
       }
       function getOptionFromName(optionName, allowShort) {
         return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -46972,8 +49171,8 @@ ${lanes.join("\n")}
           watchOptionsToExtend
         );
       }
-      function readConfigFile(fileName, readFile) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile);
+      function readConfigFile(fileName, readFile2) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile2);
         return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
       }
       function parseConfigFileTextToJson(fileName, jsonText) {
@@ -46988,14 +49187,14 @@ ${lanes.join("\n")}
           error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
         };
       }
-      function readJsonConfigFile(fileName, readFile) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile);
+      function readJsonConfigFile(fileName, readFile2) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile2);
         return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
       }
-      function tryReadFile(fileName, readFile) {
+      function tryReadFile(fileName, readFile2) {
         let text;
         try {
-          text = readFile(fileName);
+          text = readFile2(fileName);
         } catch (e) {
           return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
         }
@@ -134870,12 +137069,12 @@ ${lanes.join("\n")}
       function createCompilerHost(options, setParentNodes) {
         return createCompilerHostWorker(options, setParentNodes);
       }
-      function createGetSourceFile(readFile, getCompilerOptions, setParentNodes) {
+      function createGetSourceFile(readFile2, getCompilerOptions, setParentNodes) {
         return (fileName, languageVersionOrOptions, onError) => {
           let text;
           try {
             mark("beforeIORead");
-            text = readFile(fileName, getCompilerOptions().charset);
+            text = readFile2(fileName, getCompilerOptions().charset);
             mark("afterIORead");
             measure("I/O Read", "beforeIORead", "afterIORead");
           } catch (e) {
@@ -135690,7 +137889,7 @@ ${lanes.join("\n")}
           getSourceOfProjectReferenceRedirect,
           forEachResolvedProjectReference: forEachResolvedProjectReference2
         });
-        const readFile = host.readFile.bind(host);
+        const readFile2 = host.readFile.bind(host);
         (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
         (_f = tracing) == null ? void 0 : _f.pop();
@@ -135907,7 +138106,7 @@ ${lanes.join("\n")}
           isSourceOfProjectReferenceRedirect,
           emitBuildInfo,
           fileExists,
-          readFile,
+          readFile: readFile2,
           directoryExists,
           getSymlinkCache,
           realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
@@ -138784,7 +140983,7 @@ ${lanes.join("\n")}
           trace: host.trace ? (s) => host.trace(s) : void 0
         };
       }
-      function createPrependNodes(projectReferences, getCommandLine, readFile, host) {
+      function createPrependNodes(projectReferences, getCommandLine, readFile2, host) {
         if (!projectReferences)
           return emptyArray;
         let nodes;
@@ -138800,7 +140999,7 @@ ${lanes.join("\n")}
               /*forceDtsPaths*/
               true
             );
-            const node = createInputFilesWithFilePaths(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
+            const node = createInputFilesWithFilePaths(readFile2, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
             (nodes || (nodes = [])).push(node);
           }
         }
@@ -208105,19 +210304,18 @@ ${e.message}`;
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/loaders.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/loaders.js
 var require_loaders = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/loaders.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/loaders.js"(exports) {
     "use strict";
     var __importDefault = exports && exports.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadTs = exports.loadTsSync = exports.loadYaml = exports.loadJson = exports.loadJs = exports.loadJsSync = void 0;
-    var fs_1 = __require("fs");
-    var promises_1 = __require("fs/promises");
-    var path_1 = __importDefault(__require("path"));
-    var url_1 = __require("url");
+    var fse = require_lib();
+    var path_1 = __importDefault(__require("node:path"));
+    var url_1 = __require("node:url");
     var importFresh;
     var loadJsSync = function loadJsSync2(filepath) {
       if (importFresh === void 0) {
@@ -208134,7 +210332,7 @@ var require_loaders = __commonJS({
         try {
           return (0, exports.loadJsSync)(filepath, "");
         } catch (requireError) {
-          if (requireError.code === "ERR_REQUIRE_ESM" || requireError instanceof SyntaxError && requireError.toString().includes("Cannot use import statement outside a module")) {
+          if (requireError.code === "ERRrequire_ESM" || requireError instanceof SyntaxError && requireError.toString().includes("Cannot use import statement outside a module")) {
             throw error;
           }
           throw requireError;
@@ -208186,15 +210384,15 @@ ${error.message}`;
           noEmit: false
         };
         content = typescript.transpileModule(content, config).outputText;
-        (0, fs_1.writeFileSync)(compiledFilepath, content);
+        (0, fse.writeFileSync)(compiledFilepath, content);
         return (0, exports.loadJsSync)(compiledFilepath, content).default;
       } catch (error) {
         error.message = `TypeScript Error in ${filepath}:
 ${error.message}`;
         throw error;
       } finally {
-        if ((0, fs_1.existsSync)(compiledFilepath)) {
-          (0, fs_1.rmSync)(compiledFilepath);
+        if ((0, fse.pathExistsSync)(compiledFilepath)) {
+          (0, fse.removeSync)(compiledFilepath);
         }
       }
     };
@@ -208216,7 +210414,7 @@ ${error.message}`;
             noEmit: false
           };
           transpiledContent = typescript.transpileModule(content, config).outputText;
-          await (0, promises_1.writeFile)(compiledFilepath, transpiledContent);
+          await (0, fse.writeFile)(compiledFilepath, transpiledContent);
         } catch (error) {
           error.message = `TypeScript Error in ${filepath}:
 ${error.message}`;
@@ -208224,8 +210422,8 @@ ${error.message}`;
         }
         return await (0, exports.loadJs)(compiledFilepath, transpiledContent);
       } finally {
-        if ((0, fs_1.existsSync)(compiledFilepath)) {
-          await (0, promises_1.rm)(compiledFilepath);
+        if ((0, fse.pathExistsSync)(compiledFilepath)) {
+          await (0, fse.remove)(compiledFilepath);
         }
       }
     };
@@ -208246,9 +210444,9 @@ ${error.message}`;
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/defaults.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/defaults.js
 var require_defaults = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/defaults.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/defaults.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.defaultLoadersSync = exports.defaultLoaders = exports.metaSearchPlaces = exports.globalConfigSearchPlacesSync = exports.globalConfigSearchPlaces = exports.getDefaultSearchPlacesSync = exports.getDefaultSearchPlaces = void 0;
@@ -208417,9 +210615,9 @@ var require_env_paths = __commonJS({
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/util.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/util.js
 var require_util3 = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/util.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/util.js"(exports) {
     "use strict";
     var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
       if (k2 === void 0)
@@ -208485,8 +210683,8 @@ var require_util3 = __commonJS({
     exports.removeUndefinedValuesFromObject = removeUndefinedValuesFromObject;
     async function isDirectory(path) {
       try {
-        const stat = await fs_1.promises.stat(path);
-        return stat.isDirectory();
+        const stat2 = await fs_1.promises.stat(path);
+        return stat2.isDirectory();
       } catch (e) {
         if (e.code === "ENOENT") {
           return false;
@@ -208497,8 +210695,8 @@ var require_util3 = __commonJS({
     exports.isDirectory = isDirectory;
     function isDirectorySync(path) {
       try {
-        const stat = fs_1.default.statSync(path);
-        return stat.isDirectory();
+        const stat2 = fs_1.default.statSync(path);
+        return stat2.isDirectory();
       } catch (e) {
         if (e.code === "ENOENT") {
           return false;
@@ -208510,9 +210708,9 @@ var require_util3 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerBase.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerBase.js
 var require_ExplorerBase = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerBase.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerBase.js"(exports) {
     "use strict";
     var __importDefault = exports && exports.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -208628,9 +210826,9 @@ ${[...importStack, fullPath].map((path, i) => `${i + 1}. ${path}`).join("\n")} (
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/merge.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/merge.js
 var require_merge2 = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/merge.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/merge.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.mergeAll = exports.hasOwn = void 0;
@@ -208664,9 +210862,9 @@ var require_merge2 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/Explorer.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/Explorer.js
 var require_Explorer = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/Explorer.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/Explorer.js"(exports) {
     "use strict";
     var __importDefault = exports && exports.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -208822,9 +211020,9 @@ var require_Explorer = __commonJS({
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerSync.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerSync.js
 var require_ExplorerSync = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerSync.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/ExplorerSync.js"(exports) {
     "use strict";
     var __importDefault = exports && exports.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -208994,9 +211192,9 @@ var require_ExplorerSync = __commonJS({
   }
 });
 
-// node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/index.js
+// node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/index.js
 var require_dist = __commonJS({
-  "node_modules/.pnpm/cosmiconfig@9.0.0_typescript@5.3.3/node_modules/cosmiconfig/dist/index.js"(exports) {
+  "node_modules/.pnpm/cosmiconfig@9.0.0_patch_hash=kvwqsvntptc5dck76ulq454vwi_typescript@5.3.3/node_modules/cosmiconfig/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.defaultLoadersSync = exports.defaultLoaders = exports.globalConfigSearchPlacesSync = exports.globalConfigSearchPlaces = exports.getDefaultSearchPlacesSync = exports.getDefaultSearchPlaces = exports.cosmiconfigSync = exports.cosmiconfig = void 0;
@@ -209158,39 +211356,7 @@ var require_dist = __commonJS({
 });
 
 // packages/config-tools/src/config-file/get-config-file.ts
-var _static_cache = void 0;
-var getConfigFileByName = async (fileName, filePath) => {
-  const cosmiconfig = await Promise.resolve().then(() => __toESM(require_dist(), 1));
-  return cosmiconfig?.cosmiconfig?.(fileName, { cache: true }).search(filePath);
-};
-var getConfigFile = async (filePath) => {
-  if (_static_cache) {
-    return _static_cache;
-  }
-  let cosmiconfigResult = await getConfigFileByName("storm", filePath);
-  if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
-    cosmiconfigResult = await getConfigFileByName("storm-software", filePath);
-    if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
-      cosmiconfigResult = await getConfigFileByName("storm-stack", filePath);
-      if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
-        cosmiconfigResult = await getConfigFileByName("storm-cloud", filePath);
-      }
-    }
-  }
-  if (!cosmiconfigResult || Object.keys(cosmiconfigResult).length === 0 || cosmiconfigResult.isEmpty || !cosmiconfigResult.filepath) {
-    return void 0;
-  }
-  const config = cosmiconfigResult.config ?? {};
-  if (cosmiconfigResult.filepath) {
-    config.configFile = cosmiconfigResult.filepath;
-  }
-  config.runtimeVersion = "0.0.1";
-  _static_cache = config;
-  return config;
-};
-
-// packages/config-tools/src/config-file/define-config.ts
-var defineConfig = (input) => input;
+import { join as join2 } from "node:path";
 
 // packages/config-tools/src/utilities/find-up.ts
 import { existsSync } from "node:fs";
@@ -209261,9 +211427,74 @@ Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
   return result;
 }
 
+// packages/config-tools/src/config-file/get-config-file.ts
+import { readFile, stat } from "node:fs/promises";
+var _cosmiconfig = void 0;
+var defaultExplorer;
+var getConfigFileExplorer = async (fileName) => {
+  if (!_cosmiconfig) {
+    const mod = await Promise.resolve().then(() => __toESM(require_dist(), 1));
+    if (mod?.cosmiconfig) {
+      _cosmiconfig = mod.cosmiconfig;
+    }
+    if (!_cosmiconfig) {
+      return void 0;
+    }
+  }
+  return _cosmiconfig(fileName, { cache: true });
+};
+var getConfigFileByName = async (fileName, filePath) => {
+  return (await getConfigFileExplorer(fileName))?.search(filePath);
+};
+var getJsonConfigFile = async (fileName, filePath) => {
+  const jsonPath = join2(
+    filePath ?? process.cwd(),
+    fileName.endsWith(".json") ? fileName : `${fileName}.json`
+  );
+  const isEmpty = !!await stat(jsonPath).catch((_) => false);
+  return isEmpty ? {
+    config: JSON.parse(await readFile(jsonPath, "utf-8")),
+    filepath: jsonPath,
+    isEmpty
+  } : { config: {}, filepath: jsonPath, isEmpty };
+};
+var getConfigFile = async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : findWorkspaceRootSafe(filePath);
+  let cosmiconfigResult = await getJsonConfigFile("storm", workspacePath);
+  if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+    if (!defaultExplorer) {
+      defaultExplorer = await getConfigFileExplorer("storm");
+    }
+    if (defaultExplorer) {
+      cosmiconfigResult = await defaultExplorer.search(workspacePath);
+    }
+    if ((!cosmiconfigResult || cosmiconfigResult.isEmpty) && additionalFileNames.length > 0) {
+      for (const additionalFileName of additionalFileNames) {
+        cosmiconfigResult = await getJsonConfigFile(additionalFileName, workspacePath);
+        if (cosmiconfigResult && !cosmiconfigResult.isEmpty) {
+          break;
+        }
+        cosmiconfigResult = await getConfigFileByName(additionalFileName, workspacePath);
+        if (cosmiconfigResult && !cosmiconfigResult.isEmpty) {
+          break;
+        }
+      }
+    }
+  }
+  if (!cosmiconfigResult || Object.keys(cosmiconfigResult).length === 0 || cosmiconfigResult.isEmpty || !cosmiconfigResult.filepath) {
+    return void 0;
+  }
+  const config = cosmiconfigResult.config ?? {};
+  if (cosmiconfigResult.filepath) {
+    config.configFile = cosmiconfigResult.filepath;
+  }
+  config.runtimeVersion = "0.0.1";
+  return config;
+};
+
 // packages/config-tools/src/utilities/get-default-config.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
 var util;
@@ -209415,6 +211646,10 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
+var quotelessJson = (obj) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+};
 var ZodError = class extends Error {
   constructor(issues) {
     super();
@@ -209602,6 +211837,9 @@ var errorMap = (issue, _ctx) => {
   return { message };
 };
 var overrideErrorMap = errorMap;
+function setErrorMap(map) {
+  overrideErrorMap = map;
+}
 function getErrorMap() {
   return overrideErrorMap;
 }
@@ -209623,6 +211861,7 @@ var makeIssue = (params) => {
     message: issueData.message || errorMessage
   };
 };
+var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
   const issue = makeIssue({
     issueData,
@@ -212768,6 +215007,19 @@ ZodReadonly.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
+var custom = (check, params = {}, fatal) => {
+  if (check)
+    return ZodAny.create().superRefine((data, ctx) => {
+      var _a, _b;
+      if (!check(data)) {
+        const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+        const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
+        const p2 = typeof p === "string" ? { message: p } : p;
+        ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
+      }
+    });
+  return ZodAny.create();
+};
 var late = {
   object: ZodObject.lazycreate
 };
@@ -212810,6 +215062,9 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
   ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params);
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
 var nanType = ZodNaN.create;
@@ -212844,57 +215099,187 @@ var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
+var coerce = {
+  string: (arg) => ZodString.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  }),
+  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+};
+var NEVER = INVALID;
+var z = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  defaultErrorMap: errorMap,
+  setErrorMap,
+  getErrorMap,
+  makeIssue,
+  EMPTY_PATH,
+  addIssueToContext,
+  ParseStatus,
+  INVALID,
+  DIRTY,
+  OK,
+  isAborted,
+  isDirty,
+  isValid,
+  isAsync,
+  get util() {
+    return util;
+  },
+  get objectUtil() {
+    return objectUtil;
+  },
+  ZodParsedType,
+  getParsedType,
+  ZodType,
+  ZodString,
+  ZodNumber,
+  ZodBigInt,
+  ZodBoolean,
+  ZodDate,
+  ZodSymbol,
+  ZodUndefined,
+  ZodNull,
+  ZodAny,
+  ZodUnknown,
+  ZodNever,
+  ZodVoid,
+  ZodArray,
+  ZodObject,
+  ZodUnion,
+  ZodDiscriminatedUnion,
+  ZodIntersection,
+  ZodTuple,
+  ZodRecord,
+  ZodMap,
+  ZodSet,
+  ZodFunction,
+  ZodLazy,
+  ZodLiteral,
+  ZodEnum,
+  ZodNativeEnum,
+  ZodPromise,
+  ZodEffects,
+  ZodTransformer: ZodEffects,
+  ZodOptional,
+  ZodNullable,
+  ZodDefault,
+  ZodCatch,
+  ZodNaN,
+  BRAND,
+  ZodBranded,
+  ZodPipeline,
+  ZodReadonly,
+  custom,
+  Schema: ZodType,
+  ZodSchema: ZodType,
+  late,
+  get ZodFirstPartyTypeKind() {
+    return ZodFirstPartyTypeKind;
+  },
+  coerce,
+  any: anyType,
+  array: arrayType,
+  bigint: bigIntType,
+  boolean: booleanType,
+  date: dateType,
+  discriminatedUnion: discriminatedUnionType,
+  effect: effectsType,
+  "enum": enumType,
+  "function": functionType,
+  "instanceof": instanceOfType,
+  intersection: intersectionType,
+  lazy: lazyType,
+  literal: literalType,
+  map: mapType,
+  nan: nanType,
+  nativeEnum: nativeEnumType,
+  never: neverType,
+  "null": nullType,
+  nullable: nullableType,
+  number: numberType,
+  object: objectType,
+  oboolean,
+  onumber,
+  optional: optionalType,
+  ostring,
+  pipeline: pipelineType,
+  preprocess: preprocessType,
+  promise: promiseType,
+  record: recordType,
+  set: setType,
+  strictObject: strictObjectType,
+  string: stringType,
+  symbol: symbolType,
+  transformer: effectsType,
+  tuple: tupleType,
+  "undefined": undefinedType,
+  union: unionType,
+  unknown: unknownType,
+  "void": voidType,
+  NEVER,
+  ZodIssueCode,
+  quotelessJson,
+  ZodError
+});
 
 // packages/config/src/schema.ts
-var ColorConfigSchema = objectType({
-  primary: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The primary color of the workspace"),
-  background: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d232a").describe("The background color of the workspace"),
-  success: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#087f5b").describe("The success color of the workspace"),
-  info: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The informational color of the workspace"),
-  warning: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace"),
-  error: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#990000").describe("The error color of the workspace"),
-  fatal: stringType().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#7d1a1a").describe("The fatal color of the workspace")
+var ColorConfigSchema = z.object({
+  primary: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The primary color of the workspace"),
+  background: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d232a").describe("The background color of the workspace"),
+  success: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#087f5b").describe("The success color of the workspace"),
+  info: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0ea5e9").describe("The informational color of the workspace"),
+  warning: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace"),
+  error: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#990000").describe("The error color of the workspace"),
+  fatal: z.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#7d1a1a").describe("The fatal color of the workspace")
 }).describe("Colors used for various workspace elements");
-var StormConfigSchema = objectType({
-  name: stringType().trim().toLowerCase().optional().describe("The name of the package"),
-  namespace: stringType().trim().toLowerCase().optional().describe("The namespace of the package"),
-  organization: stringType().trim().default("storm-software").describe("The organization of the workspace"),
-  repository: stringType().trim().url().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
-  license: stringType().trim().default("Apache License 2.0").describe("The root directory of the package"),
-  homepage: stringType().trim().url().default("https://stormsoftware.org").describe("The homepage of the workspace"),
-  branch: stringType().trim().default("main").describe("The branch of the workspace"),
-  preid: stringType().optional().describe("A tag specifying the version pre-release identifier"),
-  owner: stringType().trim().default("@storm-software/development").describe("The owner of the package"),
-  worker: stringType().trim().default("stormie-bot").describe(
+var StormConfigSchema = z.object({
+  extends: z.string().trim().optional().describe("The path to a base JSON file to use as a configuration preset file"),
+  name: z.string().trim().toLowerCase().optional().describe("The name of the package"),
+  namespace: z.string().trim().toLowerCase().optional().describe("The namespace of the package"),
+  organization: z.string().trim().default("storm-software").describe("The organization of the workspace"),
+  repository: z.string().trim().url().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
+  license: z.string().trim().default("Apache License 2.0").describe("The root directory of the package"),
+  homepage: z.string().trim().url().default("https://stormsoftware.org").describe("The homepage of the workspace"),
+  branch: z.string().trim().default("main").describe("The branch of the workspace"),
+  preid: z.string().optional().describe("A tag specifying the version pre-release identifier"),
+  owner: z.string().trim().default("@storm-software/development").describe("The owner of the package"),
+  worker: z.string().trim().default("Stormie-Bot").describe(
     "The worker of the package (this is the bot that will be used to perform various tasks)"
   ),
-  env: enumType(["development", "staging", "production"]).default("production").describe("The current runtime environment of the package"),
-  ci: booleanType().default(true).describe("An indicator specifying if the current environment is a CI environment"),
-  workspaceRoot: stringType().trim().optional().describe("The root directory of the workspace"),
-  packageDirectory: stringType().trim().optional().describe("The root directory of the package"),
-  externalPackagePatterns: arrayType(stringType()).default([]).describe(
+  env: z.enum(["development", "staging", "production"]).default("production").describe("The current runtime environment of the package"),
+  ci: z.boolean().default(true).describe("An indicator specifying if the current environment is a CI environment"),
+  workspaceRoot: z.string().trim().optional().describe("The root directory of the workspace"),
+  packageDirectory: z.string().trim().optional().describe("The root directory of the package"),
+  externalPackagePatterns: z.array(z.string()).default([]).describe(
     "The build will use these package patterns to determine if they should be external to the bundle"
   ),
-  skipCache: booleanType().default(false).describe("Should all known types of workspace caching be skipped?"),
-  cacheDirectory: stringType().trim().default("node_modules/.cache/storm").describe("The directory used to store the workspace's cached file data"),
-  buildDirectory: stringType().trim().default("dist").describe("The build directory for the workspace"),
-  runtimeDirectory: stringType().trim().default("node_modules/.storm").describe("The runtime directory of Storm"),
-  runtimeVersion: stringType().trim().regex(
+  skipCache: z.boolean().default(false).describe("Should all known types of workspace caching be skipped?"),
+  cacheDirectory: z.string().trim().default("node_modules/.cache/storm").describe("The directory used to store the workspace's cached file data"),
+  buildDirectory: z.string().trim().default("dist").describe("The build directory for the workspace"),
+  runtimeDirectory: z.string().trim().default("node_modules/.storm").describe("The runtime directory of Storm"),
+  runtimeVersion: z.string().trim().regex(
     /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
   ).default("1.0.0").describe("The global version of the Storm runtime"),
-  packageManager: enumType(["npm", "yarn", "pnpm", "bun"]).default("npm").describe("The package manager used by the repository"),
-  timezone: stringType().trim().default("America/New_York").describe("The default timezone of the workspace"),
-  locale: stringType().trim().default("en-US").describe("The default locale of the workspace"),
-  logLevel: enumType(["silent", "fatal", "error", "warn", "info", "debug", "trace", "all"]).default("debug").describe(
+  packageManager: z.enum(["npm", "yarn", "pnpm", "bun"]).default("npm").describe("The package manager used by the repository"),
+  timezone: z.string().trim().default("America/New_York").describe("The default timezone of the workspace"),
+  locale: z.string().trim().default("en-US").describe("The default locale of the workspace"),
+  logLevel: z.enum(["silent", "fatal", "error", "warn", "info", "debug", "trace", "all"]).default("debug").describe(
     "The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."
   ),
-  configFile: stringType().trim().nullable().default(null).describe(
+  configFile: z.string().trim().nullable().default(null).describe(
     "The filepath of the Storm config. When this field is null, no config file was found in the current workspace."
   ),
   colors: ColorConfigSchema.describe(
     "Storm theme config values used for styling various package elements"
   ),
-  extensions: recordType(anyType()).optional().default({}).describe("Configuration of each used extension")
+  extensions: z.record(z.any()).optional().default({}).describe("Configuration of each used extension")
 }).describe(
   "Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo."
 );
@@ -212938,8 +215323,8 @@ var getDefaultConfig = (config = {}, root) => {
   let license = DEFAULT_STORM_CONFIG.license;
   let homepage = DEFAULT_STORM_CONFIG.homepage;
   const workspaceRoot = findWorkspaceRoot(root);
-  if (existsSync2(join2(workspaceRoot, "package.json"))) {
-    const file = readFileSync(join2(workspaceRoot, "package.json"), {
+  if (existsSync2(join3(workspaceRoot, "package.json"))) {
+    const file = readFileSync(join3(workspaceRoot, "package.json"), {
       encoding: "utf-8"
     });
     if (file) {
@@ -213072,7 +215457,8 @@ var getLogFn = (config = {}, logLevel = LogLevel.INFO) => {
   if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright) {
     _chalk = chalkDefault;
   }
-  if (typeof logLevel === "number" && (logLevel >= getLogLevel(config.logLevel ?? process.env?.STORM_LOG_LEVEL) || logLevel <= LogLevel.SILENT) || typeof logLevel === "string" && getLogLevel(logLevel) >= getLogLevel(config.logLevel ?? process.env?.STORM_LOG_LEVEL)) {
+  const configLogLevel = config.logLevel ?? process.env?.STORM_LOG_LEVEL ?? LogLevelLabel.INFO;
+  if (typeof logLevel === "number" && (logLevel >= getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT) || typeof logLevel === "string" && getLogLevel(logLevel) >= getLogLevel(configLogLevel)) {
     return (_) => {
     };
   }
@@ -213222,7 +215608,7 @@ Stacktrace: ${error.stack}`
 // packages/config-tools/src/utilities/run.ts
 import { execSync } from "node:child_process";
 var LARGE_BUFFER = 1024 * 1e6;
-var run = (config, command, cwd = config.workspaceRoot) => {
+var run = (config, command, cwd = config.workspaceRoot ?? process.cwd()) => {
   return execSync(command, {
     cwd,
     env: {
@@ -213239,9 +215625,7 @@ var run = (config, command, cwd = config.workspaceRoot) => {
 var getExtensionEnv = (extensionName) => {
   const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
   return Object.keys(process.env).filter((key) => key.startsWith(prefix)).reduce((ret, key) => {
-    const name = key.replace(prefix, "").split("_").map(
-      (i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""
-    ).join("");
+    const name = key.replace(prefix, "").split("_").map((i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : "").join("");
     if (name) {
       ret[name] = process.env[key];
     }
@@ -213251,6 +215635,7 @@ var getExtensionEnv = (extensionName) => {
 var getConfigEnv = () => {
   const prefix = "STORM_";
   let config = {
+    extends: process.env[`${prefix}EXTENDS`],
     name: process.env[`${prefix}NAME`],
     namespace: process.env[`${prefix}NAMESPACE`],
     owner: process.env[`${prefix}OWNER`],
@@ -213285,9 +215670,7 @@ var getConfigEnv = () => {
     repository: process.env[`${prefix}REPOSITORY`],
     branch: process.env[`${prefix}BRANCH`],
     preid: process.env[`${prefix}PRE_ID`],
-    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? Number.isSafeInteger(
-      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
-    ) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0
+    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0
   };
   const serializedConfig = process.env[`${prefix}CONFIG`];
   if (serializedConfig) {
@@ -213327,6 +215710,9 @@ var setExtensionEnv = (extensionName, extension) => {
 };
 var setConfigEnv = (config) => {
   const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = config.extends;
+  }
   if (config.name) {
     process.env[`${prefix}NAME`] = config.name;
   }
@@ -213448,13 +215834,13 @@ var setConfigEnv = (config) => {
 
 // packages/config-tools/src/create-storm-config.ts
 var _extension_cache = /* @__PURE__ */ new WeakMap();
-var _static_cache2 = void 0;
+var _static_cache = void 0;
 var createConfig = (workspaceRoot) => {
   return createStormConfig(void 0, void 0, workspaceRoot);
 };
 var createStormConfig = (extensionName, schema, workspaceRoot) => {
   let result;
-  if (!_static_cache2) {
+  if (!_static_cache) {
     const config = getConfigEnv();
     const defaultConfig = getDefaultConfig(config, workspaceRoot);
     result = StormConfigSchema.parse({
@@ -213466,7 +215852,7 @@ var createStormConfig = (extensionName, schema, workspaceRoot) => {
       }
     });
   } else {
-    result = _static_cache2;
+    result = _static_cache;
   }
   if (schema && extensionName) {
     result.extensions = {
@@ -213477,7 +215863,7 @@ var createStormConfig = (extensionName, schema, workspaceRoot) => {
       )
     };
   }
-  _static_cache2 = result;
+  _static_cache = result;
   return result;
 };
 var createConfigExtension = (extensionName, schema) => {
@@ -213526,7 +215912,6 @@ export {
   createConfig,
   createConfigExtension,
   createStormConfig,
-  defineConfig,
   exitWithError,
   exitWithSuccess,
   findWorkspaceRoot,
@@ -213534,8 +215919,10 @@ export {
   getConfigEnv,
   getConfigFile,
   getConfigFileByName,
+  getConfigFileExplorer,
   getDefaultConfig,
   getExtensionEnv,
+  getJsonConfigFile,
   getLogFn,
   getLogLevel,
   getLogLevelLabel,