@vercel/introspection 0.0.7 → 0.0.8

package/dist/loaders/cjs.cjs

@@ -287,7 +287,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				this.head = this.tail = null;
 				this.length = 0;
 			};
-			BufferList.prototype.join = function join4(s) {
+			BufferList.prototype.join = function join5(s) {
 				if (this.length === 0) return "";
 				var p = this.head;
 				var ret = "" + p.data;
@@ -2009,47 +2009,47 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 		var chdir;
 		module2.exports = patch;
-		function patch(fs6) {
-			if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs6);
-			if (!fs6.lutimes) patchLutimes(fs6);
-			fs6.chown = chownFix(fs6.chown);
-			fs6.fchown = chownFix(fs6.fchown);
-			fs6.lchown = chownFix(fs6.lchown);
-			fs6.chmod = chmodFix(fs6.chmod);
-			fs6.fchmod = chmodFix(fs6.fchmod);
-			fs6.lchmod = chmodFix(fs6.lchmod);
-			fs6.chownSync = chownFixSync(fs6.chownSync);
-			fs6.fchownSync = chownFixSync(fs6.fchownSync);
-			fs6.lchownSync = chownFixSync(fs6.lchownSync);
-			fs6.chmodSync = chmodFixSync(fs6.chmodSync);
-			fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
-			fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
-			fs6.stat = statFix(fs6.stat);
-			fs6.fstat = statFix(fs6.fstat);
-			fs6.lstat = statFix(fs6.lstat);
-			fs6.statSync = statFixSync(fs6.statSync);
-			fs6.fstatSync = statFixSync(fs6.fstatSync);
-			fs6.lstatSync = statFixSync(fs6.lstatSync);
-			if (fs6.chmod && !fs6.lchmod) {
-				fs6.lchmod = function(path7, mode, cb) {
+		function patch(fs7) {
+			if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs7);
+			if (!fs7.lutimes) patchLutimes(fs7);
+			fs7.chown = chownFix(fs7.chown);
+			fs7.fchown = chownFix(fs7.fchown);
+			fs7.lchown = chownFix(fs7.lchown);
+			fs7.chmod = chmodFix(fs7.chmod);
+			fs7.fchmod = chmodFix(fs7.fchmod);
+			fs7.lchmod = chmodFix(fs7.lchmod);
+			fs7.chownSync = chownFixSync(fs7.chownSync);
+			fs7.fchownSync = chownFixSync(fs7.fchownSync);
+			fs7.lchownSync = chownFixSync(fs7.lchownSync);
+			fs7.chmodSync = chmodFixSync(fs7.chmodSync);
+			fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
+			fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
+			fs7.stat = statFix(fs7.stat);
+			fs7.fstat = statFix(fs7.fstat);
+			fs7.lstat = statFix(fs7.lstat);
+			fs7.statSync = statFixSync(fs7.statSync);
+			fs7.fstatSync = statFixSync(fs7.fstatSync);
+			fs7.lstatSync = statFixSync(fs7.lstatSync);
+			if (fs7.chmod && !fs7.lchmod) {
+				fs7.lchmod = function(path7, mode, cb) {
 					if (cb) process.nextTick(cb);
 				};
-				fs6.lchmodSync = function() {};
+				fs7.lchmodSync = function() {};
 			}
-			if (fs6.chown && !fs6.lchown) {
-				fs6.lchown = function(path7, uid, gid, cb) {
+			if (fs7.chown && !fs7.lchown) {
+				fs7.lchown = function(path7, uid, gid, cb) {
 					if (cb) process.nextTick(cb);
 				};
-				fs6.lchownSync = function() {};
+				fs7.lchownSync = function() {};
 			}
-			if (platform === "win32") fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+			if (platform === "win32") fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
 				function rename2(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() {
-								fs6.stat(to, function(stater, st) {
+								fs7.stat(to, function(stater, st) {
 									if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
 									else cb(er);
 								});
@@ -2062,8 +2062,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				}
 				if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
 				return rename2;
-			}(fs6.rename);
-			fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
+			}(fs7.rename);
+			fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
 				function read(fd, buffer, offset, length, position, callback_) {
 					var callback;
 					if (callback_ && typeof callback_ === "function") {
@@ -2071,21 +2071,21 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						callback = function(er, _, __) {
 							if (er && er.code === "EAGAIN" && eagCounter < 10) {
 								eagCounter++;
-								return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+								return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
 							}
 							callback_.apply(this, arguments);
 						};
 					}
-					return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+					return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
 				}
 				if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
 				return read;
-			}(fs6.read);
-			fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : function(fs$readSync) {
+			}(fs7.read);
+			fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : function(fs$readSync) {
 				return function(fd, buffer, offset, length, position) {
 					var eagCounter = 0;
 					while (true) try {
-						return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+						return fs$readSync.call(fs7, fd, buffer, offset, length, position);
 					} catch (er) {
 						if (er.code === "EAGAIN" && eagCounter < 10) {
 							eagCounter++;
@@ -2094,78 +2094,78 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						throw er;
 					}
 				};
-			}(fs6.readSync);
-			function patchLchmod(fs7) {
-				fs7.lchmod = function(path7, mode, callback) {
-					fs7.open(path7, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+			}(fs7.readSync);
+			function patchLchmod(fs8) {
+				fs8.lchmod = function(path7, mode, callback) {
+					fs8.open(path7, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
 						if (err) {
 							if (callback) callback(err);
 							return;
 						}
-						fs7.fchmod(fd, mode, function(err2) {
-							fs7.close(fd, function(err22) {
+						fs8.fchmod(fd, mode, function(err2) {
+							fs8.close(fd, function(err22) {
 								if (callback) callback(err2 || err22);
 							});
 						});
 					});
 				};
-				fs7.lchmodSync = function(path7, mode) {
-					var fd = fs7.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
+				fs8.lchmodSync = function(path7, mode) {
+					var fd = fs8.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
 					var threw = true;
 					var ret;
 					try {
-						ret = fs7.fchmodSync(fd, mode);
+						ret = fs8.fchmodSync(fd, mode);
 						threw = false;
 					} finally {
 						if (threw) try {
-							fs7.closeSync(fd);
+							fs8.closeSync(fd);
 						} catch (er) {}
-						else fs7.closeSync(fd);
+						else fs8.closeSync(fd);
 					}
 					return ret;
 				};
 			}
-			function patchLutimes(fs7) {
-				if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-					fs7.lutimes = function(path7, at, mt, cb) {
-						fs7.open(path7, constants.O_SYMLINK, function(er, fd) {
+			function patchLutimes(fs8) {
+				if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+					fs8.lutimes = function(path7, at, mt, cb) {
+						fs8.open(path7, constants.O_SYMLINK, function(er, fd) {
 							if (er) {
 								if (cb) cb(er);
 								return;
 							}
-							fs7.futimes(fd, at, mt, function(er2) {
-								fs7.close(fd, function(er22) {
+							fs8.futimes(fd, at, mt, function(er2) {
+								fs8.close(fd, function(er22) {
 									if (cb) cb(er2 || er22);
 								});
 							});
 						});
 					};
-					fs7.lutimesSync = function(path7, at, mt) {
-						var fd = fs7.openSync(path7, constants.O_SYMLINK);
+					fs8.lutimesSync = function(path7, at, mt) {
+						var fd = fs8.openSync(path7, constants.O_SYMLINK);
 						var ret;
 						var threw = true;
 						try {
-							ret = fs7.futimesSync(fd, at, mt);
+							ret = fs8.futimesSync(fd, at, mt);
 							threw = false;
 						} finally {
 							if (threw) try {
-								fs7.closeSync(fd);
+								fs8.closeSync(fd);
 							} catch (er) {}
-							else fs7.closeSync(fd);
+							else fs8.closeSync(fd);
 						}
 						return ret;
 					};
-				} else if (fs7.futimes) {
-					fs7.lutimes = function(_a, _b, _c, cb) {
+				} else if (fs8.futimes) {
+					fs8.lutimes = function(_a, _b, _c, cb) {
 						if (cb) process.nextTick(cb);
 					};
-					fs7.lutimesSync = function() {};
+					fs8.lutimesSync = function() {};
 				}
 			}
 			function chmodFix(orig) {
 				if (!orig) return orig;
 				return function(target, mode, cb) {
-					return orig.call(fs6, target, mode, function(er) {
+					return orig.call(fs7, target, mode, function(er) {
 						if (chownErOk(er)) er = null;
 						if (cb) cb.apply(this, arguments);
 					});
@@ -2175,7 +2175,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				if (!orig) return orig;
 				return function(target, mode) {
 					try {
-						return orig.call(fs6, target, mode);
+						return orig.call(fs7, target, mode);
 					} catch (er) {
 						if (!chownErOk(er)) throw er;
 					}
@@ -2184,7 +2184,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			function chownFix(orig) {
 				if (!orig) return orig;
 				return function(target, uid, gid, cb) {
-					return orig.call(fs6, target, uid, gid, function(er) {
+					return orig.call(fs7, target, uid, gid, function(er) {
 						if (chownErOk(er)) er = null;
 						if (cb) cb.apply(this, arguments);
 					});
@@ -2194,7 +2194,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				if (!orig) return orig;
 				return function(target, uid, gid) {
 					try {
-						return orig.call(fs6, target, uid, gid);
+						return orig.call(fs7, target, uid, gid);
 					} catch (er) {
 						if (!chownErOk(er)) throw er;
 					}
@@ -2214,13 +2214,13 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						}
 						if (cb) cb.apply(this, arguments);
 					}
-					return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
+					return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
 				};
 			}
 			function statFixSync(orig) {
 				if (!orig) return orig;
 				return function(target, options) {
-					var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
+					var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
 					if (stats) {
 						if (stats.uid < 0) stats.uid += 4294967296;
 						if (stats.gid < 0) stats.gid += 4294967296;
@@ -2241,7 +2241,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_legacy_streams = __commonJS({ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
 		var Stream = require("stream").Stream;
 		module2.exports = legacy;
-		function legacy(fs6) {
+		function legacy(fs7) {
 			return {
 				ReadStream,
 				WriteStream
@@ -2277,7 +2277,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 					return;
 				}
-				fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+				fs7.open(this.path, this.flags, this.mode, function(err, fd) {
 					if (err) {
 						self2.emit("error", err);
 						self2.readable = false;
@@ -2312,7 +2312,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				this.busy = false;
 				this._queue = [];
 				if (this.fd === null) {
-					this._open = fs6.open;
+					this._open = fs7.open;
 					this._queue.push([
 						this._open,
 						this.path,
@@ -2341,7 +2341,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 	} });
 	var require_graceful_fs = __commonJS({ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var polyfills = require_polyfills();
 		var legacy = require_legacy_streams();
 		var clone = require_clone();
@@ -2368,46 +2368,46 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
 			console.error(m);
 		};
-		if (!fs6[gracefulQueue]) {
+		if (!fs7[gracefulQueue]) {
 			queue = global[gracefulQueue] || [];
-			publishQueue(fs6, queue);
-			fs6.close = function(fs$close) {
+			publishQueue(fs7, queue);
+			fs7.close = function(fs$close) {
 				function close(fd, cb) {
-					return fs$close.call(fs6, fd, function(err) {
+					return fs$close.call(fs7, fd, function(err) {
 						if (!err) resetQueue();
 						if (typeof cb === "function") cb.apply(this, arguments);
 					});
 				}
 				Object.defineProperty(close, previousSymbol, { value: fs$close });
 				return close;
-			}(fs6.close);
-			fs6.closeSync = function(fs$closeSync) {
+			}(fs7.close);
+			fs7.closeSync = function(fs$closeSync) {
 				function closeSync(fd) {
-					fs$closeSync.apply(fs6, arguments);
+					fs$closeSync.apply(fs7, arguments);
 					resetQueue();
 				}
 				Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
 				return closeSync;
-			}(fs6.closeSync);
+			}(fs7.closeSync);
 			if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
-				debug2(fs6[gracefulQueue]);
-				require("assert").equal(fs6[gracefulQueue].length, 0);
+				debug2(fs7[gracefulQueue]);
+				require("assert").equal(fs7[gracefulQueue].length, 0);
 			});
 		}
 		var queue;
-		if (!global[gracefulQueue]) publishQueue(global, fs6[gracefulQueue]);
-		module2.exports = patch(clone(fs6));
-		if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
-			module2.exports = patch(fs6);
-			fs6.__patched = true;
-		}
-		function patch(fs7) {
-			polyfills(fs7);
-			fs7.gracefulify = patch;
-			fs7.createReadStream = createReadStream;
-			fs7.createWriteStream = createWriteStream;
-			var fs$readFile = fs7.readFile;
-			fs7.readFile = readFile4;
+		if (!global[gracefulQueue]) publishQueue(global, fs7[gracefulQueue]);
+		module2.exports = patch(clone(fs7));
+		if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
+			module2.exports = patch(fs7);
+			fs7.__patched = true;
+		}
+		function patch(fs8) {
+			polyfills(fs8);
+			fs8.gracefulify = patch;
+			fs8.createReadStream = createReadStream;
+			fs8.createWriteStream = createWriteStream;
+			var fs$readFile = fs8.readFile;
+			fs8.readFile = readFile4;
 			function readFile4(path7, options, cb) {
 				if (typeof options === "function") cb = options, options = null;
 				return go$readFile(path7, options, cb);
@@ -2428,8 +2428,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 				}
 			}
-			var fs$writeFile = fs7.writeFile;
-			fs7.writeFile = writeFile;
+			var fs$writeFile = fs8.writeFile;
+			fs8.writeFile = writeFile;
 			function writeFile(path7, data, options, cb) {
 				if (typeof options === "function") cb = options, options = null;
 				return go$writeFile(path7, data, options, cb);
@@ -2451,8 +2451,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 				}
 			}
-			var fs$appendFile = fs7.appendFile;
-			if (fs$appendFile) fs7.appendFile = appendFile;
+			var fs$appendFile = fs8.appendFile;
+			if (fs$appendFile) fs8.appendFile = appendFile;
 			function appendFile(path7, data, options, cb) {
 				if (typeof options === "function") cb = options, options = null;
 				return go$appendFile(path7, data, options, cb);
@@ -2474,8 +2474,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 				}
 			}
-			var fs$copyFile = fs7.copyFile;
-			if (fs$copyFile) fs7.copyFile = copyFile;
+			var fs$copyFile = fs8.copyFile;
+			if (fs$copyFile) fs8.copyFile = copyFile;
 			function copyFile(src, dest, flags, cb) {
 				if (typeof flags === "function") {
 					cb = flags;
@@ -2500,8 +2500,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 				}
 			}
-			var fs$readdir = fs7.readdir;
-			fs7.readdir = readdir;
+			var fs$readdir = fs8.readdir;
+			fs8.readdir = readdir;
 			var noReaddirOptionVersions = /^v[0-5]\./;
 			function readdir(path7, options, cb) {
 				if (typeof options === "function") cb = options, options = null;
@@ -2532,21 +2532,21 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				}
 			}
 			if (process.version.substr(0, 4) === "v0.8") {
-				var legStreams = legacy(fs7);
+				var legStreams = legacy(fs8);
 				ReadStream = legStreams.ReadStream;
 				WriteStream = legStreams.WriteStream;
 			}
-			var fs$ReadStream = fs7.ReadStream;
+			var fs$ReadStream = fs8.ReadStream;
 			if (fs$ReadStream) {
 				ReadStream.prototype = Object.create(fs$ReadStream.prototype);
 				ReadStream.prototype.open = ReadStream$open;
 			}
-			var fs$WriteStream = fs7.WriteStream;
+			var fs$WriteStream = fs8.WriteStream;
 			if (fs$WriteStream) {
 				WriteStream.prototype = Object.create(fs$WriteStream.prototype);
 				WriteStream.prototype.open = WriteStream$open;
 			}
-			Object.defineProperty(fs7, "ReadStream", {
+			Object.defineProperty(fs8, "ReadStream", {
 				get: function() {
 					return ReadStream;
 				},
@@ -2556,7 +2556,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				enumerable: true,
 				configurable: true
 			});
-			Object.defineProperty(fs7, "WriteStream", {
+			Object.defineProperty(fs8, "WriteStream", {
 				get: function() {
 					return WriteStream;
 				},
@@ -2567,7 +2567,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				configurable: true
 			});
 			var FileReadStream = ReadStream;
-			Object.defineProperty(fs7, "FileReadStream", {
+			Object.defineProperty(fs8, "FileReadStream", {
 				get: function() {
 					return FileReadStream;
 				},
@@ -2578,7 +2578,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				configurable: true
 			});
 			var FileWriteStream = WriteStream;
-			Object.defineProperty(fs7, "FileWriteStream", {
+			Object.defineProperty(fs8, "FileWriteStream", {
 				get: function() {
 					return FileWriteStream;
 				},
@@ -2622,13 +2622,13 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				});
 			}
 			function createReadStream(path7, options) {
-				return new fs7.ReadStream(path7, options);
+				return new fs8.ReadStream(path7, options);
 			}
 			function createWriteStream(path7, options) {
-				return new fs7.WriteStream(path7, options);
+				return new fs8.WriteStream(path7, options);
 			}
-			var fs$open = fs7.open;
-			fs7.open = open;
+			var fs$open = fs8.open;
+			fs8.open = open;
 			function open(path7, flags, mode, cb) {
 				if (typeof mode === "function") cb = mode, mode = null;
 				return go$open(path7, flags, mode, cb);
@@ -2650,27 +2650,27 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					});
 				}
 			}
-			return fs7;
+			return fs8;
 		}
 		function enqueue(elem) {
 			debug2("ENQUEUE", elem[0].name, elem[1]);
-			fs6[gracefulQueue].push(elem);
+			fs7[gracefulQueue].push(elem);
 			retry2();
 		}
 		var retryTimer;
 		function resetQueue() {
 			var now = Date.now();
-			for (var i = 0; i < fs6[gracefulQueue].length; ++i) if (fs6[gracefulQueue][i].length > 2) {
-				fs6[gracefulQueue][i][3] = now;
-				fs6[gracefulQueue][i][4] = now;
+			for (var i = 0; i < fs7[gracefulQueue].length; ++i) if (fs7[gracefulQueue][i].length > 2) {
+				fs7[gracefulQueue][i][3] = now;
+				fs7[gracefulQueue][i][4] = now;
 			}
 			retry2();
 		}
 		function retry2() {
 			clearTimeout(retryTimer);
 			retryTimer = void 0;
-			if (fs6[gracefulQueue].length === 0) return;
-			var elem = fs6[gracefulQueue].shift();
+			if (fs7[gracefulQueue].length === 0) return;
+			var elem = fs7[gracefulQueue].shift();
 			var fn = elem[0];
 			var args = elem[1];
 			var err = elem[2];
@@ -2689,14 +2689,14 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
 					debug2("RETRY", fn.name, args);
 					fn.apply(null, args.concat([startTime]));
-				} else fs6[gracefulQueue].push(elem);
+				} else fs7[gracefulQueue].push(elem);
 			}
 			if (retryTimer === void 0) retryTimer = setTimeout(retry2, 0);
 		}
 	} });
 	var require_fs = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/fs/index.js"(exports2) {
 		var u = require_universalify().fromCallback;
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var api = [
 			"access",
 			"appendFile",
@@ -2733,23 +2733,23 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			"utimes",
 			"writeFile"
 		].filter((key) => {
-			return typeof fs6[key] === "function";
+			return typeof fs7[key] === "function";
 		});
-		Object.assign(exports2, fs6);
+		Object.assign(exports2, fs7);
 		api.forEach((method) => {
-			exports2[method] = u(fs6[method]);
+			exports2[method] = u(fs7[method]);
 		});
-		exports2.realpath.native = u(fs6.realpath.native);
+		exports2.realpath.native = u(fs7.realpath.native);
 		exports2.exists = function(filename, callback) {
-			if (typeof callback === "function") return fs6.exists(filename, callback);
+			if (typeof callback === "function") return fs7.exists(filename, callback);
 			return new Promise((resolve) => {
-				return fs6.exists(filename, resolve);
+				return fs7.exists(filename, resolve);
 			});
 		};
 		exports2.read = function(fd, buffer, offset, length, position, callback) {
-			if (typeof callback === "function") return fs6.read(fd, buffer, offset, length, position, callback);
+			if (typeof callback === "function") return fs7.read(fd, buffer, offset, length, position, callback);
 			return new Promise((resolve, reject) => {
-				fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+				fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
 					if (err) return reject(err);
 					resolve({
 						bytesRead,
@@ -2759,9 +2759,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		};
 		exports2.write = function(fd, buffer, ...args) {
-			if (typeof args[args.length - 1] === "function") return fs6.write(fd, buffer, ...args);
+			if (typeof args[args.length - 1] === "function") return fs7.write(fd, buffer, ...args);
 			return new Promise((resolve, reject) => {
-				fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+				fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
 					if (err) return reject(err);
 					resolve({
 						bytesWritten,
@@ -2770,10 +2770,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				});
 			});
 		};
-		if (typeof fs6.writev === "function") exports2.writev = function(fd, buffers, ...args) {
-			if (typeof args[args.length - 1] === "function") return fs6.writev(fd, buffers, ...args);
+		if (typeof fs7.writev === "function") exports2.writev = function(fd, buffers, ...args) {
+			if (typeof args[args.length - 1] === "function") return fs7.writev(fd, buffers, ...args);
 			return new Promise((resolve, reject) => {
-				fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+				fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
 					if (err) return reject(err);
 					resolve({
 						bytesWritten,
@@ -2796,7 +2796,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_make_dir = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
-		var fs6 = require_fs();
+		var fs7 = require_fs();
 		var { checkPath } = require_utils();
 		var getMode = (options) => {
 			const defaults = { mode: 511 };
@@ -2808,14 +2808,14 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 		module2.exports.makeDir = async (dir, options) => {
 			checkPath(dir);
-			return fs6.mkdir(dir, {
+			return fs7.mkdir(dir, {
 				mode: getMode(options),
 				recursive: true
 			});
 		};
 		module2.exports.makeDirSync = (dir, options) => {
 			checkPath(dir);
-			return fs6.mkdirSync(dir, {
+			return fs7.mkdirSync(dir, {
 				mode: getMode(options),
 				recursive: true
 			});
@@ -2835,21 +2835,21 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_utimes = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		function utimesMillis(path7, atime, mtime2, callback) {
-			fs6.open(path7, "r+", (err, fd) => {
+			fs7.open(path7, "r+", (err, fd) => {
 				if (err) return callback(err);
-				fs6.futimes(fd, atime, mtime2, (futimesErr) => {
-					fs6.close(fd, (closeErr) => {
+				fs7.futimes(fd, atime, mtime2, (futimesErr) => {
+					fs7.close(fd, (closeErr) => {
 						if (callback) callback(futimesErr || closeErr);
 					});
 				});
 			});
 		}
 		function utimesMillisSync(path7, atime, mtime2) {
-			const fd = fs6.openSync(path7, "r+");
-			fs6.futimesSync(fd, atime, mtime2);
-			return fs6.closeSync(fd);
+			const fd = fs7.openSync(path7, "r+");
+			fs7.futimesSync(fd, atime, mtime2);
+			return fs7.closeSync(fd);
 		}
 		module2.exports = {
 			utimesMillis,
@@ -2857,11 +2857,11 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_stat = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
-		var fs6 = require_fs();
+		var fs7 = require_fs();
 		var path7 = require("path");
 		var util = require("util");
 		function getStats(src, dest, opts) {
-			const statFunc = opts.dereference ? (file) => fs6.stat(file, { bigint: true }) : (file) => fs6.lstat(file, { bigint: true });
+			const statFunc = opts.dereference ? (file) => fs7.stat(file, { bigint: true }) : (file) => fs7.lstat(file, { bigint: true });
 			return Promise.all([statFunc(src), statFunc(dest).catch((err) => {
 				if (err.code === "ENOENT") return null;
 				throw err;
@@ -2872,7 +2872,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 		function getStatsSync(src, dest, opts) {
 			let destStat;
-			const statFunc = opts.dereference ? (file) => fs6.statSync(file, { bigint: true }) : (file) => fs6.lstatSync(file, { bigint: true });
+			const statFunc = opts.dereference ? (file) => fs7.statSync(file, { bigint: true }) : (file) => fs7.lstatSync(file, { bigint: true });
 			const srcStat = statFunc(src);
 			try {
 				destStat = statFunc(dest);
@@ -2939,7 +2939,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			const srcParent = path7.resolve(path7.dirname(src));
 			const destParent = path7.resolve(path7.dirname(dest));
 			if (destParent === srcParent || destParent === path7.parse(destParent).root) return cb();
-			fs6.stat(destParent, { bigint: true }, (err, destStat) => {
+			fs7.stat(destParent, { bigint: true }, (err, destStat) => {
 				if (err) {
 					if (err.code === "ENOENT") return cb();
 					return cb(err);
@@ -2954,7 +2954,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			if (destParent === srcParent || destParent === path7.parse(destParent).root) return;
 			let destStat;
 			try {
-				destStat = fs6.statSync(destParent, { bigint: true });
+				destStat = fs7.statSync(destParent, { bigint: true });
 			} catch (err) {
 				if (err.code === "ENOENT") return;
 				throw err;
@@ -2983,7 +2983,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_copy_sync = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var mkdirsSync = require_mkdirs().mkdirsSync;
 		var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -3003,7 +3003,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function handleFilterAndCopy(destStat, src, dest, opts) {
 			if (opts.filter && !opts.filter(src, dest)) return;
 			const destParent = path7.dirname(dest);
-			if (!fs6.existsSync(destParent)) mkdirsSync(destParent);
+			if (!fs7.existsSync(destParent)) mkdirsSync(destParent);
 			return getStats(destStat, src, dest, opts);
 		}
 		function startCopy(destStat, src, dest, opts) {
@@ -3011,7 +3011,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return getStats(destStat, src, dest, opts);
 		}
 		function getStats(destStat, src, dest, opts) {
-			const srcStat = (opts.dereference ? fs6.statSync : fs6.lstatSync)(src);
+			const srcStat = (opts.dereference ? fs7.statSync : fs7.lstatSync)(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);
@@ -3025,12 +3025,12 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 		function mayCopyFile(srcStat, src, dest, opts) {
 			if (opts.overwrite) {
-				fs6.unlinkSync(dest);
+				fs7.unlinkSync(dest);
 				return copyFile(srcStat, src, dest, opts);
 			} else if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
 		}
 		function copyFile(srcStat, src, dest, opts) {
-			fs6.copyFileSync(src, dest);
+			fs7.copyFileSync(src, dest);
 			if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
 			return setDestMode(dest, srcStat.mode);
 		}
@@ -3045,10 +3045,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return setDestMode(dest, srcMode | 128);
 		}
 		function setDestMode(dest, srcMode) {
-			return fs6.chmodSync(dest, srcMode);
+			return fs7.chmodSync(dest, srcMode);
 		}
 		function setDestTimestamps(src, dest) {
-			const updatedSrcStat = fs6.statSync(src);
+			const updatedSrcStat = fs7.statSync(src);
 			return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
 		}
 		function onDir(srcStat, destStat, src, dest, opts) {
@@ -3056,12 +3056,12 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return copyDir(src, dest, opts);
 		}
 		function mkDirAndCopy(srcMode, src, dest, opts) {
-			fs6.mkdirSync(dest);
+			fs7.mkdirSync(dest);
 			copyDir(src, dest, opts);
 			return setDestMode(dest, srcMode);
 		}
 		function copyDir(src, dest, opts) {
-			fs6.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+			fs7.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
 		}
 		function copyDirItem(item, src, dest, opts) {
 			const srcItem = path7.join(src, item);
@@ -3070,26 +3070,26 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return startCopy(destStat, srcItem, destItem, opts);
 		}
 		function onLink(destStat, src, dest, opts) {
-			let resolvedSrc = fs6.readlinkSync(src);
+			let resolvedSrc = fs7.readlinkSync(src);
 			if (opts.dereference) resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
-			if (!destStat) return fs6.symlinkSync(resolvedSrc, dest);
+			if (!destStat) return fs7.symlinkSync(resolvedSrc, dest);
 			else {
 				let resolvedDest;
 				try {
-					resolvedDest = fs6.readlinkSync(dest);
+					resolvedDest = fs7.readlinkSync(dest);
 				} catch (err) {
-					if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs6.symlinkSync(resolvedSrc, dest);
+					if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs7.symlinkSync(resolvedSrc, dest);
 					throw err;
 				}
 				if (opts.dereference) resolvedDest = path7.resolve(process.cwd(), resolvedDest);
 				if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-				if (fs6.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+				if (fs7.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
 				return copyLink(resolvedSrc, dest);
 			}
 		}
 		function copyLink(resolvedSrc, dest) {
-			fs6.unlinkSync(dest);
-			return fs6.symlinkSync(resolvedSrc, dest);
+			fs7.unlinkSync(dest);
+			return fs7.symlinkSync(resolvedSrc, dest);
 		}
 		module2.exports = copySync;
 	} });
@@ -3098,17 +3098,17 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	} });
 	var require_path_exists = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
 		var u = require_universalify().fromPromise;
-		var fs6 = require_fs();
+		var fs7 = require_fs();
 		function pathExists(path7) {
-			return fs6.access(path7).then(() => true).catch(() => false);
+			return fs7.access(path7).then(() => true).catch(() => false);
 		}
 		module2.exports = {
 			pathExists: u(pathExists),
-			pathExistsSync: fs6.existsSync
+			pathExistsSync: fs7.existsSync
 		};
 	} });
 	var require_copy = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var mkdirs = require_mkdirs().mkdirs;
 		var pathExists = require_path_exists().pathExists;
@@ -3158,7 +3158,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return getStats(destStat, src, dest, opts, cb);
 		}
 		function getStats(destStat, src, dest, opts, cb) {
-			(opts.dereference ? fs6.stat : fs6.lstat)(src, (err, srcStat) => {
+			(opts.dereference ? fs7.stat : fs7.lstat)(src, (err, srcStat) => {
 				if (err) return cb(err);
 				if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb);
 				else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb);
@@ -3173,7 +3173,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return mayCopyFile(srcStat, src, dest, opts, cb);
 		}
 		function mayCopyFile(srcStat, src, dest, opts, cb) {
-			if (opts.overwrite) fs6.unlink(dest, (err) => {
+			if (opts.overwrite) fs7.unlink(dest, (err) => {
 				if (err) return cb(err);
 				return copyFile(srcStat, src, dest, opts, cb);
 			});
@@ -3181,7 +3181,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			else return cb();
 		}
 		function copyFile(srcStat, src, dest, opts, cb) {
-			fs6.copyFile(src, dest, (err) => {
+			fs7.copyFile(src, dest, (err) => {
 				if (err) return cb(err);
 				if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
 				return setDestMode(dest, srcStat.mode, cb);
@@ -3207,10 +3207,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function setDestMode(dest, srcMode, cb) {
-			return fs6.chmod(dest, srcMode, cb);
+			return fs7.chmod(dest, srcMode, cb);
 		}
 		function setDestTimestamps(src, dest, cb) {
-			fs6.stat(src, (err, updatedSrcStat) => {
+			fs7.stat(src, (err, updatedSrcStat) => {
 				if (err) return cb(err);
 				return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
 			});
@@ -3220,7 +3220,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return copyDir(src, dest, opts, cb);
 		}
 		function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-			fs6.mkdir(dest, (err) => {
+			fs7.mkdir(dest, (err) => {
 				if (err) return cb(err);
 				copyDir(src, dest, opts, (err2) => {
 					if (err2) return cb(err2);
@@ -3229,7 +3229,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function copyDir(src, dest, opts, cb) {
-			fs6.readdir(src, (err, items) => {
+			fs7.readdir(src, (err, items) => {
 				if (err) return cb(err);
 				return copyDirItems(items, src, dest, opts, cb);
 			});
@@ -3252,13 +3252,13 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function onLink(destStat, src, dest, opts, cb) {
-			fs6.readlink(src, (err, resolvedSrc) => {
+			fs7.readlink(src, (err, resolvedSrc) => {
 				if (err) return cb(err);
 				if (opts.dereference) resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
-				if (!destStat) return fs6.symlink(resolvedSrc, dest, cb);
-				else fs6.readlink(dest, (err2, resolvedDest) => {
+				if (!destStat) return fs7.symlink(resolvedSrc, dest, cb);
+				else fs7.readlink(dest, (err2, resolvedDest) => {
 					if (err2) {
-						if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs6.symlink(resolvedSrc, dest, cb);
+						if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs7.symlink(resolvedSrc, dest, cb);
 						return cb(err2);
 					}
 					if (opts.dereference) resolvedDest = path7.resolve(process.cwd(), resolvedDest);
@@ -3269,9 +3269,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function copyLink(resolvedSrc, dest, cb) {
-			fs6.unlink(dest, (err) => {
+			fs7.unlink(dest, (err) => {
 				if (err) return cb(err);
-				return fs6.symlink(resolvedSrc, dest, cb);
+				return fs7.symlink(resolvedSrc, dest, cb);
 			});
 		}
 		module2.exports = copy;
@@ -3281,7 +3281,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		module2.exports = { copy: u(require_copy()) };
 	} });
 	var require_rimraf = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var assert7 = require("assert");
 		var isWindows = process.platform === "win32";
@@ -3294,9 +3294,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				"rmdir",
 				"readdir"
 			].forEach((m) => {
-				options[m] = options[m] || fs6[m];
+				options[m] = options[m] || fs7[m];
 				m = m + "Sync";
-				options[m] = options[m] || fs6[m];
+				options[m] = options[m] || fs7[m];
 			});
 			options.maxBusyTries = options.maxBusyTries || 3;
 		}
@@ -3454,18 +3454,18 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		rimraf.sync = rimrafSync;
 	} });
 	var require_remove = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var u = require_universalify().fromCallback;
 		var rimraf = require_rimraf();
 		function remove2(path7, callback) {
-			if (fs6.rm) return fs6.rm(path7, {
+			if (fs7.rm) return fs7.rm(path7, {
 				recursive: true,
 				force: true
 			}, callback);
 			rimraf(path7, callback);
 		}
 		function removeSync(path7) {
-			if (fs6.rmSync) return fs6.rmSync(path7, {
+			if (fs7.rmSync) return fs7.rmSync(path7, {
 				recursive: true,
 				force: true
 			});
@@ -3478,14 +3478,14 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	} });
 	var require_empty = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
 		var u = require_universalify().fromPromise;
-		var fs6 = require_fs();
+		var fs7 = require_fs();
 		var path7 = require("path");
 		var mkdir = require_mkdirs();
 		var remove2 = require_remove();
 		var emptyDir = u(async function emptyDir2(dir) {
 			let items;
 			try {
-				items = await fs6.readdir(dir);
+				items = await fs7.readdir(dir);
 			} catch {
 				return mkdir.mkdirs(dir);
 			}
@@ -3494,7 +3494,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function emptyDirSync(dir) {
 			let items;
 			try {
-				items = fs6.readdirSync(dir);
+				items = fs7.readdirSync(dir);
 			} catch {
 				return mkdir.mkdirsSync(dir);
 			}
@@ -3513,19 +3513,19 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_file = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
 		var u = require_universalify().fromCallback;
 		var path7 = require("path");
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var mkdir = require_mkdirs();
 		function createFile(file, callback) {
 			function makeFile() {
-				fs6.writeFile(file, "", (err) => {
+				fs7.writeFile(file, "", (err) => {
 					if (err) return callback(err);
 					callback();
 				});
 			}
-			fs6.stat(file, (err, stats) => {
+			fs7.stat(file, (err, stats) => {
 				if (!err && stats.isFile()) return callback();
 				const dir = path7.dirname(file);
-				fs6.stat(dir, (err2, stats2) => {
+				fs7.stat(dir, (err2, stats2) => {
 					if (err2) {
 						if (err2.code === "ENOENT") return mkdir.mkdirs(dir, (err3) => {
 							if (err3) return callback(err3);
@@ -3534,7 +3534,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						return callback(err2);
 					}
 					if (stats2.isDirectory()) makeFile();
-					else fs6.readdir(dir, (err3) => {
+					else fs7.readdir(dir, (err3) => {
 						if (err3) return callback(err3);
 					});
 				});
@@ -3543,17 +3543,17 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function createFileSync(file) {
 			let stats;
 			try {
-				stats = fs6.statSync(file);
+				stats = fs7.statSync(file);
 			} catch {}
 			if (stats && stats.isFile()) return;
 			const dir = path7.dirname(file);
 			try {
-				if (!fs6.statSync(dir).isDirectory()) fs6.readdirSync(dir);
+				if (!fs7.statSync(dir).isDirectory()) fs7.readdirSync(dir);
 			} catch (err) {
 				if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
 				else throw err;
 			}
-			fs6.writeFileSync(file, "");
+			fs7.writeFileSync(file, "");
 		}
 		module2.exports = {
 			createFile: u(createFile),
@@ -3563,19 +3563,19 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_link = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
 		var u = require_universalify().fromCallback;
 		var path7 = require("path");
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var mkdir = require_mkdirs();
 		var pathExists = require_path_exists().pathExists;
 		var { areIdentical } = require_stat();
 		function createLink(srcpath, dstpath, callback) {
 			function makeLink(srcpath2, dstpath2) {
-				fs6.link(srcpath2, dstpath2, (err) => {
+				fs7.link(srcpath2, dstpath2, (err) => {
 					if (err) return callback(err);
 					callback(null);
 				});
 			}
-			fs6.lstat(dstpath, (_, dstStat) => {
-				fs6.lstat(srcpath, (err, srcStat) => {
+			fs7.lstat(dstpath, (_, dstStat) => {
+				fs7.lstat(srcpath, (err, srcStat) => {
 					if (err) {
 						err.message = err.message.replace("lstat", "ensureLink");
 						return callback(err);
@@ -3596,19 +3596,19 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function createLinkSync(srcpath, dstpath) {
 			let dstStat;
 			try {
-				dstStat = fs6.lstatSync(dstpath);
+				dstStat = fs7.lstatSync(dstpath);
 			} catch {}
 			try {
-				const srcStat = fs6.lstatSync(srcpath);
+				const srcStat = fs7.lstatSync(srcpath);
 				if (dstStat && areIdentical(srcStat, dstStat)) return;
 			} catch (err) {
 				err.message = err.message.replace("lstat", "ensureLink");
 				throw err;
 			}
 			const dir = path7.dirname(dstpath);
-			if (fs6.existsSync(dir)) return fs6.linkSync(srcpath, dstpath);
+			if (fs7.existsSync(dir)) return fs7.linkSync(srcpath, dstpath);
 			mkdir.mkdirsSync(dir);
-			return fs6.linkSync(srcpath, dstpath);
+			return fs7.linkSync(srcpath, dstpath);
 		}
 		module2.exports = {
 			createLink: u(createLink),
@@ -3617,10 +3617,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	} });
 	var require_symlink_paths = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
 		var path7 = require("path");
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var pathExists = require_path_exists().pathExists;
 		function symlinkPaths(srcpath, dstpath, callback) {
-			if (path7.isAbsolute(srcpath)) return fs6.lstat(srcpath, (err) => {
+			if (path7.isAbsolute(srcpath)) return fs7.lstat(srcpath, (err) => {
 				if (err) {
 					err.message = err.message.replace("lstat", "ensureSymlink");
 					return callback(err);
@@ -3639,7 +3639,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						toCwd: relativeToDst,
 						toDst: srcpath
 					});
-					else return fs6.lstat(srcpath, (err2) => {
+					else return fs7.lstat(srcpath, (err2) => {
 						if (err2) {
 							err2.message = err2.message.replace("lstat", "ensureSymlink");
 							return callback(err2);
@@ -3655,7 +3655,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function symlinkPathsSync(srcpath, dstpath) {
 			let exists;
 			if (path7.isAbsolute(srcpath)) {
-				exists = fs6.existsSync(srcpath);
+				exists = fs7.existsSync(srcpath);
 				if (!exists) throw new Error("absolute srcpath does not exist");
 				return {
 					toCwd: srcpath,
@@ -3664,13 +3664,13 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			} else {
 				const dstdir = path7.dirname(dstpath);
 				const relativeToDst = path7.join(dstdir, srcpath);
-				exists = fs6.existsSync(relativeToDst);
+				exists = fs7.existsSync(relativeToDst);
 				if (exists) return {
 					toCwd: relativeToDst,
 					toDst: srcpath
 				};
 				else {
-					exists = fs6.existsSync(srcpath);
+					exists = fs7.existsSync(srcpath);
 					if (!exists) throw new Error("relative srcpath does not exist");
 					return {
 						toCwd: srcpath,
@@ -3685,12 +3685,12 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_symlink_type = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		function symlinkType(srcpath, type, callback) {
 			callback = typeof type === "function" ? type : callback;
 			type = typeof type === "function" ? false : type;
 			if (type) return callback(null, type);
-			fs6.lstat(srcpath, (err, stats) => {
+			fs7.lstat(srcpath, (err, stats) => {
 				if (err) return callback(null, "file");
 				type = stats && stats.isDirectory() ? "dir" : "file";
 				callback(null, type);
@@ -3700,7 +3700,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			let stats;
 			if (type) return type;
 			try {
-				stats = fs6.lstatSync(srcpath);
+				stats = fs7.lstatSync(srcpath);
 			} catch {
 				return "file";
 			}
@@ -3714,7 +3714,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_symlink = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
 		var u = require_universalify().fromCallback;
 		var path7 = require("path");
-		var fs6 = require_fs();
+		var fs7 = require_fs();
 		var _mkdirs = require_mkdirs();
 		var mkdirs = _mkdirs.mkdirs;
 		var mkdirsSync = _mkdirs.mkdirsSync;
@@ -3729,8 +3729,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function createSymlink(srcpath, dstpath, type, callback) {
 			callback = typeof type === "function" ? type : callback;
 			type = typeof type === "function" ? false : type;
-			fs6.lstat(dstpath, (err, stats) => {
-				if (!err && stats.isSymbolicLink()) Promise.all([fs6.stat(srcpath), fs6.stat(dstpath)]).then(([srcStat, dstStat]) => {
+			fs7.lstat(dstpath, (err, stats) => {
+				if (!err && stats.isSymbolicLink()) Promise.all([fs7.stat(srcpath), fs7.stat(dstpath)]).then(([srcStat, dstStat]) => {
 					if (areIdentical(srcStat, dstStat)) return callback(null);
 					_createSymlink(srcpath, dstpath, type, callback);
 				});
@@ -3746,10 +3746,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					const dir = path7.dirname(dstpath);
 					pathExists(dir, (err3, dirExists) => {
 						if (err3) return callback(err3);
-						if (dirExists) return fs6.symlink(srcpath, dstpath, type2, callback);
+						if (dirExists) return fs7.symlink(srcpath, dstpath, type2, callback);
 						mkdirs(dir, (err4) => {
 							if (err4) return callback(err4);
-							fs6.symlink(srcpath, dstpath, type2, callback);
+							fs7.symlink(srcpath, dstpath, type2, callback);
 						});
 					});
 				});
@@ -3758,18 +3758,18 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function createSymlinkSync(srcpath, dstpath, type) {
 			let stats;
 			try {
-				stats = fs6.lstatSync(dstpath);
+				stats = fs7.lstatSync(dstpath);
 			} catch {}
 			if (stats && stats.isSymbolicLink()) {
-				if (areIdentical(fs6.statSync(srcpath), fs6.statSync(dstpath))) return;
+				if (areIdentical(fs7.statSync(srcpath), fs7.statSync(dstpath))) return;
 			}
 			const relative = symlinkPathsSync(srcpath, dstpath);
 			srcpath = relative.toDst;
 			type = symlinkTypeSync(relative.toCwd, type);
 			const dir = path7.dirname(dstpath);
-			if (fs6.existsSync(dir)) return fs6.symlinkSync(srcpath, dstpath, type);
+			if (fs7.existsSync(dir)) return fs7.symlinkSync(srcpath, dstpath, type);
 			mkdirsSync(dir);
-			return fs6.symlinkSync(srcpath, dstpath, type);
+			return fs7.symlinkSync(srcpath, dstpath, type);
 		}
 		module2.exports = {
 			createSymlink: u(createSymlink),
@@ -3820,9 +3820,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		var { stringify, stripBom } = require_utils2();
 		async function _readFile(file, options = {}) {
 			if (typeof options === "string") options = { encoding: options };
-			const fs6 = options.fs || _fs;
+			const fs7 = options.fs || _fs;
 			const shouldThrow = "throws" in options ? options.throws : true;
-			let data = await universalify.fromCallback(fs6.readFile)(file, options);
+			let data = await universalify.fromCallback(fs7.readFile)(file, options);
 			data = stripBom(data);
 			let obj;
 			try {
@@ -3838,10 +3838,10 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		var readFile4 = universalify.fromPromise(_readFile);
 		function readFileSync(file, options = {}) {
 			if (typeof options === "string") options = { encoding: options };
-			const fs6 = options.fs || _fs;
+			const fs7 = options.fs || _fs;
 			const shouldThrow = "throws" in options ? options.throws : true;
 			try {
-				let content = fs6.readFileSync(file, options);
+				let content = fs7.readFileSync(file, options);
 				content = stripBom(content);
 				return JSON.parse(content, options.reviver);
 			} catch (err) {
@@ -3852,15 +3852,15 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			}
 		}
 		async function _writeFile(file, obj, options = {}) {
-			const fs6 = options.fs || _fs;
+			const fs7 = options.fs || _fs;
 			const str = stringify(obj, options);
-			await universalify.fromCallback(fs6.writeFile)(file, str, options);
+			await universalify.fromCallback(fs7.writeFile)(file, str, options);
 		}
 		var writeFile = universalify.fromPromise(_writeFile);
 		function writeFileSync(file, obj, options = {}) {
-			const fs6 = options.fs || _fs;
+			const fs7 = options.fs || _fs;
 			const str = stringify(obj, options);
-			return fs6.writeFileSync(file, str, options);
+			return fs7.writeFileSync(file, str, options);
 		}
 		module2.exports = {
 			readFile: readFile4,
@@ -3880,7 +3880,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	} });
 	var require_output = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/output/index.js"(exports2, module2) {
 		var u = require_universalify().fromCallback;
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var mkdir = require_mkdirs();
 		var pathExists = require_path_exists().pathExists;
@@ -3892,18 +3892,18 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			const dir = path7.dirname(file);
 			pathExists(dir, (err, itDoes) => {
 				if (err) return callback(err);
-				if (itDoes) return fs6.writeFile(file, data, encoding, callback);
+				if (itDoes) return fs7.writeFile(file, data, encoding, callback);
 				mkdir.mkdirs(dir, (err2) => {
 					if (err2) return callback(err2);
-					fs6.writeFile(file, data, encoding, callback);
+					fs7.writeFile(file, data, encoding, callback);
 				});
 			});
 		}
 		function outputFileSync(file, ...args) {
 			const dir = path7.dirname(file);
-			if (fs6.existsSync(dir)) return fs6.writeFileSync(file, ...args);
+			if (fs7.existsSync(dir)) return fs7.writeFileSync(file, ...args);
 			mkdir.mkdirsSync(dir);
-			fs6.writeFileSync(file, ...args);
+			fs7.writeFileSync(file, ...args);
 		}
 		module2.exports = {
 			outputFile: u(outputFile),
@@ -3940,7 +3940,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		module2.exports = jsonFile;
 	} });
 	var require_move_sync = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/move-sync.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var copySync = require_copy_sync2().copySync;
 		var removeSync = require_remove().removeSync;
@@ -3964,12 +3964,12 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				removeSync(dest);
 				return rename2(src, dest, overwrite);
 			}
-			if (fs6.existsSync(dest)) throw new Error("dest already exists.");
+			if (fs7.existsSync(dest)) throw new Error("dest already exists.");
 			return rename2(src, dest, overwrite);
 		}
 		function rename2(src, dest, overwrite) {
 			try {
-				fs6.renameSync(src, dest);
+				fs7.renameSync(src, dest);
 			} catch (err) {
 				if (err.code !== "EXDEV") throw err;
 				return moveAcrossDevice(src, dest, overwrite);
@@ -3988,7 +3988,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		module2.exports = { moveSync: require_move_sync() };
 	} });
 	var require_move = __commonJS({ "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
-		var fs6 = require_graceful_fs();
+		var fs7 = require_graceful_fs();
 		var path7 = require("path");
 		var copy = require_copy2().copy;
 		var remove2 = require_remove().remove;
@@ -4031,7 +4031,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function rename2(src, dest, overwrite, cb) {
-			fs6.rename(src, dest, (err) => {
+			fs7.rename(src, dest, (err) => {
 				if (!err) return cb();
 				if (err.code !== "EXDEV") return cb(err);
 				return moveAcrossDevice(src, dest, overwrite, cb);
@@ -42882,7 +42882,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		module2.exports = crc32;
 	} });
 	var require_yazl = __commonJS({ "../../node_modules/.pnpm/yazl@2.5.1/node_modules/yazl/index.js"(exports2) {
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var Transform = require("stream").Transform;
 		var PassThrough = require("stream").PassThrough;
 		var zlib = require("zlib");
@@ -42906,14 +42906,14 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			if (options == null) options = {};
 			var entry = new Entry(metadataPath, false, options);
 			self2.entries.push(entry);
-			fs6.stat(realPath, function(err, stats) {
+			fs7.stat(realPath, function(err, stats) {
 				if (err) return self2.emit("error", err);
 				if (!stats.isFile()) return self2.emit("error", /* @__PURE__ */ new Error("not a file: " + realPath));
 				entry.uncompressedSize = stats.size;
 				if (options.mtime == null) entry.setLastModDate(stats.mtime);
 				if (options.mode == null) entry.setFileAttributesMode(stats.mode);
 				entry.setFileDataPumpFunction(function() {
-					var readStream = fs6.createReadStream(realPath);
+					var readStream = fs7.createReadStream(realPath);
 					entry.state = Entry.FILE_DATA_IN_PROGRESS;
 					readStream.on("error", function(err2) {
 						self2.emit("error", err2);
@@ -44248,7 +44248,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_old = __commonJS({ "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports2) {
 		var pathModule = require("path");
 		var isWindows = process.platform === "win32";
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
 		function rethrow() {
 			var callback;
@@ -44301,7 +44301,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				base = m[0];
 				previous = "";
 				if (isWindows && !knownHard[base]) {
-					fs6.lstatSync(base);
+					fs7.lstatSync(base);
 					knownHard[base] = true;
 				}
 			}
@@ -44316,7 +44316,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				var resolvedLink;
 				if (cache && Object.prototype.hasOwnProperty.call(cache, base)) resolvedLink = cache[base];
 				else {
-					var stat = fs6.lstatSync(base);
+					var stat = fs7.lstatSync(base);
 					if (!stat.isSymbolicLink()) {
 						knownHard[base] = true;
 						if (cache) cache[base] = base;
@@ -44328,8 +44328,8 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 						if (seenLinks.hasOwnProperty(id)) linkTarget = seenLinks[id];
 					}
 					if (linkTarget === null) {
-						fs6.statSync(base);
-						linkTarget = fs6.readlinkSync(base);
+						fs7.statSync(base);
+						linkTarget = fs7.readlinkSync(base);
 					}
 					resolvedLink = pathModule.resolve(previous, linkTarget);
 					if (cache) cache[base] = resolvedLink;
@@ -44360,7 +44360,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				current = m[0];
 				base = m[0];
 				previous = "";
-				if (isWindows && !knownHard[base]) fs6.lstat(base, function(err) {
+				if (isWindows && !knownHard[base]) fs7.lstat(base, function(err) {
 					if (err) return cb(err);
 					knownHard[base] = true;
 					LOOP();
@@ -44380,7 +44380,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 				pos = nextPartRe.lastIndex;
 				if (knownHard[base] || cache && cache[base] === base) return process.nextTick(LOOP);
 				if (cache && Object.prototype.hasOwnProperty.call(cache, base)) return gotResolvedLink(cache[base]);
-				return fs6.lstat(base, gotStat);
+				return fs7.lstat(base, gotStat);
 			}
 			function gotStat(err, stat) {
 				if (err) return cb(err);
@@ -44393,9 +44393,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 					var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
 					if (seenLinks.hasOwnProperty(id)) return gotTarget(null, seenLinks[id], base);
 				}
-				fs6.stat(base, function(err2) {
+				fs7.stat(base, function(err2) {
 					if (err2) return cb(err2);
-					fs6.readlink(base, function(err3, target) {
+					fs7.readlink(base, function(err3, target) {
 						if (!isWindows) seenLinks[id] = target;
 						gotTarget(err3, target);
 					});
@@ -44420,9 +44420,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		realpath.realpathSync = realpathSync;
 		realpath.monkeypatch = monkeypatch;
 		realpath.unmonkeypatch = unmonkeypatch;
-		var fs6 = require("fs");
-		var origRealpath = fs6.realpath;
-		var origRealpathSync = fs6.realpathSync;
+		var fs7 = require("fs");
+		var origRealpath = fs7.realpath;
+		var origRealpathSync = fs7.realpathSync;
 		var version = process.version;
 		var ok = /^v[0-5]\./.test(version);
 		var old = require_old();
@@ -44450,12 +44450,12 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			}
 		}
 		function monkeypatch() {
-			fs6.realpath = realpath;
-			fs6.realpathSync = realpathSync;
+			fs7.realpath = realpath;
+			fs7.realpathSync = realpathSync;
 		}
 		function unmonkeypatch() {
-			fs6.realpath = origRealpath;
-			fs6.realpathSync = origRealpathSync;
+			fs7.realpath = origRealpath;
+			fs7.realpathSync = origRealpathSync;
 		}
 	} });
 	var require_path = __commonJS({ "../../node_modules/.pnpm/minimatch@5.0.1/node_modules/minimatch/lib/path.js"(exports2, module2) {
@@ -45072,7 +45072,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function ownProp(obj, field) {
 			return Object.prototype.hasOwnProperty.call(obj, field);
 		}
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var path7 = require("path");
 		var minimatch2 = require_minimatch2();
 		var isAbsolute = require("path").isAbsolute;
@@ -45117,7 +45117,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			self2.stat = !!options.stat;
 			self2.noprocess = !!options.noprocess;
 			self2.absolute = !!options.absolute;
-			self2.fs = options.fs || fs6;
+			self2.fs = options.fs || fs7;
 			self2.maxLength = options.maxLength || Infinity;
 			self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
 			self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -45980,7 +45980,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 	var require_windows = __commonJS({ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
 		module2.exports = isexe;
 		isexe.sync = sync;
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		function checkPathExt(path7, options) {
 			var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
 			if (!pathext) return true;
@@ -45997,25 +45997,25 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return checkPathExt(path7, options);
 		}
 		function isexe(path7, options, cb) {
-			fs6.stat(path7, function(er, stat) {
+			fs7.stat(path7, function(er, stat) {
 				cb(er, er ? false : checkStat(stat, path7, options));
 			});
 		}
 		function sync(path7, options) {
-			return checkStat(fs6.statSync(path7), path7, options);
+			return checkStat(fs7.statSync(path7), path7, options);
 		}
 	} });
 	var require_mode = __commonJS({ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
 		module2.exports = isexe;
 		isexe.sync = sync;
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		function isexe(path7, options, cb) {
-			fs6.stat(path7, function(er, stat) {
+			fs7.stat(path7, function(er, stat) {
 				cb(er, er ? false : checkStat(stat, options));
 			});
 		}
 		function sync(path7, options) {
-			return checkStat(fs6.statSync(path7), options);
+			return checkStat(fs7.statSync(path7), options);
 		}
 		function checkStat(stat, options) {
 			return stat.isFile() && checkMode(stat, options);
@@ -46034,7 +46034,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 	} });
 	var require_isexe = __commonJS({ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var core;
 		if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
 		else core = require_mode();
@@ -46227,7 +46227,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		};
 	} });
 	var require_readShebang = __commonJS({ "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
-		var fs6 = require("fs");
+		var fs7 = require("fs");
 		var shebangCommand = require_shebang_command();
 		function readShebang(command) {
 			const size = 150;
@@ -46239,9 +46239,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			}
 			let fd;
 			try {
-				fd = fs6.openSync(command, "r");
-				fs6.readSync(fd, buffer, 0, size, 0);
-				fs6.closeSync(fd);
+				fd = fs7.openSync(command, "r");
+				fs7.readSync(fd, buffer, 0, size, 0);
+				fs7.closeSync(fd);
 			} catch (e) {}
 			return shebangCommand(buffer.toString());
 		}
@@ -47081,7 +47081,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		var escape = require_escape();
 		var readShebang = require_readShebang();
 		var semver = require_semver();
-		var isWin2 = process.platform === "win32";
+		var isWin3 = process.platform === "win32";
 		var isExecutableRegExp = /\.(?:com|exe)$/i;
 		var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
 		var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
@@ -47096,7 +47096,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			return parsed.file;
 		}
 		function parseNonShell(parsed) {
-			if (!isWin2) return parsed;
+			if (!isWin3) return parsed;
 			const commandFile = detectShebang(parsed);
 			const needsShell = !isExecutableRegExp.test(commandFile);
 			if (parsed.options.forceShell || needsShell) {
@@ -47118,7 +47118,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		function parseShell(parsed) {
 			if (supportsShellOption) return parsed;
 			const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-			if (isWin2) {
+			if (isWin3) {
 				parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
 				parsed.args = [
 					"/d",
@@ -47157,7 +47157,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		module2.exports = parse3;
 	} });
 	var require_enoent = __commonJS({ "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
-		var isWin2 = process.platform === "win32";
+		var isWin3 = process.platform === "win32";
 		function notFoundError(original, syscall) {
 			return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
 				code: "ENOENT",
@@ -47168,7 +47168,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			});
 		}
 		function hookChildProcess(cp, parsed) {
-			if (!isWin2) return;
+			if (!isWin3) return;
 			const originalEmit = cp.emit;
 			cp.emit = function(name, arg1) {
 				if (name === "exit") {
@@ -47179,11 +47179,11 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 			};
 		}
 		function verifyENOENT(status, parsed) {
-			if (isWin2 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+			if (isWin3 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
 			return null;
 		}
 		function verifyENOENTSync(status, parsed) {
-			if (isWin2 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+			if (isWin3 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
 			return null;
 		}
 		module2.exports = {
@@ -52814,6 +52814,1547 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		}
 		module2.exports = (options) => new IgnoreBase(options);
 	} });
+	var require_which2 = __commonJS({ "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+		var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+		var path7 = require("path");
+		var COLON = isWindows ? ";" : ":";
+		var isexe = require_isexe();
+		var getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+		var getPathInfo = (cmd, opt) => {
+			const colon = opt.colon || COLON;
+			const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+			const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+			const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+			if (isWindows) {
+				if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+			}
+			return {
+				pathEnv,
+				pathExt,
+				pathExtExe
+			};
+		};
+		var which = (cmd, opt, cb) => {
+			if (typeof opt === "function") {
+				cb = opt;
+				opt = {};
+			}
+			if (!opt) opt = {};
+			const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+			const found = [];
+			const step = (i) => new Promise((resolve, reject) => {
+				if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+				const ppRaw = pathEnv[i];
+				const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+				const pCmd = path7.join(pathPart, cmd);
+				resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i, 0));
+			});
+			const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+				if (ii === pathExt.length) return resolve(step(i + 1));
+				const ext = pathExt[ii];
+				isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+					if (!er && is) if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+					return resolve(subStep(p, i, ii + 1));
+				});
+			});
+			return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+		};
+		var whichSync = (cmd, opt) => {
+			opt = opt || {};
+			const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+			const found = [];
+			for (let i = 0; i < pathEnv.length; i++) {
+				const ppRaw = pathEnv[i];
+				const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+				const pCmd = path7.join(pathPart, cmd);
+				const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+				for (let j = 0; j < pathExt.length; j++) {
+					const cur = p + pathExt[j];
+					try {
+						if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
+						else return cur;
+					} catch (ex) {}
+				}
+			}
+			if (opt.all && found.length) return found;
+			if (opt.nothrow) return null;
+			throw getNotFoundError(cmd);
+		};
+		module2.exports = which;
+		which.sync = whichSync;
+	} });
+	var require_path_key2 = __commonJS({ "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+		var pathKey = (options = {}) => {
+			const environment = options.env || process.env;
+			if ((options.platform || process.platform) !== "win32") return "PATH";
+			return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+		};
+		module2.exports = pathKey;
+		module2.exports.default = pathKey;
+	} });
+	var require_resolveCommand2 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+		var path7 = require("path");
+		var which = require_which2();
+		var getPathKey = require_path_key2();
+		function resolveCommandAttempt(parsed, withoutPathExt) {
+			const env = parsed.options.env || process.env;
+			const cwd = process.cwd();
+			const hasCustomCwd = parsed.options.cwd != null;
+			const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+			if (shouldSwitchCwd) try {
+				process.chdir(parsed.options.cwd);
+			} catch (err) {}
+			let resolved;
+			try {
+				resolved = which.sync(parsed.command, {
+					path: env[getPathKey({ env })],
+					pathExt: withoutPathExt ? path7.delimiter : void 0
+				});
+			} catch (e) {} finally {
+				if (shouldSwitchCwd) process.chdir(cwd);
+			}
+			if (resolved) resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+			return resolved;
+		}
+		function resolveCommand(parsed) {
+			return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+		}
+		module2.exports = resolveCommand;
+	} });
+	var require_escape2 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+		var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+		function escapeCommand(arg) {
+			arg = arg.replace(metaCharsRegExp, "^$1");
+			return arg;
+		}
+		function escapeArgument(arg, doubleEscapeMetaChars) {
+			arg = `${arg}`;
+			arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+			arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+			arg = `"${arg}"`;
+			arg = arg.replace(metaCharsRegExp, "^$1");
+			if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+			return arg;
+		}
+		module2.exports.command = escapeCommand;
+		module2.exports.argument = escapeArgument;
+	} });
+	var require_shebang_regex2 = __commonJS({ "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+		module2.exports = /^#!(.*)/;
+	} });
+	var require_shebang_command2 = __commonJS({ "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+		var shebangRegex = require_shebang_regex2();
+		module2.exports = (string = "") => {
+			const match = string.match(shebangRegex);
+			if (!match) return null;
+			const [path7, argument] = match[0].replace(/#! ?/, "").split(" ");
+			const binary = path7.split("/").pop();
+			if (binary === "env") return argument;
+			return argument ? `${binary} ${argument}` : binary;
+		};
+	} });
+	var require_readShebang2 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+		var fs7 = require("fs");
+		var shebangCommand = require_shebang_command2();
+		function readShebang(command) {
+			const size = 150;
+			const buffer = Buffer.alloc(size);
+			let fd;
+			try {
+				fd = fs7.openSync(command, "r");
+				fs7.readSync(fd, buffer, 0, size, 0);
+				fs7.closeSync(fd);
+			} catch (e) {}
+			return shebangCommand(buffer.toString());
+		}
+		module2.exports = readShebang;
+	} });
+	var require_parse4 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+		var path7 = require("path");
+		var resolveCommand = require_resolveCommand2();
+		var escape = require_escape2();
+		var readShebang = require_readShebang2();
+		var isWin3 = process.platform === "win32";
+		var isExecutableRegExp = /\.(?:com|exe)$/i;
+		var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+		function detectShebang(parsed) {
+			parsed.file = resolveCommand(parsed);
+			const shebang = parsed.file && readShebang(parsed.file);
+			if (shebang) {
+				parsed.args.unshift(parsed.file);
+				parsed.command = shebang;
+				return resolveCommand(parsed);
+			}
+			return parsed.file;
+		}
+		function parseNonShell(parsed) {
+			if (!isWin3) return parsed;
+			const commandFile = detectShebang(parsed);
+			const needsShell = !isExecutableRegExp.test(commandFile);
+			if (parsed.options.forceShell || needsShell) {
+				const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+				parsed.command = path7.normalize(parsed.command);
+				parsed.command = escape.command(parsed.command);
+				parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+				parsed.args = [
+					"/d",
+					"/s",
+					"/c",
+					`"${[parsed.command].concat(parsed.args).join(" ")}"`
+				];
+				parsed.command = process.env.comspec || "cmd.exe";
+				parsed.options.windowsVerbatimArguments = true;
+			}
+			return parsed;
+		}
+		function parse3(command, args, options) {
+			if (args && !Array.isArray(args)) {
+				options = args;
+				args = null;
+			}
+			args = args ? args.slice(0) : [];
+			options = Object.assign({}, options);
+			const parsed = {
+				command,
+				args,
+				options,
+				file: void 0,
+				original: {
+					command,
+					args
+				}
+			};
+			return options.shell ? parsed : parseNonShell(parsed);
+		}
+		module2.exports = parse3;
+	} });
+	var require_enoent2 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+		var isWin3 = process.platform === "win32";
+		function notFoundError(original, syscall) {
+			return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+				code: "ENOENT",
+				errno: "ENOENT",
+				syscall: `${syscall} ${original.command}`,
+				path: original.command,
+				spawnargs: original.args
+			});
+		}
+		function hookChildProcess(cp, parsed) {
+			if (!isWin3) return;
+			const originalEmit = cp.emit;
+			cp.emit = function(name, arg1) {
+				if (name === "exit") {
+					const err = verifyENOENT(arg1, parsed);
+					if (err) return originalEmit.call(cp, "error", err);
+				}
+				return originalEmit.apply(cp, arguments);
+			};
+		}
+		function verifyENOENT(status, parsed) {
+			if (isWin3 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+			return null;
+		}
+		function verifyENOENTSync(status, parsed) {
+			if (isWin3 && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+			return null;
+		}
+		module2.exports = {
+			hookChildProcess,
+			verifyENOENT,
+			verifyENOENTSync,
+			notFoundError
+		};
+	} });
+	var require_cross_spawn2 = __commonJS({ "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports2, module2) {
+		var cp = require("child_process");
+		var parse3 = require_parse4();
+		var enoent = require_enoent2();
+		function spawn2(command, args, options) {
+			const parsed = parse3(command, args, options);
+			const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+			enoent.hookChildProcess(spawned, parsed);
+			return spawned;
+		}
+		function spawnSync(command, args, options) {
+			const parsed = parse3(command, args, options);
+			const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+			result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+			return result;
+		}
+		module2.exports = spawn2;
+		module2.exports.spawn = spawn2;
+		module2.exports.sync = spawnSync;
+		module2.exports._parse = parse3;
+		module2.exports._enoent = enoent;
+	} });
+	var require_strip_final_newline = __commonJS({ "../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports2, module2) {
+		module2.exports = (input) => {
+			const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+			const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+			if (input[input.length - 1] === LF) input = input.slice(0, input.length - 1);
+			if (input[input.length - 1] === CR) input = input.slice(0, input.length - 1);
+			return input;
+		};
+	} });
+	var require_npm_run_path = __commonJS({ "../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports2, module2) {
+		var path7 = require("path");
+		var pathKey = require_path_key2();
+		var npmRunPath = (options) => {
+			options = {
+				cwd: process.cwd(),
+				path: process.env[pathKey()],
+				execPath: process.execPath,
+				...options
+			};
+			let previous;
+			let cwdPath = path7.resolve(options.cwd);
+			const result = [];
+			while (previous !== cwdPath) {
+				result.push(path7.join(cwdPath, "node_modules/.bin"));
+				previous = cwdPath;
+				cwdPath = path7.resolve(cwdPath, "..");
+			}
+			const execPathDir = path7.resolve(options.cwd, options.execPath, "..");
+			result.push(execPathDir);
+			return result.concat(options.path).join(path7.delimiter);
+		};
+		module2.exports = npmRunPath;
+		module2.exports.default = npmRunPath;
+		module2.exports.env = (options) => {
+			options = {
+				env: process.env,
+				...options
+			};
+			const env = { ...options.env };
+			const path8 = pathKey({ env });
+			options.path = env[path8];
+			env[path8] = module2.exports(options);
+			return env;
+		};
+	} });
+	var require_mimic_fn = __commonJS({ "../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports2, module2) {
+		var mimicFn = (to, from) => {
+			for (const prop of Reflect.ownKeys(from)) Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+			return to;
+		};
+		module2.exports = mimicFn;
+		module2.exports.default = mimicFn;
+	} });
+	var require_onetime = __commonJS({ "../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports2, module2) {
+		var mimicFn = require_mimic_fn();
+		var calledFunctions = /* @__PURE__ */ new WeakMap();
+		var onetime = (function_, options = {}) => {
+			if (typeof function_ !== "function") throw new TypeError("Expected a function");
+			let returnValue;
+			let callCount = 0;
+			const functionName = function_.displayName || function_.name || "<anonymous>";
+			const onetime2 = function(...arguments_) {
+				calledFunctions.set(onetime2, ++callCount);
+				if (callCount === 1) {
+					returnValue = function_.apply(this, arguments_);
+					function_ = null;
+				} else if (options.throw === true) throw new Error(`Function \`${functionName}\` can only be called once`);
+				return returnValue;
+			};
+			mimicFn(onetime2, function_);
+			calledFunctions.set(onetime2, callCount);
+			return onetime2;
+		};
+		module2.exports = onetime;
+		module2.exports.default = onetime;
+		module2.exports.callCount = (function_) => {
+			if (!calledFunctions.has(function_)) throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+			return calledFunctions.get(function_);
+		};
+	} });
+	var require_core2 = __commonJS({ "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/core.js"(exports2) {
+		Object.defineProperty(exports2, "__esModule", { value: true });
+		exports2.SIGNALS = void 0;
+		exports2.SIGNALS = [
+			{
+				name: "SIGHUP",
+				number: 1,
+				action: "terminate",
+				description: "Terminal closed",
+				standard: "posix"
+			},
+			{
+				name: "SIGINT",
+				number: 2,
+				action: "terminate",
+				description: "User interruption with CTRL-C",
+				standard: "ansi"
+			},
+			{
+				name: "SIGQUIT",
+				number: 3,
+				action: "core",
+				description: "User interruption with CTRL-\\",
+				standard: "posix"
+			},
+			{
+				name: "SIGILL",
+				number: 4,
+				action: "core",
+				description: "Invalid machine instruction",
+				standard: "ansi"
+			},
+			{
+				name: "SIGTRAP",
+				number: 5,
+				action: "core",
+				description: "Debugger breakpoint",
+				standard: "posix"
+			},
+			{
+				name: "SIGABRT",
+				number: 6,
+				action: "core",
+				description: "Aborted",
+				standard: "ansi"
+			},
+			{
+				name: "SIGIOT",
+				number: 6,
+				action: "core",
+				description: "Aborted",
+				standard: "bsd"
+			},
+			{
+				name: "SIGBUS",
+				number: 7,
+				action: "core",
+				description: "Bus error due to misaligned, non-existing address or paging error",
+				standard: "bsd"
+			},
+			{
+				name: "SIGEMT",
+				number: 7,
+				action: "terminate",
+				description: "Command should be emulated but is not implemented",
+				standard: "other"
+			},
+			{
+				name: "SIGFPE",
+				number: 8,
+				action: "core",
+				description: "Floating point arithmetic error",
+				standard: "ansi"
+			},
+			{
+				name: "SIGKILL",
+				number: 9,
+				action: "terminate",
+				description: "Forced termination",
+				standard: "posix",
+				forced: true
+			},
+			{
+				name: "SIGUSR1",
+				number: 10,
+				action: "terminate",
+				description: "Application-specific signal",
+				standard: "posix"
+			},
+			{
+				name: "SIGSEGV",
+				number: 11,
+				action: "core",
+				description: "Segmentation fault",
+				standard: "ansi"
+			},
+			{
+				name: "SIGUSR2",
+				number: 12,
+				action: "terminate",
+				description: "Application-specific signal",
+				standard: "posix"
+			},
+			{
+				name: "SIGPIPE",
+				number: 13,
+				action: "terminate",
+				description: "Broken pipe or socket",
+				standard: "posix"
+			},
+			{
+				name: "SIGALRM",
+				number: 14,
+				action: "terminate",
+				description: "Timeout or timer",
+				standard: "posix"
+			},
+			{
+				name: "SIGTERM",
+				number: 15,
+				action: "terminate",
+				description: "Termination",
+				standard: "ansi"
+			},
+			{
+				name: "SIGSTKFLT",
+				number: 16,
+				action: "terminate",
+				description: "Stack is empty or overflowed",
+				standard: "other"
+			},
+			{
+				name: "SIGCHLD",
+				number: 17,
+				action: "ignore",
+				description: "Child process terminated, paused or unpaused",
+				standard: "posix"
+			},
+			{
+				name: "SIGCLD",
+				number: 17,
+				action: "ignore",
+				description: "Child process terminated, paused or unpaused",
+				standard: "other"
+			},
+			{
+				name: "SIGCONT",
+				number: 18,
+				action: "unpause",
+				description: "Unpaused",
+				standard: "posix",
+				forced: true
+			},
+			{
+				name: "SIGSTOP",
+				number: 19,
+				action: "pause",
+				description: "Paused",
+				standard: "posix",
+				forced: true
+			},
+			{
+				name: "SIGTSTP",
+				number: 20,
+				action: "pause",
+				description: "Paused using CTRL-Z or \"suspend\"",
+				standard: "posix"
+			},
+			{
+				name: "SIGTTIN",
+				number: 21,
+				action: "pause",
+				description: "Background process cannot read terminal input",
+				standard: "posix"
+			},
+			{
+				name: "SIGBREAK",
+				number: 21,
+				action: "terminate",
+				description: "User interruption with CTRL-BREAK",
+				standard: "other"
+			},
+			{
+				name: "SIGTTOU",
+				number: 22,
+				action: "pause",
+				description: "Background process cannot write to terminal output",
+				standard: "posix"
+			},
+			{
+				name: "SIGURG",
+				number: 23,
+				action: "ignore",
+				description: "Socket received out-of-band data",
+				standard: "bsd"
+			},
+			{
+				name: "SIGXCPU",
+				number: 24,
+				action: "core",
+				description: "Process timed out",
+				standard: "bsd"
+			},
+			{
+				name: "SIGXFSZ",
+				number: 25,
+				action: "core",
+				description: "File too big",
+				standard: "bsd"
+			},
+			{
+				name: "SIGVTALRM",
+				number: 26,
+				action: "terminate",
+				description: "Timeout or timer",
+				standard: "bsd"
+			},
+			{
+				name: "SIGPROF",
+				number: 27,
+				action: "terminate",
+				description: "Timeout or timer",
+				standard: "bsd"
+			},
+			{
+				name: "SIGWINCH",
+				number: 28,
+				action: "ignore",
+				description: "Terminal window size changed",
+				standard: "bsd"
+			},
+			{
+				name: "SIGIO",
+				number: 29,
+				action: "terminate",
+				description: "I/O is available",
+				standard: "other"
+			},
+			{
+				name: "SIGPOLL",
+				number: 29,
+				action: "terminate",
+				description: "Watched event",
+				standard: "other"
+			},
+			{
+				name: "SIGINFO",
+				number: 29,
+				action: "ignore",
+				description: "Request for process information",
+				standard: "other"
+			},
+			{
+				name: "SIGPWR",
+				number: 30,
+				action: "terminate",
+				description: "Device running out of power",
+				standard: "systemv"
+			},
+			{
+				name: "SIGSYS",
+				number: 31,
+				action: "core",
+				description: "Invalid system call",
+				standard: "other"
+			},
+			{
+				name: "SIGUNUSED",
+				number: 31,
+				action: "terminate",
+				description: "Invalid system call",
+				standard: "other"
+			}
+		];
+	} });
+	var require_realtime = __commonJS({ "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/realtime.js"(exports2) {
+		Object.defineProperty(exports2, "__esModule", { value: true });
+		exports2.SIGRTMAX = exports2.getRealtimeSignals = void 0;
+		var getRealtimeSignals = function() {
+			const length = SIGRTMAX - SIGRTMIN + 1;
+			return Array.from({ length }, getRealtimeSignal);
+		};
+		exports2.getRealtimeSignals = getRealtimeSignals;
+		var getRealtimeSignal = function(value, index) {
+			return {
+				name: `SIGRT${index + 1}`,
+				number: SIGRTMIN + index,
+				action: "terminate",
+				description: "Application-specific signal (realtime)",
+				standard: "posix"
+			};
+		};
+		var SIGRTMIN = 34;
+		var SIGRTMAX = 64;
+		exports2.SIGRTMAX = SIGRTMAX;
+	} });
+	var require_signals = __commonJS({ "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/signals.js"(exports2) {
+		Object.defineProperty(exports2, "__esModule", { value: true });
+		exports2.getSignals = void 0;
+		var _os = require("os");
+		var _core = require_core2();
+		var _realtime = require_realtime();
+		var getSignals = function() {
+			const realtimeSignals = (0, _realtime.getRealtimeSignals)();
+			return [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal);
+		};
+		exports2.getSignals = getSignals;
+		var normalizeSignal = function({ name, number: defaultNumber, description, action, forced = false, standard }) {
+			const { signals: { [name]: constantSignal } } = _os.constants;
+			const supported = constantSignal !== void 0;
+			return {
+				name,
+				number: supported ? constantSignal : defaultNumber,
+				description,
+				supported,
+				action,
+				forced,
+				standard
+			};
+		};
+	} });
+	var require_main = __commonJS({ "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/main.js"(exports2) {
+		Object.defineProperty(exports2, "__esModule", { value: true });
+		exports2.signalsByNumber = exports2.signalsByName = void 0;
+		var _os = require("os");
+		var _signals = require_signals();
+		var _realtime = require_realtime();
+		var getSignalsByName = function() {
+			return (0, _signals.getSignals)().reduce(getSignalByName, {});
+		};
+		var getSignalByName = function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
+			return {
+				...signalByNameMemo,
+				[name]: {
+					name,
+					number,
+					description,
+					supported,
+					action,
+					forced,
+					standard
+				}
+			};
+		};
+		exports2.signalsByName = getSignalsByName();
+		var getSignalsByNumber = function() {
+			const signals = (0, _signals.getSignals)();
+			const length = _realtime.SIGRTMAX + 1;
+			const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
+			return Object.assign({}, ...signalsA);
+		};
+		var getSignalByNumber = function(number, signals) {
+			const signal = findSignalByNumber(number, signals);
+			if (signal === void 0) return {};
+			const { name, description, supported, action, forced, standard } = signal;
+			return { [number]: {
+				name,
+				number,
+				description,
+				supported,
+				action,
+				forced,
+				standard
+			} };
+		};
+		var findSignalByNumber = function(number, signals) {
+			const signal = signals.find(({ name }) => _os.constants.signals[name] === number);
+			if (signal !== void 0) return signal;
+			return signals.find((signalA) => signalA.number === number);
+		};
+		exports2.signalsByNumber = getSignalsByNumber();
+	} });
+	var require_error = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/error.js"(exports2, module2) {
+		var { signalsByName } = require_main();
+		var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+			if (timedOut) return `timed out after ${timeout} milliseconds`;
+			if (isCanceled) return "was canceled";
+			if (errorCode !== void 0) return `failed with ${errorCode}`;
+			if (signal !== void 0) return `was killed with ${signal} (${signalDescription})`;
+			if (exitCode !== void 0) return `failed with exit code ${exitCode}`;
+			return "failed";
+		};
+		var makeError = ({ stdout, stderr, all, error, signal, exitCode, command, timedOut, isCanceled, killed, parsed: { options: { timeout } } }) => {
+			exitCode = exitCode === null ? void 0 : exitCode;
+			signal = signal === null ? void 0 : signal;
+			const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
+			const message = `Command ${getErrorPrefix({
+				timedOut,
+				timeout,
+				errorCode: error && error.code,
+				signal,
+				signalDescription,
+				exitCode,
+				isCanceled
+			})}: ${command}`;
+			if (error instanceof Error) {
+				error.originalMessage = error.message;
+				error.message = `${message}
+${error.message}`;
+			} else error = new Error(message);
+			error.command = command;
+			error.exitCode = exitCode;
+			error.signal = signal;
+			error.signalDescription = signalDescription;
+			error.stdout = stdout;
+			error.stderr = stderr;
+			if (all !== void 0) error.all = all;
+			if ("bufferedData" in error) delete error.bufferedData;
+			error.failed = true;
+			error.timedOut = Boolean(timedOut);
+			error.isCanceled = isCanceled;
+			error.killed = killed && !timedOut;
+			return error;
+		};
+		module2.exports = makeError;
+	} });
+	var require_stdio = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stdio.js"(exports2, module2) {
+		var aliases = [
+			"stdin",
+			"stdout",
+			"stderr"
+		];
+		var hasAlias = (opts) => aliases.some((alias) => opts[alias] !== void 0);
+		var normalizeStdio = (opts) => {
+			if (!opts) return;
+			const { stdio } = opts;
+			if (stdio === void 0) return aliases.map((alias) => opts[alias]);
+			if (hasAlias(opts)) throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+			if (typeof stdio === "string") return stdio;
+			if (!Array.isArray(stdio)) throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+			const length = Math.max(stdio.length, aliases.length);
+			return Array.from({ length }, (value, index) => stdio[index]);
+		};
+		module2.exports = normalizeStdio;
+		module2.exports.node = (opts) => {
+			const stdio = normalizeStdio(opts);
+			if (stdio === "ipc") return "ipc";
+			if (stdio === void 0 || typeof stdio === "string") return [
+				stdio,
+				stdio,
+				stdio,
+				"ipc"
+			];
+			if (stdio.includes("ipc")) return stdio;
+			return [...stdio, "ipc"];
+		};
+	} });
+	var require_signals2 = __commonJS({ "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+		module2.exports = [
+			"SIGABRT",
+			"SIGALRM",
+			"SIGHUP",
+			"SIGINT",
+			"SIGTERM"
+		];
+		if (process.platform !== "win32") module2.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+		if (process.platform === "linux") module2.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+	} });
+	var require_signal_exit = __commonJS({ "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+		var process2 = global.process;
+		var processOk = function(process3) {
+			return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+		};
+		if (!processOk(process2)) module2.exports = function() {
+			return function() {};
+		};
+		else {
+			assert7 = require("assert");
+			signals = require_signals2();
+			isWin3 = /^win/i.test(process2.platform);
+			EE = require("events");
+			if (typeof EE !== "function") EE = EE.EventEmitter;
+			if (process2.__signal_exit_emitter__) emitter = process2.__signal_exit_emitter__;
+			else {
+				emitter = process2.__signal_exit_emitter__ = new EE();
+				emitter.count = 0;
+				emitter.emitted = {};
+			}
+			if (!emitter.infinite) {
+				emitter.setMaxListeners(Infinity);
+				emitter.infinite = true;
+			}
+			module2.exports = function(cb, opts) {
+				if (!processOk(global.process)) return function() {};
+				assert7.equal(typeof cb, "function", "a callback must be provided for exit handler");
+				if (loaded === false) load();
+				var ev = "exit";
+				if (opts && opts.alwaysLast) ev = "afterexit";
+				var remove2 = function() {
+					emitter.removeListener(ev, cb);
+					if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) unload();
+				};
+				emitter.on(ev, cb);
+				return remove2;
+			};
+			unload = function unload2() {
+				if (!loaded || !processOk(global.process)) return;
+				loaded = false;
+				signals.forEach(function(sig) {
+					try {
+						process2.removeListener(sig, sigListeners[sig]);
+					} catch (er) {}
+				});
+				process2.emit = originalProcessEmit;
+				process2.reallyExit = originalProcessReallyExit;
+				emitter.count -= 1;
+			};
+			module2.exports.unload = unload;
+			emit = function emit2(event, code, signal) {
+				if (emitter.emitted[event]) return;
+				emitter.emitted[event] = true;
+				emitter.emit(event, code, signal);
+			};
+			sigListeners = {};
+			signals.forEach(function(sig) {
+				sigListeners[sig] = function listener() {
+					if (!processOk(global.process)) return;
+					if (process2.listeners(sig).length === emitter.count) {
+						unload();
+						emit("exit", null, sig);
+						emit("afterexit", null, sig);
+						if (isWin3 && sig === "SIGHUP") sig = "SIGINT";
+						process2.kill(process2.pid, sig);
+					}
+				};
+			});
+			module2.exports.signals = function() {
+				return signals;
+			};
+			loaded = false;
+			load = function load2() {
+				if (loaded || !processOk(global.process)) return;
+				loaded = true;
+				emitter.count += 1;
+				signals = signals.filter(function(sig) {
+					try {
+						process2.on(sig, sigListeners[sig]);
+						return true;
+					} catch (er) {
+						return false;
+					}
+				});
+				process2.emit = processEmit;
+				process2.reallyExit = processReallyExit;
+			};
+			module2.exports.load = load;
+			originalProcessReallyExit = process2.reallyExit;
+			processReallyExit = function processReallyExit2(code) {
+				if (!processOk(global.process)) return;
+				process2.exitCode = code || 0;
+				emit("exit", process2.exitCode, null);
+				emit("afterexit", process2.exitCode, null);
+				originalProcessReallyExit.call(process2, process2.exitCode);
+			};
+			originalProcessEmit = process2.emit;
+			processEmit = function processEmit2(ev, arg) {
+				if (ev === "exit" && processOk(global.process)) {
+					if (arg !== void 0) process2.exitCode = arg;
+					var ret = originalProcessEmit.apply(this, arguments);
+					emit("exit", process2.exitCode, null);
+					emit("afterexit", process2.exitCode, null);
+					return ret;
+				} else return originalProcessEmit.apply(this, arguments);
+			};
+		}
+		var assert7;
+		var signals;
+		var isWin3;
+		var EE;
+		var emitter;
+		var unload;
+		var emit;
+		var sigListeners;
+		var loaded;
+		var load;
+		var originalProcessReallyExit;
+		var processReallyExit;
+		var originalProcessEmit;
+		var processEmit;
+	} });
+	var require_p_finally = __commonJS({ "../../node_modules/.pnpm/p-finally@2.0.1/node_modules/p-finally/index.js"(exports2, module2) {
+		module2.exports = async (promise, onFinally = () => {}) => {
+			let value;
+			try {
+				value = await promise;
+			} catch (error) {
+				await onFinally();
+				throw error;
+			}
+			await onFinally();
+			return value;
+		};
+	} });
+	var require_kill = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/kill.js"(exports2, module2) {
+		var os = require("os");
+		var onExit = require_signal_exit();
+		var pFinally = require_p_finally();
+		var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+		var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
+			const killResult = kill(signal);
+			setKillTimeout(kill, signal, options, killResult);
+			return killResult;
+		};
+		var setKillTimeout = (kill, signal, options, killResult) => {
+			if (!shouldForceKill(signal, options, killResult)) return;
+			const timeout = getForceKillAfterTimeout(options);
+			setTimeout(() => {
+				kill("SIGKILL");
+			}, timeout).unref();
+		};
+		var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => {
+			return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+		};
+		var isSigterm = (signal) => {
+			return signal === os.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+		};
+		var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
+			if (forceKillAfterTimeout === true) return DEFAULT_FORCE_KILL_TIMEOUT;
+			if (!Number.isInteger(forceKillAfterTimeout) || forceKillAfterTimeout < 0) throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+			return forceKillAfterTimeout;
+		};
+		var spawnedCancel = (spawned, context) => {
+			if (spawned.kill()) context.isCanceled = true;
+		};
+		var timeoutKill = (spawned, signal, reject) => {
+			spawned.kill(signal);
+			reject(Object.assign(/* @__PURE__ */ new Error("Timed out"), {
+				timedOut: true,
+				signal
+			}));
+		};
+		var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+			if (timeout === 0 || timeout === void 0) return spawnedPromise;
+			if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+			let timeoutId;
+			const timeoutPromise = new Promise((resolve, reject) => {
+				timeoutId = setTimeout(() => {
+					timeoutKill(spawned, killSignal, reject);
+				}, timeout);
+			});
+			const safeSpawnedPromise = pFinally(spawnedPromise, () => {
+				clearTimeout(timeoutId);
+			});
+			return Promise.race([timeoutPromise, safeSpawnedPromise]);
+		};
+		var setExitHandler = (spawned, { cleanup, detached }, timedPromise) => {
+			if (!cleanup || detached) return timedPromise;
+			return pFinally(timedPromise, onExit(() => {
+				spawned.kill();
+			}));
+		};
+		module2.exports = {
+			spawnedKill,
+			spawnedCancel,
+			setupTimeout,
+			setExitHandler
+		};
+	} });
+	var require_is_stream = __commonJS({ "../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports2, module2) {
+		var isStream = (stream) => stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+		isStream.writable = (stream) => isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+		isStream.readable = (stream) => isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+		isStream.duplex = (stream) => isStream.writable(stream) && isStream.readable(stream);
+		isStream.transform = (stream) => isStream.duplex(stream) && typeof stream._transform === "function";
+		module2.exports = isStream;
+	} });
+	var require_pump = __commonJS({ "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports2, module2) {
+		var once = require_once();
+		var eos2 = require_end_of_stream();
+		var fs7;
+		try {
+			fs7 = require("fs");
+		} catch (e) {}
+		var noop = function() {};
+		var ancient = /^v?\.0/.test(process.version);
+		var isFn = function(fn) {
+			return typeof fn === "function";
+		};
+		var isFS = function(stream) {
+			if (!ancient) return false;
+			if (!fs7) return false;
+			return (stream instanceof (fs7.ReadStream || noop) || stream instanceof (fs7.WriteStream || noop)) && isFn(stream.close);
+		};
+		var isRequest = function(stream) {
+			return stream.setHeader && isFn(stream.abort);
+		};
+		var destroyer = function(stream, reading, writing, callback) {
+			callback = once(callback);
+			var closed = false;
+			stream.on("close", function() {
+				closed = true;
+			});
+			eos2(stream, {
+				readable: reading,
+				writable: writing
+			}, function(err) {
+				if (err) return callback(err);
+				closed = true;
+				callback();
+			});
+			var destroyed = false;
+			return function(err) {
+				if (closed) return;
+				if (destroyed) return;
+				destroyed = true;
+				if (isFS(stream)) return stream.close(noop);
+				if (isRequest(stream)) return stream.abort();
+				if (isFn(stream.destroy)) return stream.destroy();
+				callback(err || /* @__PURE__ */ new Error("stream was destroyed"));
+			};
+		};
+		var call = function(fn) {
+			fn();
+		};
+		var pipe = function(from, to) {
+			return from.pipe(to);
+		};
+		var pump = function() {
+			var streams = Array.prototype.slice.call(arguments);
+			var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+			if (Array.isArray(streams[0])) streams = streams[0];
+			if (streams.length < 2) throw new Error("pump requires two streams per minimum");
+			var error;
+			var destroys = streams.map(function(stream, i) {
+				var reading = i < streams.length - 1;
+				return destroyer(stream, reading, i > 0, function(err) {
+					if (!error) error = err;
+					if (err) destroys.forEach(call);
+					if (reading) return;
+					destroys.forEach(call);
+					callback(error);
+				});
+			});
+			return streams.reduce(pipe);
+		};
+		module2.exports = pump;
+	} });
+	var require_buffer_stream = __commonJS({ "../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/buffer-stream.js"(exports2, module2) {
+		var { PassThrough: PassThroughStream } = require("stream");
+		module2.exports = (options) => {
+			options = { ...options };
+			const { array } = options;
+			let { encoding } = options;
+			const isBuffer = encoding === "buffer";
+			let objectMode = false;
+			if (array) objectMode = !(encoding || isBuffer);
+			else encoding = encoding || "utf8";
+			if (isBuffer) encoding = null;
+			const stream = new PassThroughStream({ objectMode });
+			if (encoding) stream.setEncoding(encoding);
+			let length = 0;
+			const chunks = [];
+			stream.on("data", (chunk) => {
+				chunks.push(chunk);
+				if (objectMode) length = chunks.length;
+				else length += chunk.length;
+			});
+			stream.getBufferedValue = () => {
+				if (array) return chunks;
+				return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+			};
+			stream.getBufferedLength = () => length;
+			return stream;
+		};
+	} });
+	var require_get_stream = __commonJS({ "../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/index.js"(exports2, module2) {
+		var { constants: BufferConstants } = require("buffer");
+		var pump = require_pump();
+		var bufferStream = require_buffer_stream();
+		var MaxBufferError = class extends Error {
+			constructor() {
+				super("maxBuffer exceeded");
+				this.name = "MaxBufferError";
+			}
+		};
+		async function getStream(inputStream, options) {
+			if (!inputStream) return Promise.reject(/* @__PURE__ */ new Error("Expected a stream"));
+			options = {
+				maxBuffer: Infinity,
+				...options
+			};
+			const { maxBuffer } = options;
+			let stream;
+			await new Promise((resolve, reject) => {
+				const rejectPromise = (error) => {
+					if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) error.bufferedData = stream.getBufferedValue();
+					reject(error);
+				};
+				stream = pump(inputStream, bufferStream(options), (error) => {
+					if (error) {
+						rejectPromise(error);
+						return;
+					}
+					resolve();
+				});
+				stream.on("data", () => {
+					if (stream.getBufferedLength() > maxBuffer) rejectPromise(new MaxBufferError());
+				});
+			});
+			return stream.getBufferedValue();
+		}
+		module2.exports = getStream;
+		module2.exports.default = getStream;
+		module2.exports.buffer = (stream, options) => getStream(stream, {
+			...options,
+			encoding: "buffer"
+		});
+		module2.exports.array = (stream, options) => getStream(stream, {
+			...options,
+			array: true
+		});
+		module2.exports.MaxBufferError = MaxBufferError;
+	} });
+	var require_merge_stream = __commonJS({ "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module2) {
+		var { PassThrough } = require("stream");
+		module2.exports = function() {
+			var sources = [];
+			var output = new PassThrough({ objectMode: true });
+			output.setMaxListeners(0);
+			output.add = add;
+			output.isEmpty = isEmpty;
+			output.on("unpipe", remove2);
+			Array.prototype.slice.call(arguments).forEach(add);
+			return output;
+			function add(source) {
+				if (Array.isArray(source)) {
+					source.forEach(add);
+					return this;
+				}
+				sources.push(source);
+				source.once("end", remove2.bind(null, source));
+				source.once("error", output.emit.bind(output, "error"));
+				source.pipe(output, { end: false });
+				return this;
+			}
+			function isEmpty() {
+				return sources.length == 0;
+			}
+			function remove2(source) {
+				sources = sources.filter(function(it) {
+					return it !== source;
+				});
+				if (!sources.length && output.readable) output.end();
+			}
+		};
+	} });
+	var require_stream2 = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stream.js"(exports2, module2) {
+		var isStream = require_is_stream();
+		var getStream = require_get_stream();
+		var mergeStream = require_merge_stream();
+		var handleInput = (spawned, input) => {
+			if (input === void 0 || spawned.stdin === void 0) return;
+			if (isStream(input)) input.pipe(spawned.stdin);
+			else spawned.stdin.end(input);
+		};
+		var makeAllStream = (spawned, { all }) => {
+			if (!all || !spawned.stdout && !spawned.stderr) return;
+			const mixed = mergeStream();
+			if (spawned.stdout) mixed.add(spawned.stdout);
+			if (spawned.stderr) mixed.add(spawned.stderr);
+			return mixed;
+		};
+		var getBufferedData = async (stream, streamPromise) => {
+			if (!stream) return;
+			stream.destroy();
+			try {
+				return await streamPromise;
+			} catch (error) {
+				return error.bufferedData;
+			}
+		};
+		var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
+			if (!stream || !buffer) return;
+			if (encoding) return getStream(stream, {
+				encoding,
+				maxBuffer
+			});
+			return getStream.buffer(stream, { maxBuffer });
+		};
+		var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
+			const stdoutPromise = getStreamPromise(stdout, {
+				encoding,
+				buffer,
+				maxBuffer
+			});
+			const stderrPromise = getStreamPromise(stderr, {
+				encoding,
+				buffer,
+				maxBuffer
+			});
+			const allPromise = getStreamPromise(all, {
+				encoding,
+				buffer,
+				maxBuffer: maxBuffer * 2
+			});
+			try {
+				return await Promise.all([
+					processDone,
+					stdoutPromise,
+					stderrPromise,
+					allPromise
+				]);
+			} catch (error) {
+				return Promise.all([
+					{
+						error,
+						signal: error.signal,
+						timedOut: error.timedOut
+					},
+					getBufferedData(stdout, stdoutPromise),
+					getBufferedData(stderr, stderrPromise),
+					getBufferedData(all, allPromise)
+				]);
+			}
+		};
+		var validateInputSync = ({ input }) => {
+			if (isStream(input)) throw new TypeError("The `input` option cannot be a stream in sync mode");
+		};
+		module2.exports = {
+			handleInput,
+			makeAllStream,
+			getSpawnedResult,
+			validateInputSync
+		};
+	} });
+	var require_promise = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/promise.js"(exports2, module2) {
+		var mergePromiseProperty = (spawned, promise, property) => {
+			const value = typeof promise === "function" ? (...args) => promise()[property](...args) : promise[property].bind(promise);
+			Object.defineProperty(spawned, property, {
+				value,
+				writable: true,
+				enumerable: false,
+				configurable: true
+			});
+		};
+		var mergePromise = (spawned, promise) => {
+			mergePromiseProperty(spawned, promise, "then");
+			mergePromiseProperty(spawned, promise, "catch");
+			if (Promise.prototype.finally) mergePromiseProperty(spawned, promise, "finally");
+			return spawned;
+		};
+		var getSpawnedPromise = (spawned) => {
+			return new Promise((resolve, reject) => {
+				spawned.on("exit", (exitCode, signal) => {
+					resolve({
+						exitCode,
+						signal
+					});
+				});
+				spawned.on("error", (error) => {
+					reject(error);
+				});
+				if (spawned.stdin) spawned.stdin.on("error", (error) => {
+					reject(error);
+				});
+			});
+		};
+		module2.exports = {
+			mergePromise,
+			getSpawnedPromise
+		};
+	} });
+	var require_command = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/command.js"(exports2, module2) {
+		var SPACES_REGEXP = / +/g;
+		var joinCommand = (file, args = []) => {
+			if (!Array.isArray(args)) return file;
+			return [file, ...args].join(" ");
+		};
+		var handleEscaping = (tokens, token, index) => {
+			if (index === 0) return [token];
+			const previousToken = tokens[tokens.length - 1];
+			if (previousToken.endsWith("\\")) return [...tokens.slice(0, -1), `${previousToken.slice(0, -1)} ${token}`];
+			return [...tokens, token];
+		};
+		var parseCommand = (command) => {
+			return command.trim().split(SPACES_REGEXP).reduce(handleEscaping, []);
+		};
+		module2.exports = {
+			joinCommand,
+			parseCommand
+		};
+	} });
+	var require_execa = __commonJS({ "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/index.js"(exports2, module2) {
+		var path7 = require("path");
+		var childProcess = require("child_process");
+		var crossSpawn = require_cross_spawn2();
+		var stripFinalNewline = require_strip_final_newline();
+		var npmRunPath = require_npm_run_path();
+		var onetime = require_onetime();
+		var makeError = require_error();
+		var normalizeStdio = require_stdio();
+		var { spawnedKill, spawnedCancel, setupTimeout, setExitHandler } = require_kill();
+		var { handleInput, getSpawnedResult, makeAllStream, validateInputSync } = require_stream2();
+		var { mergePromise, getSpawnedPromise } = require_promise();
+		var { joinCommand, parseCommand } = require_command();
+		var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
+		var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+			const env = extendEnv ? {
+				...process.env,
+				...envOption
+			} : envOption;
+			if (preferLocal) return npmRunPath.env({
+				env,
+				cwd: localDir,
+				execPath
+			});
+			return env;
+		};
+		var handleArgs = (file, args, options = {}) => {
+			const parsed = crossSpawn._parse(file, args, options);
+			file = parsed.command;
+			args = parsed.args;
+			options = parsed.options;
+			options = {
+				maxBuffer: DEFAULT_MAX_BUFFER,
+				buffer: true,
+				stripFinalNewline: true,
+				extendEnv: true,
+				preferLocal: false,
+				localDir: options.cwd || process.cwd(),
+				execPath: process.execPath,
+				encoding: "utf8",
+				reject: true,
+				cleanup: true,
+				all: false,
+				...options,
+				windowsHide: true
+			};
+			options.env = getEnv(options);
+			options.stdio = normalizeStdio(options);
+			if (process.platform === "win32" && path7.basename(file, ".exe") === "cmd") args.unshift("/q");
+			return {
+				file,
+				args,
+				options,
+				parsed
+			};
+		};
+		var handleOutput = (options, value, error) => {
+			if (typeof value !== "string" && !Buffer.isBuffer(value)) return error === void 0 ? void 0 : "";
+			if (options.stripFinalNewline) return stripFinalNewline(value);
+			return value;
+		};
+		var execa2 = (file, args, options) => {
+			const parsed = handleArgs(file, args, options);
+			const command = joinCommand(file, args);
+			let spawned;
+			try {
+				spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
+			} catch (error) {
+				return mergePromise(new childProcess.ChildProcess(), Promise.reject(makeError({
+					error,
+					stdout: "",
+					stderr: "",
+					all: "",
+					command,
+					parsed,
+					timedOut: false,
+					isCanceled: false,
+					killed: false
+				})));
+			}
+			const spawnedPromise = getSpawnedPromise(spawned);
+			const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+			const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+			const context = { isCanceled: false };
+			spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+			spawned.cancel = spawnedCancel.bind(null, spawned, context);
+			const handlePromise = async () => {
+				const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+				const stdout = handleOutput(parsed.options, stdoutResult);
+				const stderr = handleOutput(parsed.options, stderrResult);
+				const all = handleOutput(parsed.options, allResult);
+				if (error || exitCode !== 0 || signal !== null) {
+					const returnedError = makeError({
+						error,
+						exitCode,
+						signal,
+						stdout,
+						stderr,
+						all,
+						command,
+						parsed,
+						timedOut,
+						isCanceled: context.isCanceled,
+						killed: spawned.killed
+					});
+					if (!parsed.options.reject) return returnedError;
+					throw returnedError;
+				}
+				return {
+					command,
+					exitCode: 0,
+					stdout,
+					stderr,
+					all,
+					failed: false,
+					timedOut: false,
+					isCanceled: false,
+					killed: false
+				};
+			};
+			const handlePromiseOnce = onetime(handlePromise);
+			crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
+			handleInput(spawned, parsed.options.input);
+			spawned.all = makeAllStream(spawned, parsed.options);
+			return mergePromise(spawned, handlePromiseOnce);
+		};
+		module2.exports = execa2;
+		module2.exports.sync = (file, args, options) => {
+			const parsed = handleArgs(file, args, options);
+			const command = joinCommand(file, args);
+			validateInputSync(parsed.options);
+			let result;
+			try {
+				result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
+			} catch (error) {
+				throw makeError({
+					error,
+					stdout: "",
+					stderr: "",
+					all: "",
+					command,
+					parsed,
+					timedOut: false,
+					isCanceled: false,
+					killed: false
+				});
+			}
+			const stdout = handleOutput(parsed.options, result.stdout, result.error);
+			const stderr = handleOutput(parsed.options, result.stderr, result.error);
+			if (result.error || result.status !== 0 || result.signal !== null) {
+				const error = makeError({
+					stdout,
+					stderr,
+					error: result.error,
+					signal: result.signal,
+					exitCode: result.status,
+					command,
+					parsed,
+					timedOut: result.error && result.error.code === "ETIMEDOUT",
+					isCanceled: false,
+					killed: result.signal !== null
+				});
+				if (!parsed.options.reject) return error;
+				throw error;
+			}
+			return {
+				command,
+				exitCode: 0,
+				stdout,
+				stderr,
+				failed: false,
+				timedOut: false,
+				isCanceled: false,
+				killed: false
+			};
+		};
+		module2.exports.command = (command, options) => {
+			const [file, ...args] = parseCommand(command);
+			return execa2(file, args, options);
+		};
+		module2.exports.commandSync = (command, options) => {
+			const [file, ...args] = parseCommand(command);
+			return execa2.sync(file, args, options);
+		};
+		module2.exports.node = (scriptPath, args, options = {}) => {
+			if (args && !Array.isArray(args) && typeof args === "object") {
+				options = args;
+				args = [];
+			}
+			const stdio = normalizeStdio.node(options);
+			const { nodePath = process.execPath, nodeOptions = process.execArgv } = options;
+			return execa2(nodePath, [
+				...nodeOptions,
+				scriptPath,
+				...Array.isArray(args) ? args : []
+			], {
+				...options,
+				stdin: void 0,
+				stdout: void 0,
+				stderr: void 0,
+				stdio,
+				shell: false
+			});
+		};
+	} });
 	var src_exports = {};
 	__export(src_exports, {
 		BACKEND_FRAMEWORKS: () => BACKEND_FRAMEWORKS,
@@ -52872,6 +54413,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		isDirectory: () => isDirectory,
 		isExperimentalBackendsEnabled: () => isExperimentalBackendsEnabled,
 		isExperimentalBackendsWithoutIntrospectionEnabled: () => isExperimentalBackendsWithoutIntrospectionEnabled,
+		isPythonEntrypoint: () => isPythonEntrypoint,
 		isSymbolicLink: () => isSymbolicLink,
 		normalizePath: () => normalizePath,
 		readConfigFile: () => readConfigFile,
@@ -52882,6 +54424,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJS$1({ "../build-utils/dist/index.j
 		runPackageJsonScript: () => runPackageJsonScript,
 		runPipInstall: () => runPipInstall,
 		runShellScript: () => runShellScript,
+		runStdlibPyScript: () => runStdlibPyScript,
 		scanParentDirs: () => scanParentDirs,
 		shouldServe: () => shouldServe,
 		shouldUseExperimentalBackends: () => shouldUseExperimentalBackends,
@@ -54980,6 +56523,47 @@ ${entrypointsForMessage}`);
 	function shouldUseExperimentalBackends(framework) {
 		return isExperimentalBackendsEnabled() && isBackendFramework(framework);
 	}
+	var import_fs3 = __toESM(require("fs"));
+	var import_path10 = require("path");
+	var import_execa = __toESM(require_execa());
+	var isWin2 = process.platform === "win32";
+	async function runStdlibPyScript(options) {
+		const { scriptName, pythonPath, args = [], cwd } = options;
+		const scriptPath = (0, import_path10.join)(__dirname, "..", "lib", "python", `${scriptName}.py`);
+		if (!import_fs3.default.existsSync(scriptPath)) throw new Error(`Python script not found: ${scriptPath}`);
+		const pythonCmd = pythonPath ?? (isWin2 ? "python" : "python3");
+		debug$2(`Running stdlib Python script: ${pythonCmd} ${scriptPath} ${args.join(" ")}`);
+		try {
+			const result = await (0, import_execa.default)(pythonCmd, [scriptPath, ...args], { cwd });
+			return {
+				exitCode: 0,
+				stdout: result.stdout,
+				stderr: result.stderr
+			};
+		} catch (err) {
+			const execaErr = err;
+			return {
+				exitCode: execaErr.exitCode ?? 1,
+				stdout: execaErr.stdout ?? "",
+				stderr: execaErr.stderr ?? ""
+			};
+		}
+	}
+	async function isPythonEntrypoint(file) {
+		try {
+			const fsPath = file.fsPath;
+			if (!fsPath) return false;
+			const content = await import_fs3.default.promises.readFile(fsPath, "utf-8");
+			if (!content.includes("app") && !content.includes("handler") && !content.includes("Handler")) return false;
+			return (await runStdlibPyScript({
+				scriptName: "ast_parser",
+				args: [fsPath]
+			})).exitCode === 0;
+		} catch (err) {
+			debug$2(`Failed to check Python entrypoint: ${err}`);
+			return false;
+		}
+	}
 }) });
 
 //#endregion