@vixt/react 0.7.4 → 0.8.0

package/dist/index.mjs

@@ -28,8 +28,8 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i$1 = 0, n = keys.length, key; i$1 < n; i$1++) {
-			key = keys[i$1];
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
 			if (!__hasOwnProp.call(to, key) && key !== except) {
 				__defProp(to, key, {
 					get: ((k) => from[k]).bind(null, key),
@@ -52,8 +52,8 @@ var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.fromCallback = function(fn) {
 		return Object.defineProperty(function(...args) {
 			if (typeof args[args.length - 1] === "function") fn.apply(this, args);
-			else return new Promise((resolve$1, reject) => {
-				args.push((err, res) => err != null ? reject(err) : resolve$1(res));
+			else return new Promise((resolve, reject) => {
+				args.push((err, res) => err != null ? reject(err) : resolve(res));
 				fn.apply(this, args);
 			});
 		}, "name", { value: fn.name });
@@ -64,7 +64,7 @@ var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
 			if (typeof cb !== "function") return fn.apply(this, args);
 			else {
 				args.pop();
-				fn.apply(this, args).then((r$1) => cb(null, r$1), cb);
+				fn.apply(this, args).then((r) => cb(null, r), cb);
 			}
 		}, "name", { value: fn.name });
 	};
@@ -93,47 +93,47 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
 	}
 	module.exports = patch;
-	function patch(fs$5) {
-		if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs$5);
-		if (!fs$5.lutimes) patchLutimes(fs$5);
-		fs$5.chown = chownFix(fs$5.chown);
-		fs$5.fchown = chownFix(fs$5.fchown);
-		fs$5.lchown = chownFix(fs$5.lchown);
-		fs$5.chmod = chmodFix(fs$5.chmod);
-		fs$5.fchmod = chmodFix(fs$5.fchmod);
-		fs$5.lchmod = chmodFix(fs$5.lchmod);
-		fs$5.chownSync = chownFixSync(fs$5.chownSync);
-		fs$5.fchownSync = chownFixSync(fs$5.fchownSync);
-		fs$5.lchownSync = chownFixSync(fs$5.lchownSync);
-		fs$5.chmodSync = chmodFixSync(fs$5.chmodSync);
-		fs$5.fchmodSync = chmodFixSync(fs$5.fchmodSync);
-		fs$5.lchmodSync = chmodFixSync(fs$5.lchmodSync);
-		fs$5.stat = statFix(fs$5.stat);
-		fs$5.fstat = statFix(fs$5.fstat);
-		fs$5.lstat = statFix(fs$5.lstat);
-		fs$5.statSync = statFixSync(fs$5.statSync);
-		fs$5.fstatSync = statFixSync(fs$5.fstatSync);
-		fs$5.lstatSync = statFixSync(fs$5.lstatSync);
-		if (fs$5.chmod && !fs$5.lchmod) {
-			fs$5.lchmod = function(path$13, mode, cb) {
+	function patch(fs) {
+		if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs);
+		if (!fs.lutimes) patchLutimes(fs);
+		fs.chown = chownFix(fs.chown);
+		fs.fchown = chownFix(fs.fchown);
+		fs.lchown = chownFix(fs.lchown);
+		fs.chmod = chmodFix(fs.chmod);
+		fs.fchmod = chmodFix(fs.fchmod);
+		fs.lchmod = chmodFix(fs.lchmod);
+		fs.chownSync = chownFixSync(fs.chownSync);
+		fs.fchownSync = chownFixSync(fs.fchownSync);
+		fs.lchownSync = chownFixSync(fs.lchownSync);
+		fs.chmodSync = chmodFixSync(fs.chmodSync);
+		fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+		fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+		fs.stat = statFix(fs.stat);
+		fs.fstat = statFix(fs.fstat);
+		fs.lstat = statFix(fs.lstat);
+		fs.statSync = statFixSync(fs.statSync);
+		fs.fstatSync = statFixSync(fs.fstatSync);
+		fs.lstatSync = statFixSync(fs.lstatSync);
+		if (fs.chmod && !fs.lchmod) {
+			fs.lchmod = function(path, mode, cb) {
 				if (cb) process.nextTick(cb);
 			};
-			fs$5.lchmodSync = function() {};
+			fs.lchmodSync = function() {};
 		}
-		if (fs$5.chown && !fs$5.lchown) {
-			fs$5.lchown = function(path$13, uid, gid, cb) {
+		if (fs.chown && !fs.lchown) {
+			fs.lchown = function(path, uid, gid, cb) {
 				if (cb) process.nextTick(cb);
 			};
-			fs$5.lchownSync = function() {};
+			fs.lchownSync = function() {};
 		}
-		if (platform === "win32") fs$5.rename = typeof fs$5.rename !== "function" ? fs$5.rename : (function(fs$rename) {
+		if (platform === "win32") fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
 			function rename(from, to, cb) {
 				var start = Date.now();
 				var backoff = 0;
 				fs$rename(from, to, function CB(er) {
 					if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
 						setTimeout(function() {
-							fs$5.stat(to, function(stater, st) {
+							fs.stat(to, function(stater, st) {
 								if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
 								else cb(er);
 							});
@@ -146,30 +146,30 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 			if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
 			return rename;
-		})(fs$5.rename);
-		fs$5.read = typeof fs$5.read !== "function" ? fs$5.read : (function(fs$read) {
-			function read$1(fd, buffer, offset, length, position, callback_) {
+		})(fs.rename);
+		fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+			function read(fd, buffer, offset, length, position, callback_) {
 				var callback;
 				if (callback_ && typeof callback_ === "function") {
 					var eagCounter = 0;
 					callback = function(er, _, __) {
 						if (er && er.code === "EAGAIN" && eagCounter < 10) {
 							eagCounter++;
-							return fs$read.call(fs$5, fd, buffer, offset, length, position, callback);
+							return fs$read.call(fs, fd, buffer, offset, length, position, callback);
 						}
 						callback_.apply(this, arguments);
 					};
 				}
-				return fs$read.call(fs$5, fd, buffer, offset, length, position, callback);
+				return fs$read.call(fs, fd, buffer, offset, length, position, callback);
 			}
-			if (Object.setPrototypeOf) Object.setPrototypeOf(read$1, fs$read);
-			return read$1;
-		})(fs$5.read);
-		fs$5.readSync = typeof fs$5.readSync !== "function" ? fs$5.readSync : (function(fs$readSync) {
+			if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+			return read;
+		})(fs.read);
+		fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : (function(fs$readSync) {
 			return function(fd, buffer, offset, length, position) {
 				var eagCounter = 0;
 				while (true) try {
-					return fs$readSync.call(fs$5, fd, buffer, offset, length, position);
+					return fs$readSync.call(fs, fd, buffer, offset, length, position);
 				} catch (er) {
 					if (er.code === "EAGAIN" && eagCounter < 10) {
 						eagCounter++;
@@ -178,78 +178,78 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					throw er;
 				}
 			};
-		})(fs$5.readSync);
-		function patchLchmod(fs$6) {
-			fs$6.lchmod = function(path$13, mode, callback) {
-				fs$6.open(path$13, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+		})(fs.readSync);
+		function patchLchmod(fs) {
+			fs.lchmod = function(path, mode, callback) {
+				fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
 					if (err) {
 						if (callback) callback(err);
 						return;
 					}
-					fs$6.fchmod(fd, mode, function(err$1) {
-						fs$6.close(fd, function(err2) {
-							if (callback) callback(err$1 || err2);
+					fs.fchmod(fd, mode, function(err) {
+						fs.close(fd, function(err2) {
+							if (callback) callback(err || err2);
 						});
 					});
 				});
 			};
-			fs$6.lchmodSync = function(path$13, mode) {
-				var fd = fs$6.openSync(path$13, constants.O_WRONLY | constants.O_SYMLINK, mode);
+			fs.lchmodSync = function(path, mode) {
+				var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
 				var threw = true;
 				var ret;
 				try {
-					ret = fs$6.fchmodSync(fd, mode);
+					ret = fs.fchmodSync(fd, mode);
 					threw = false;
 				} finally {
 					if (threw) try {
-						fs$6.closeSync(fd);
+						fs.closeSync(fd);
 					} catch (er) {}
-					else fs$6.closeSync(fd);
+					else fs.closeSync(fd);
 				}
 				return ret;
 			};
 		}
-		function patchLutimes(fs$6) {
-			if (constants.hasOwnProperty("O_SYMLINK") && fs$6.futimes) {
-				fs$6.lutimes = function(path$13, at, mt, cb) {
-					fs$6.open(path$13, constants.O_SYMLINK, function(er, fd) {
+		function patchLutimes(fs) {
+			if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+				fs.lutimes = function(path, at, mt, cb) {
+					fs.open(path, constants.O_SYMLINK, function(er, fd) {
 						if (er) {
 							if (cb) cb(er);
 							return;
 						}
-						fs$6.futimes(fd, at, mt, function(er$1) {
-							fs$6.close(fd, function(er2) {
-								if (cb) cb(er$1 || er2);
+						fs.futimes(fd, at, mt, function(er) {
+							fs.close(fd, function(er2) {
+								if (cb) cb(er || er2);
 							});
 						});
 					});
 				};
-				fs$6.lutimesSync = function(path$13, at, mt) {
-					var fd = fs$6.openSync(path$13, constants.O_SYMLINK);
+				fs.lutimesSync = function(path, at, mt) {
+					var fd = fs.openSync(path, constants.O_SYMLINK);
 					var ret;
 					var threw = true;
 					try {
-						ret = fs$6.futimesSync(fd, at, mt);
+						ret = fs.futimesSync(fd, at, mt);
 						threw = false;
 					} finally {
 						if (threw) try {
-							fs$6.closeSync(fd);
+							fs.closeSync(fd);
 						} catch (er) {}
-						else fs$6.closeSync(fd);
+						else fs.closeSync(fd);
 					}
 					return ret;
 				};
-			} else if (fs$6.futimes) {
-				fs$6.lutimes = function(_a, _b, _c, cb) {
+			} else if (fs.futimes) {
+				fs.lutimes = function(_a, _b, _c, cb) {
 					if (cb) process.nextTick(cb);
 				};
-				fs$6.lutimesSync = function() {};
+				fs.lutimesSync = function() {};
 			}
 		}
 		function chmodFix(orig) {
 			if (!orig) return orig;
 			return function(target, mode, cb) {
-				return orig.call(fs$5, target, mode, function(er) {
+				return orig.call(fs, target, mode, function(er) {
 					if (chownErOk(er)) er = null;
 					if (cb) cb.apply(this, arguments);
 				});
@@ -259,7 +259,7 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (!orig) return orig;
 			return function(target, mode) {
 				try {
-					return orig.call(fs$5, target, mode);
+					return orig.call(fs, target, mode);
 				} catch (er) {
 					if (!chownErOk(er)) throw er;
 				}
@@ -268,7 +268,7 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		function chownFix(orig) {
 			if (!orig) return orig;
 			return function(target, uid, gid, cb) {
-				return orig.call(fs$5, target, uid, gid, function(er) {
+				return orig.call(fs, target, uid, gid, function(er) {
 					if (chownErOk(er)) er = null;
 					if (cb) cb.apply(this, arguments);
 				});
@@ -278,7 +278,7 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (!orig) return orig;
 			return function(target, uid, gid) {
 				try {
-					return orig.call(fs$5, target, uid, gid);
+					return orig.call(fs, target, uid, gid);
 				} catch (er) {
 					if (!chownErOk(er)) throw er;
 				}
@@ -298,13 +298,13 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					}
 					if (cb) cb.apply(this, arguments);
 				}
-				return options ? orig.call(fs$5, target, options, callback) : orig.call(fs$5, target, callback);
+				return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
 			};
 		}
 		function statFixSync(orig) {
 			if (!orig) return orig;
 			return function(target, options) {
-				var stats = options ? orig.call(fs$5, target, options) : orig.call(fs$5, target);
+				var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
 				if (stats) {
 					if (stats.uid < 0) stats.uid += 4294967296;
 					if (stats.gid < 0) stats.gid += 4294967296;
@@ -328,16 +328,16 @@ var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var Stream = __require("stream").Stream;
 	module.exports = legacy;
-	function legacy(fs$5) {
+	function legacy(fs) {
 		return {
 			ReadStream,
 			WriteStream
 		};
-		function ReadStream(path$13, options) {
-			if (!(this instanceof ReadStream)) return new ReadStream(path$13, options);
+		function ReadStream(path, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path, options);
 			Stream.call(this);
 			var self = this;
-			this.path = path$13;
+			this.path = path;
 			this.fd = null;
 			this.readable = true;
 			this.paused = false;
@@ -364,7 +364,7 @@ var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 				});
 				return;
 			}
-			fs$5.open(this.path, this.flags, this.mode, function(err, fd) {
+			fs.open(this.path, this.flags, this.mode, function(err, fd) {
 				if (err) {
 					self.emit("error", err);
 					self.readable = false;
@@ -375,10 +375,10 @@ var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 				self._read();
 			});
 		}
-		function WriteStream(path$13, options) {
-			if (!(this instanceof WriteStream)) return new WriteStream(path$13, options);
+		function WriteStream(path, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path, options);
 			Stream.call(this);
-			this.path = path$13;
+			this.path = path;
 			this.fd = null;
 			this.writable = true;
 			this.flags = "w";
@@ -399,7 +399,7 @@ var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 			this.busy = false;
 			this._queue = [];
 			if (this.fd === null) {
-				this._open = fs$5.open;
+				this._open = fs.open;
 				this._queue.push([
 					this._open,
 					this.path,
@@ -494,124 +494,124 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		module.exports = patch(fs$4);
 		fs$4.__patched = true;
 	}
-	function patch(fs$5) {
-		polyfills(fs$5);
-		fs$5.gracefulify = patch;
-		fs$5.createReadStream = createReadStream;
-		fs$5.createWriteStream = createWriteStream;
-		var fs$readFile = fs$5.readFile;
-		fs$5.readFile = readFile;
-		function readFile(path$13, options, cb) {
+	function patch(fs) {
+		polyfills(fs);
+		fs.gracefulify = patch;
+		fs.createReadStream = createReadStream;
+		fs.createWriteStream = createWriteStream;
+		var fs$readFile = fs.readFile;
+		fs.readFile = readFile;
+		function readFile(path, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
-			return go$readFile(path$13, options, cb);
-			function go$readFile(path$14, options$1, cb$1, startTime) {
-				return fs$readFile(path$14, options$1, function(err) {
+			return go$readFile(path, options, cb);
+			function go$readFile(path, options, cb, startTime) {
+				return fs$readFile(path, options, function(err) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$readFile,
 						[
-							path$14,
-							options$1,
-							cb$1
+							path,
+							options,
+							cb
 						],
 						err,
 						startTime || Date.now(),
 						Date.now()
 					]);
-					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+					else if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 		}
-		var fs$writeFile = fs$5.writeFile;
-		fs$5.writeFile = writeFile;
-		function writeFile(path$13, data$1, options, cb) {
+		var fs$writeFile = fs.writeFile;
+		fs.writeFile = writeFile;
+		function writeFile(path, data, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
-			return go$writeFile(path$13, data$1, options, cb);
-			function go$writeFile(path$14, data$2, options$1, cb$1, startTime) {
-				return fs$writeFile(path$14, data$2, options$1, function(err) {
+			return go$writeFile(path, data, options, cb);
+			function go$writeFile(path, data, options, cb, startTime) {
+				return fs$writeFile(path, data, options, function(err) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$writeFile,
 						[
-							path$14,
-							data$2,
-							options$1,
-							cb$1
+							path,
+							data,
+							options,
+							cb
 						],
 						err,
 						startTime || Date.now(),
 						Date.now()
 					]);
-					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+					else if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 		}
-		var fs$appendFile = fs$5.appendFile;
-		if (fs$appendFile) fs$5.appendFile = appendFile;
-		function appendFile(path$13, data$1, options, cb) {
+		var fs$appendFile = fs.appendFile;
+		if (fs$appendFile) fs.appendFile = appendFile;
+		function appendFile(path, data, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
-			return go$appendFile(path$13, data$1, options, cb);
-			function go$appendFile(path$14, data$2, options$1, cb$1, startTime) {
-				return fs$appendFile(path$14, data$2, options$1, function(err) {
+			return go$appendFile(path, data, options, cb);
+			function go$appendFile(path, data, options, cb, startTime) {
+				return fs$appendFile(path, data, options, function(err) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$appendFile,
 						[
-							path$14,
-							data$2,
-							options$1,
-							cb$1
+							path,
+							data,
+							options,
+							cb
 						],
 						err,
 						startTime || Date.now(),
 						Date.now()
 					]);
-					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+					else if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 		}
-		var fs$copyFile = fs$5.copyFile;
-		if (fs$copyFile) fs$5.copyFile = copyFile;
+		var fs$copyFile = fs.copyFile;
+		if (fs$copyFile) fs.copyFile = copyFile;
 		function copyFile(src, dest, flags, cb) {
 			if (typeof flags === "function") {
 				cb = flags;
 				flags = 0;
 			}
 			return go$copyFile(src, dest, flags, cb);
-			function go$copyFile(src$1, dest$1, flags$1, cb$1, startTime) {
-				return fs$copyFile(src$1, dest$1, flags$1, function(err) {
+			function go$copyFile(src, dest, flags, cb, startTime) {
+				return fs$copyFile(src, dest, flags, function(err) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$copyFile,
 						[
-							src$1,
-							dest$1,
-							flags$1,
-							cb$1
+							src,
+							dest,
+							flags,
+							cb
 						],
 						err,
 						startTime || Date.now(),
 						Date.now()
 					]);
-					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+					else if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 		}
-		var fs$readdir = fs$5.readdir;
-		fs$5.readdir = readdir;
+		var fs$readdir = fs.readdir;
+		fs.readdir = readdir;
 		var noReaddirOptionVersions = /^v[0-5]\./;
-		function readdir(path$13, options, cb) {
+		function readdir(path, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
-			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir$1(path$14, options$1, cb$1, startTime) {
-				return fs$readdir(path$14, fs$readdirCallback(path$14, options$1, cb$1, startTime));
-			} : function go$readdir$1(path$14, options$1, cb$1, startTime) {
-				return fs$readdir(path$14, options$1, fs$readdirCallback(path$14, options$1, cb$1, startTime));
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+			} : function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
 			};
-			return go$readdir(path$13, options, cb);
-			function fs$readdirCallback(path$14, options$1, cb$1, startTime) {
+			return go$readdir(path, options, cb);
+			function fs$readdirCallback(path, options, cb, startTime) {
 				return function(err, files) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$readdir,
 						[
-							path$14,
-							options$1,
-							cb$1
+							path,
+							options,
+							cb
 						],
 						err,
 						startTime || Date.now(),
@@ -619,27 +619,27 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					]);
 					else {
 						if (files && files.sort) files.sort();
-						if (typeof cb$1 === "function") cb$1.call(this, err, files);
+						if (typeof cb === "function") cb.call(this, err, files);
 					}
 				};
 			}
 		}
 		if (process.version.substr(0, 4) === "v0.8") {
-			var legStreams = legacy(fs$5);
+			var legStreams = legacy(fs);
 			ReadStream = legStreams.ReadStream;
 			WriteStream = legStreams.WriteStream;
 		}
-		var fs$ReadStream = fs$5.ReadStream;
+		var fs$ReadStream = fs.ReadStream;
 		if (fs$ReadStream) {
 			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
 			ReadStream.prototype.open = ReadStream$open;
 		}
-		var fs$WriteStream = fs$5.WriteStream;
+		var fs$WriteStream = fs.WriteStream;
 		if (fs$WriteStream) {
 			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
 			WriteStream.prototype.open = WriteStream$open;
 		}
-		Object.defineProperty(fs$5, "ReadStream", {
+		Object.defineProperty(fs, "ReadStream", {
 			get: function() {
 				return ReadStream;
 			},
@@ -649,7 +649,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			enumerable: true,
 			configurable: true
 		});
-		Object.defineProperty(fs$5, "WriteStream", {
+		Object.defineProperty(fs, "WriteStream", {
 			get: function() {
 				return WriteStream;
 			},
@@ -660,7 +660,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			configurable: true
 		});
 		var FileReadStream = ReadStream;
-		Object.defineProperty(fs$5, "FileReadStream", {
+		Object.defineProperty(fs, "FileReadStream", {
 			get: function() {
 				return FileReadStream;
 			},
@@ -671,7 +671,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			configurable: true
 		});
 		var FileWriteStream = WriteStream;
-		Object.defineProperty(fs$5, "FileWriteStream", {
+		Object.defineProperty(fs, "FileWriteStream", {
 			get: function() {
 				return FileWriteStream;
 			},
@@ -681,7 +681,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			enumerable: true,
 			configurable: true
 		});
-		function ReadStream(path$13, options) {
+		function ReadStream(path, options) {
 			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
 			else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
 		}
@@ -698,7 +698,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				}
 			});
 		}
-		function WriteStream(path$13, options) {
+		function WriteStream(path, options) {
 			if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
 			else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
 		}
@@ -714,36 +714,36 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				}
 			});
 		}
-		function createReadStream(path$13, options) {
-			return new fs$5.ReadStream(path$13, options);
+		function createReadStream(path, options) {
+			return new fs.ReadStream(path, options);
 		}
-		function createWriteStream(path$13, options) {
-			return new fs$5.WriteStream(path$13, options);
+		function createWriteStream(path, options) {
+			return new fs.WriteStream(path, options);
 		}
-		var fs$open = fs$5.open;
-		fs$5.open = open;
-		function open(path$13, flags, mode, cb) {
+		var fs$open = fs.open;
+		fs.open = open;
+		function open(path, flags, mode, cb) {
 			if (typeof mode === "function") cb = mode, mode = null;
-			return go$open(path$13, flags, mode, cb);
-			function go$open(path$14, flags$1, mode$1, cb$1, startTime) {
-				return fs$open(path$14, flags$1, mode$1, function(err, fd) {
+			return go$open(path, flags, mode, cb);
+			function go$open(path, flags, mode, cb, startTime) {
+				return fs$open(path, flags, mode, function(err, fd) {
 					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
 						go$open,
 						[
-							path$14,
-							flags$1,
-							mode$1,
-							cb$1
+							path,
+							flags,
+							mode,
+							cb
 						],
 						err,
 						startTime || Date.now(),
 						Date.now()
 					]);
-					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+					else if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 		}
-		return fs$5;
+		return fs;
 	}
 	function enqueue(elem) {
 		debug("ENQUEUE", elem[0].name, elem[1]);
@@ -753,9 +753,9 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var retryTimer;
 	function resetQueue() {
 		var now = Date.now();
-		for (var i$1 = 0; i$1 < fs$4[gracefulQueue].length; ++i$1) if (fs$4[gracefulQueue][i$1].length > 2) {
-			fs$4[gracefulQueue][i$1][3] = now;
-			fs$4[gracefulQueue][i$1][4] = now;
+		for (var i = 0; i < fs$4[gracefulQueue].length; ++i) if (fs$4[gracefulQueue][i].length > 2) {
+			fs$4[gracefulQueue][i][3] = now;
+			fs$4[gracefulQueue][i][4] = now;
 		}
 		retry();
 	}
@@ -841,54 +841,54 @@ var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	});
 	exports.exists = function(filename, callback) {
 		if (typeof callback === "function") return fs.exists(filename, callback);
-		return new Promise((resolve$1) => {
-			return fs.exists(filename, resolve$1);
+		return new Promise((resolve) => {
+			return fs.exists(filename, resolve);
 		});
 	};
 	exports.read = function(fd, buffer, offset, length, position, callback) {
 		if (typeof callback === "function") return fs.read(fd, buffer, offset, length, position, callback);
-		return new Promise((resolve$1, reject) => {
-			fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer$1) => {
+		return new Promise((resolve, reject) => {
+			fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
 				if (err) return reject(err);
-				resolve$1({
+				resolve({
 					bytesRead,
-					buffer: buffer$1
+					buffer
 				});
 			});
 		});
 	};
 	exports.write = function(fd, buffer, ...args) {
 		if (typeof args[args.length - 1] === "function") return fs.write(fd, buffer, ...args);
-		return new Promise((resolve$1, reject) => {
-			fs.write(fd, buffer, ...args, (err, bytesWritten, buffer$1) => {
+		return new Promise((resolve, reject) => {
+			fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
 				if (err) return reject(err);
-				resolve$1({
+				resolve({
 					bytesWritten,
-					buffer: buffer$1
+					buffer
 				});
 			});
 		});
 	};
 	exports.readv = function(fd, buffers, ...args) {
 		if (typeof args[args.length - 1] === "function") return fs.readv(fd, buffers, ...args);
-		return new Promise((resolve$1, reject) => {
-			fs.readv(fd, buffers, ...args, (err, bytesRead, buffers$1) => {
+		return new Promise((resolve, reject) => {
+			fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
 				if (err) return reject(err);
-				resolve$1({
+				resolve({
 					bytesRead,
-					buffers: buffers$1
+					buffers
 				});
 			});
 		});
 	};
 	exports.writev = function(fd, buffers, ...args) {
 		if (typeof args[args.length - 1] === "function") return fs.writev(fd, buffers, ...args);
-		return new Promise((resolve$1, reject) => {
-			fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers$1) => {
+		return new Promise((resolve, reject) => {
+			fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
 				if (err) return reject(err);
-				resolve$1({
+				resolve({
 					bytesWritten,
-					buffers: buffers$1
+					buffers
 				});
 			});
 		});
@@ -962,8 +962,8 @@ var require_mkdirs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_path_exists = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const u = require_universalify().fromPromise;
 	const fs = require_fs();
-	function pathExists(path$13) {
-		return fs.access(path$13).then(() => true).catch(() => false);
+	function pathExists(path) {
+		return fs.access(path).then(() => true).catch(() => false);
 	}
 	module.exports = {
 		pathExists: u(pathExists),
@@ -976,8 +976,8 @@ var require_path_exists = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_utimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const fs = require_fs();
 	const u = require_universalify().fromPromise;
-	async function utimesMillis(path$13, atime, mtime) {
-		const fd = await fs.open(path$13, "r+");
+	async function utimesMillis(path, atime, mtime) {
+		const fd = await fs.open(path, "r+");
 		let closeErr = null;
 		try {
 			await fs.futimes(fd, atime, mtime);
@@ -990,8 +990,8 @@ var require_utimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		if (closeErr) throw closeErr;
 	}
-	function utimesMillisSync(path$13, atime, mtime) {
-		const fd = fs.openSync(path$13, "r+");
+	function utimesMillisSync(path, atime, mtime) {
+		const fd = fs.openSync(path, "r+");
 		fs.futimesSync(fd, atime, mtime);
 		return fs.closeSync(fd);
 	}
@@ -1111,9 +1111,9 @@ var require_stat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
 	}
 	function isSrcSubdir(src, dest) {
-		const srcArr = path$11.resolve(src).split(path$11.sep).filter((i$1) => i$1);
-		const destArr = path$11.resolve(dest).split(path$11.sep).filter((i$1) => i$1);
-		return srcArr.every((cur, i$1) => destArr[i$1] === cur);
+		const srcArr = path$11.resolve(src).split(path$11.sep).filter((i) => i);
+		const destArr = path$11.resolve(dest).split(path$11.sep).filter((i) => i);
+		return srcArr.every((cur, i) => destArr[i] === cur);
 	}
 	function errMsg(src, dest, funcName) {
 		return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
@@ -1205,8 +1205,8 @@ var require_copy$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const srcItem = path$10.join(src, item.name);
 			const destItem = path$10.join(dest, item.name);
 			if (await runFilter(srcItem, destItem, opts)) {
-				const { destStat: destStat$1 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
-				await getStatsAndPerformCopy(destStat$1, srcItem, destItem, opts);
+				const { destStat } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+				await getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
 			}
 		});
 		if (!destStat) await fs.chmod(dest, srcStat.mode);
@@ -1362,14 +1362,14 @@ var require_copy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_remove = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const fs = require_graceful_fs();
 	const u = require_universalify().fromCallback;
-	function remove(path$13, callback) {
-		fs.rm(path$13, {
+	function remove(path, callback) {
+		fs.rm(path, {
 			recursive: true,
 			force: true
 		}, callback);
 	}
-	function removeSync(path$13) {
-		fs.rmSync(path$13, {
+	function removeSync(path) {
+		fs.rmSync(path, {
 			recursive: true,
 			force: true
 		});
@@ -1649,9 +1649,9 @@ var require_symlink = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const [srcStat, dstStat] = await Promise.all([fs.stat(srcpath), fs.stat(dstpath)]);
 			if (areIdentical(srcStat, dstStat)) return;
 		}
-		const relative$1 = await symlinkPaths(srcpath, dstpath);
-		srcpath = relative$1.toDst;
-		const toType = await symlinkType(relative$1.toCwd, type);
+		const relative = await symlinkPaths(srcpath, dstpath);
+		srcpath = relative.toDst;
+		const toType = await symlinkType(relative.toCwd, type);
 		const dir = path$4.dirname(dstpath);
 		if (!await pathExists(dir)) await mkdirs(dir);
 		return fs.symlink(srcpath, dstpath, toType);
@@ -1664,9 +1664,9 @@ var require_symlink = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (stats && stats.isSymbolicLink()) {
 			if (areIdentical(fs.statSync(srcpath), fs.statSync(dstpath))) return;
 		}
-		const relative$1 = symlinkPathsSync(srcpath, dstpath);
-		srcpath = relative$1.toDst;
-		type = symlinkTypeSync(relative$1.toCwd, type);
+		const relative = symlinkPathsSync(srcpath, dstpath);
+		srcpath = relative.toDst;
+		type = symlinkTypeSync(relative.toCwd, type);
 		const dir = path$4.dirname(dstpath);
 		if (fs.existsSync(dir)) return fs.symlinkSync(srcpath, dstpath, type);
 		mkdirsSync(dir);
@@ -1730,13 +1730,13 @@ var require_jsonfile$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { stringify, stripBom } = require_utils();
 	async function _readFile(file, options = {}) {
 		if (typeof options === "string") options = { encoding: options };
-		const fs$5 = options.fs || _fs;
+		const fs = options.fs || _fs;
 		const shouldThrow = "throws" in options ? options.throws : true;
-		let data$1 = await universalify.fromCallback(fs$5.readFile)(file, options);
-		data$1 = stripBom(data$1);
+		let data = await universalify.fromCallback(fs.readFile)(file, options);
+		data = stripBom(data);
 		let obj;
 		try {
-			obj = JSON.parse(data$1, options ? options.reviver : null);
+			obj = JSON.parse(data, options ? options.reviver : null);
 		} catch (err) {
 			if (shouldThrow) {
 				err.message = `${file}: ${err.message}`;
@@ -1748,10 +1748,10 @@ var require_jsonfile$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const readFile = universalify.fromPromise(_readFile);
 	function readFileSync(file, options = {}) {
 		if (typeof options === "string") options = { encoding: options };
-		const fs$5 = options.fs || _fs;
+		const fs = options.fs || _fs;
 		const shouldThrow = "throws" in options ? options.throws : true;
 		try {
-			let content = fs$5.readFileSync(file, options);
+			let content = fs.readFileSync(file, options);
 			content = stripBom(content);
 			return JSON.parse(content, options.reviver);
 		} catch (err) {
@@ -1762,15 +1762,15 @@ var require_jsonfile$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	}
 	async function _writeFile(file, obj, options = {}) {
-		const fs$5 = options.fs || _fs;
+		const fs = options.fs || _fs;
 		const str = stringify(obj, options);
-		await universalify.fromCallback(fs$5.writeFile)(file, str, options);
+		await universalify.fromCallback(fs.writeFile)(file, str, options);
 	}
 	const writeFile = universalify.fromPromise(_writeFile);
 	function writeFileSync(file, obj, options = {}) {
-		const fs$5 = options.fs || _fs;
+		const fs = options.fs || _fs;
 		const str = stringify(obj, options);
-		return fs$5.writeFileSync(file, str, options);
+		return fs.writeFileSync(file, str, options);
 	}
 	module.exports = {
 		readFile,
@@ -1800,10 +1800,10 @@ var require_output_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const path$3 = __require("path");
 	const mkdir = require_mkdirs();
 	const pathExists = require_path_exists().pathExists;
-	async function outputFile(file, data$1, encoding = "utf-8") {
+	async function outputFile(file, data, encoding = "utf-8") {
 		const dir = path$3.dirname(file);
 		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
-		return fs.writeFile(file, data$1, encoding);
+		return fs.writeFile(file, data, encoding);
 	}
 	function outputFileSync(file, ...args) {
 		const dir = path$3.dirname(file);
@@ -1821,8 +1821,8 @@ var require_output_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_output_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { stringify } = require_utils();
 	const { outputFile } = require_output_file();
-	async function outputJson(file, data$1, options = {}) {
-		await outputFile(file, stringify(data$1, options), options);
+	async function outputJson(file, data, options = {}) {
+		await outputFile(file, stringify(data, options), options);
 	}
 	module.exports = outputJson;
 }));
@@ -1832,8 +1832,8 @@ var require_output_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_output_json_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { stringify } = require_utils();
 	const { outputFileSync } = require_output_file();
-	function outputJsonSync(file, data$1, options) {
-		outputFileSync(file, stringify(data$1, options), options);
+	function outputJsonSync(file, data, options) {
+		outputFileSync(file, stringify(data, options), options);
 	}
 	module.exports = outputJsonSync;
 }));
@@ -2910,14 +2910,14 @@ var keywords$1 = {
 	6: ecma5AndLessKeywords + " const class extends export import super"
 };
 var keywordRelationalOperator = /^in(stanceof)?$/;
-var nonASCIIidentifierStart = /* @__PURE__ */ new RegExp("[" + nonASCIIidentifierStartChars + "]");
-var nonASCIIidentifier = /* @__PURE__ */ new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
 function isInAstralSet(code, set) {
 	var pos = 65536;
-	for (var i$1 = 0; i$1 < set.length; i$1 += 2) {
-		pos += set[i$1];
+	for (var i = 0; i < set.length; i += 2) {
+		pos += set[i];
 		if (pos > code) return false;
-		pos += set[i$1 + 1];
+		pos += set[i + 1];
 		if (pos >= code) return true;
 	}
 	return false;
@@ -2942,7 +2942,7 @@ function isIdentifierChar(code, astral) {
 	if (astral === false) return false;
 	return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
 }
-var TokenType = function TokenType$1(label, conf) {
+var TokenType = function TokenType(label, conf) {
 	if (conf === void 0) conf = {};
 	this.label = label;
 	this.keyword = conf.keyword;
@@ -2955,18 +2955,18 @@ var TokenType = function TokenType$1(label, conf) {
 	this.binop = conf.binop || null;
 	this.updateContext = null;
 };
-function binop(name$3, prec) {
-	return new TokenType(name$3, {
+function binop(name, prec) {
+	return new TokenType(name, {
 		beforeExpr: true,
 		binop: prec
 	});
 }
 var beforeExpr = { beforeExpr: true }, startsExpr = { startsExpr: true };
 var keywords = {};
-function kw(name$3, options) {
+function kw(name, options) {
 	if (options === void 0) options = {};
-	options.keyword = name$3;
-	return keywords[name$3] = new TokenType(name$3, options);
+	options.keyword = name;
+	return keywords[name] = new TokenType(name, options);
 }
 var types$1 = {
 	num: new TokenType("num", startsExpr),
@@ -3109,9 +3109,9 @@ function isNewLine(code) {
 }
 function nextLineBreak(code, from, end) {
 	if (end === void 0) end = code.length;
-	for (var i$1 = from; i$1 < end; i$1++) {
-		var next = code.charCodeAt(i$1);
-		if (isNewLine(next)) return i$1 < end - 1 && next === 13 && code.charCodeAt(i$1 + 1) === 10 ? i$1 + 2 : i$1 + 1;
+	for (var i = from; i < end; i++) {
+		var next = code.charCodeAt(i);
+		if (isNewLine(next)) return i < end - 1 && next === 13 && code.charCodeAt(i + 1) === 10 ? i + 2 : i + 1;
 	}
 	return -1;
 }
@@ -3128,7 +3128,7 @@ var isArray = Array.isArray || (function(obj) {
 });
 var regexpCache = Object.create(null);
 function wordsRegexp(words) {
-	return regexpCache[words] || (regexpCache[words] = /* @__PURE__ */ new RegExp("^(?:" + words.replace(/ /g, "|") + ")$"));
+	return regexpCache[words] || (regexpCache[words] = new RegExp("^(?:" + words.replace(/ /g, "|") + ")$"));
 }
 function codePointToString(code) {
 	if (code <= 65535) return String.fromCharCode(code);
@@ -3136,14 +3136,14 @@ function codePointToString(code) {
 	return String.fromCharCode((code >> 10) + 55296, (code & 1023) + 56320);
 }
 var loneSurrogate = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/;
-var Position = function Position$1(line, col) {
+var Position = function Position(line, col) {
 	this.line = line;
 	this.column = col;
 };
 Position.prototype.offset = function offset(n) {
 	return new Position(this.line, this.column + n);
 };
-var SourceLocation = function SourceLocation$1(p, start, end) {
+var SourceLocation = function SourceLocation(p, start, end) {
 	this.start = start;
 	this.end = end;
 	if (p.sourceFile !== null) this.source = p.sourceFile;
@@ -3218,7 +3218,7 @@ function functionFlags(async, generator) {
 	return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0);
 }
 var BIND_NONE = 0, BIND_VAR = 1, BIND_LEXICAL = 2, BIND_FUNCTION = 3, BIND_SIMPLE_CATCH = 4, BIND_OUTSIDE = 5;
-var Parser = function Parser$1(options, input, startPos) {
+var Parser = function Parser(options, input, startPos) {
 	this.options = options = getOptions(options);
 	this.sourceFile = options.sourceFile;
 	this.keywords = wordsRegexp(keywords$1[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
@@ -3273,7 +3273,7 @@ var prototypeAccessors = {
 	allowNewDotTarget: { configurable: true },
 	inClassStaticBlock: { configurable: true }
 };
-Parser.prototype.parse = function parse$2() {
+Parser.prototype.parse = function parse() {
 	var node = this.options.program || this.startNode();
 	this.nextToken();
 	return this.parseTopLevel(node);
@@ -3288,8 +3288,8 @@ prototypeAccessors.inAsync.get = function() {
 	return (this.currentVarScope().flags & SCOPE_ASYNC) > 0;
 };
 prototypeAccessors.canAwait.get = function() {
-	for (var i$1 = this.scopeStack.length - 1; i$1 >= 0; i$1--) {
-		var flags = this.scopeStack[i$1].flags;
+	for (var i = this.scopeStack.length - 1; i >= 0; i--) {
+		var flags = this.scopeStack[i].flags;
 		if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) return false;
 		if (flags & SCOPE_FUNCTION) return (flags & SCOPE_ASYNC) > 0;
 	}
@@ -3305,8 +3305,8 @@ prototypeAccessors.treatFunctionsAsVar.get = function() {
 	return this.treatFunctionsAsVarInScope(this.currentScope());
 };
 prototypeAccessors.allowNewDotTarget.get = function() {
-	for (var i$1 = this.scopeStack.length - 1; i$1 >= 0; i$1--) {
-		var flags = this.scopeStack[i$1].flags;
+	for (var i = this.scopeStack.length - 1; i >= 0; i--) {
+		var flags = this.scopeStack[i].flags;
 		if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || flags & SCOPE_FUNCTION && !(flags & SCOPE_ARROW)) return true;
 	}
 	return false;
@@ -3318,10 +3318,10 @@ Parser.extend = function extend() {
 	var plugins = [], len = arguments.length;
 	while (len--) plugins[len] = arguments[len];
 	var cls = this;
-	for (var i$1 = 0; i$1 < plugins.length; i$1++) cls = plugins[i$1](cls);
+	for (var i = 0; i < plugins.length; i++) cls = plugins[i](cls);
 	return cls;
 };
-Parser.parse = function parse$2(input, options) {
+Parser.parse = function parse(input, options) {
 	return new this(options, input).parse();
 };
 Parser.parseExpressionAt = function parseExpressionAt(input, pos, options) {
@@ -3360,16 +3360,16 @@ pp$9.eat = function(type) {
 		return true;
 	} else return false;
 };
-pp$9.isContextual = function(name$3) {
-	return this.type === types$1.name && this.value === name$3 && !this.containsEsc;
+pp$9.isContextual = function(name) {
+	return this.type === types$1.name && this.value === name && !this.containsEsc;
 };
-pp$9.eatContextual = function(name$3) {
-	if (!this.isContextual(name$3)) return false;
+pp$9.eatContextual = function(name) {
+	if (!this.isContextual(name)) return false;
 	this.next();
 	return true;
 };
-pp$9.expectContextual = function(name$3) {
-	if (!this.eatContextual(name$3)) this.unexpected();
+pp$9.expectContextual = function(name) {
+	if (!this.eatContextual(name)) this.unexpected();
 };
 pp$9.canInsertSemicolon = function() {
 	return this.type === types$1.eof || this.type === types$1.braceR || lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
@@ -3396,7 +3396,7 @@ pp$9.expect = function(type) {
 pp$9.unexpected = function(pos) {
 	this.raise(pos != null ? pos : this.start, "Unexpected token");
 };
-var DestructuringErrors = function DestructuringErrors$1() {
+var DestructuringErrors = function DestructuringErrors() {
 	this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
 };
 pp$9.checkPatternErrors = function(refDestructuringErrors, isAssign) {
@@ -3423,15 +3423,15 @@ pp$9.isSimpleAssignTarget = function(expr) {
 };
 var pp$8 = Parser.prototype;
 pp$8.parseTopLevel = function(node) {
-	var exports$1 = Object.create(null);
+	var exports = Object.create(null);
 	if (!node.body) node.body = [];
 	while (this.type !== types$1.eof) {
-		var stmt = this.parseStatement(null, true, exports$1);
+		var stmt = this.parseStatement(null, true, exports);
 		node.body.push(stmt);
 	}
-	if (this.inModule) for (var i$1 = 0, list$1 = Object.keys(this.undefinedExports); i$1 < list$1.length; i$1 += 1) {
-		var name$3 = list$1[i$1];
-		this.raiseRecoverable(this.undefinedExports[name$3].start, "Export '" + name$3 + "' is not defined");
+	if (this.inModule) for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1) {
+		var name = list[i];
+		this.raiseRecoverable(this.undefinedExports[name].start, "Export '" + name + "' is not defined");
 	}
 	this.adaptDirectivePrologue(node.body);
 	this.next();
@@ -3491,7 +3491,7 @@ pp$8.isAwaitUsing = function(isFor) {
 pp$8.isUsing = function(isFor) {
 	return this.isUsingKeyword(false, isFor);
 };
-pp$8.parseStatement = function(context, topLevel, exports$1) {
+pp$8.parseStatement = function(context, topLevel, exports) {
 	var starttype = this.type, node = this.startNode(), kind;
 	if (this.isLet(context)) {
 		starttype = types$1._var;
@@ -3535,7 +3535,7 @@ pp$8.parseStatement = function(context, topLevel, exports$1) {
 				if (!topLevel) this.raise(this.start, "'import' and 'export' may only appear at the top level");
 				if (!this.inModule) this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
 			}
-			return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports$1);
+			return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports);
 		default:
 			if (this.isAsyncFunction()) {
 				if (context) this.unexpected();
@@ -3568,15 +3568,15 @@ pp$8.parseBreakContinueStatement = function(node, keyword) {
 		node.label = this.parseIdent();
 		this.semicolon();
 	}
-	var i$1 = 0;
-	for (; i$1 < this.labels.length; ++i$1) {
-		var lab = this.labels[i$1];
+	var i = 0;
+	for (; i < this.labels.length; ++i) {
+		var lab = this.labels[i];
 		if (node.label == null || lab.name === node.label.name) {
 			if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
 			if (node.label && isBreak) break;
 		}
 	}
-	if (i$1 === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
+	if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
 	return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
 };
 pp$8.parseDebuggerStatement = function(node) {
@@ -3768,10 +3768,10 @@ pp$8.parseEmptyStatement = function(node) {
 	return this.finishNode(node, "EmptyStatement");
 };
 pp$8.parseLabeledStatement = function(node, maybeName, expr, context) {
-	for (var i$1 = 0, list$1 = this.labels; i$1 < list$1.length; i$1 += 1) if (list$1[i$1].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+	for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1) if (list[i$1].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
 	var kind = this.type.isLoop ? "loop" : this.type === types$1._switch ? "switch" : null;
-	for (var i$2 = this.labels.length - 1; i$2 >= 0; i$2--) {
-		var label$1 = this.labels[i$2];
+	for (var i = this.labels.length - 1; i >= 0; i--) {
+		var label$1 = this.labels[i];
 		if (label$1.statementStart === node.start) {
 			label$1.statementStart = this.start;
 			label$1.kind = kind;
@@ -3910,7 +3910,7 @@ pp$8.parseClass = function(node, isStatement) {
 };
 pp$8.parseClassElement = function(constructorAllowsSuper) {
 	if (this.eat(types$1.semi)) return null;
-	var ecmaVersion$1 = this.options.ecmaVersion;
+	var ecmaVersion = this.options.ecmaVersion;
 	var node = this.startNode();
 	var keyName = "";
 	var isGenerator = false;
@@ -3918,7 +3918,7 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
 	var kind = "method";
 	var isStatic = false;
 	if (this.eatContextual("static")) {
-		if (ecmaVersion$1 >= 13 && this.eat(types$1.braceL)) {
+		if (ecmaVersion >= 13 && this.eat(types$1.braceL)) {
 			this.parseClassStaticBlock(node);
 			return node;
 		}
@@ -3926,9 +3926,9 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
 		else keyName = "static";
 	}
 	node.static = isStatic;
-	if (!keyName && ecmaVersion$1 >= 8 && this.eatContextual("async")) if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) isAsync = true;
+	if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) isAsync = true;
 	else keyName = "async";
-	if (!keyName && (ecmaVersion$1 >= 9 || !isAsync) && this.eat(types$1.star)) isGenerator = true;
+	if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types$1.star)) isGenerator = true;
 	if (!keyName && !isAsync && !isGenerator) {
 		var lastValue = this.value;
 		if (this.eatContextual("get") || this.eatContextual("set")) if (this.isClassElementNameStart()) kind = lastValue;
@@ -3940,7 +3940,7 @@ pp$8.parseClassElement = function(constructorAllowsSuper) {
 		node.key.name = keyName;
 		this.finishNode(node.key, "Identifier");
 	} else this.parseClassElementName(node);
-	if (ecmaVersion$1 < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
+	if (ecmaVersion < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
 		var isConstructor = !node.static && checkKeyName(node, "constructor");
 		var allowsDirectSuper = isConstructor && constructorAllowsSuper;
 		if (isConstructor && kind !== "method") this.raise(node.key.start, "Constructor can't have get/set modifier");
@@ -4017,40 +4017,40 @@ pp$8.enterClassBody = function() {
 	return element.declared;
 };
 pp$8.exitClassBody = function() {
-	var ref$1 = this.privateNameStack.pop();
-	var declared = ref$1.declared;
-	var used = ref$1.used;
+	var ref = this.privateNameStack.pop();
+	var declared = ref.declared;
+	var used = ref.used;
 	if (!this.options.checkPrivateFields) return;
 	var len = this.privateNameStack.length;
 	var parent = len === 0 ? null : this.privateNameStack[len - 1];
-	for (var i$1 = 0; i$1 < used.length; ++i$1) {
-		var id = used[i$1];
+	for (var i = 0; i < used.length; ++i) {
+		var id = used[i];
 		if (!hasOwn(declared, id.name)) if (parent) parent.used.push(id);
 		else this.raiseRecoverable(id.start, "Private field '#" + id.name + "' must be declared in an enclosing class");
 	}
 };
 function isPrivateNameConflicted(privateNameMap, element) {
-	var name$3 = element.key.name;
-	var curr = privateNameMap[name$3];
+	var name = element.key.name;
+	var curr = privateNameMap[name];
 	var next = "true";
 	if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) next = (element.static ? "s" : "i") + element.kind;
 	if (curr === "iget" && next === "iset" || curr === "iset" && next === "iget" || curr === "sget" && next === "sset" || curr === "sset" && next === "sget") {
-		privateNameMap[name$3] = "true";
+		privateNameMap[name] = "true";
 		return false;
 	} else if (!curr) {
-		privateNameMap[name$3] = next;
+		privateNameMap[name] = next;
 		return false;
 	} else return true;
 }
-function checkKeyName(node, name$3) {
+function checkKeyName(node, name) {
 	var computed = node.computed;
 	var key = node.key;
-	return !computed && (key.type === "Identifier" && key.name === name$3 || key.type === "Literal" && key.value === name$3);
+	return !computed && (key.type === "Identifier" && key.name === name || key.type === "Literal" && key.value === name);
 }
-pp$8.parseExportAllDeclaration = function(node, exports$1) {
+pp$8.parseExportAllDeclaration = function(node, exports) {
 	if (this.options.ecmaVersion >= 11) if (this.eatContextual("as")) {
 		node.exported = this.parseModuleExportName();
-		this.checkExport(exports$1, node.exported, this.lastTokStart);
+		this.checkExport(exports, node.exported, this.lastTokStart);
 	} else node.exported = null;
 	this.expectContextual("from");
 	if (this.type !== types$1.string) this.unexpected();
@@ -4059,31 +4059,31 @@ pp$8.parseExportAllDeclaration = function(node, exports$1) {
 	this.semicolon();
 	return this.finishNode(node, "ExportAllDeclaration");
 };
-pp$8.parseExport = function(node, exports$1) {
+pp$8.parseExport = function(node, exports) {
 	this.next();
-	if (this.eat(types$1.star)) return this.parseExportAllDeclaration(node, exports$1);
+	if (this.eat(types$1.star)) return this.parseExportAllDeclaration(node, exports);
 	if (this.eat(types$1._default)) {
-		this.checkExport(exports$1, "default", this.lastTokStart);
+		this.checkExport(exports, "default", this.lastTokStart);
 		node.declaration = this.parseExportDefaultDeclaration();
 		return this.finishNode(node, "ExportDefaultDeclaration");
 	}
 	if (this.shouldParseExportStatement()) {
 		node.declaration = this.parseExportDeclaration(node);
-		if (node.declaration.type === "VariableDeclaration") this.checkVariableExport(exports$1, node.declaration.declarations);
-		else this.checkExport(exports$1, node.declaration.id, node.declaration.id.start);
+		if (node.declaration.type === "VariableDeclaration") this.checkVariableExport(exports, node.declaration.declarations);
+		else this.checkExport(exports, node.declaration.id, node.declaration.id.start);
 		node.specifiers = [];
 		node.source = null;
 		if (this.options.ecmaVersion >= 16) node.attributes = [];
 	} else {
 		node.declaration = null;
-		node.specifiers = this.parseExportSpecifiers(exports$1);
+		node.specifiers = this.parseExportSpecifiers(exports);
 		if (this.eatContextual("from")) {
 			if (this.type !== types$1.string) this.unexpected();
 			node.source = this.parseExprAtom();
 			if (this.options.ecmaVersion >= 16) node.attributes = this.parseWithClause();
 		} else {
-			for (var i$1 = 0, list$1 = node.specifiers; i$1 < list$1.length; i$1 += 1) {
-				var spec = list$1[i$1];
+			for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+				var spec = list[i];
 				this.checkUnreserved(spec.local);
 				this.checkLocalExport(spec.local);
 				if (spec.local.type === "Literal") this.raise(spec.local.start, "A string literal cannot be used as an exported binding without `from`.");
@@ -4114,45 +4114,45 @@ pp$8.parseExportDefaultDeclaration = function() {
 		return declaration;
 	}
 };
-pp$8.checkExport = function(exports$1, name$3, pos) {
-	if (!exports$1) return;
-	if (typeof name$3 !== "string") name$3 = name$3.type === "Identifier" ? name$3.name : name$3.value;
-	if (hasOwn(exports$1, name$3)) this.raiseRecoverable(pos, "Duplicate export '" + name$3 + "'");
-	exports$1[name$3] = true;
+pp$8.checkExport = function(exports, name, pos) {
+	if (!exports) return;
+	if (typeof name !== "string") name = name.type === "Identifier" ? name.name : name.value;
+	if (hasOwn(exports, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
+	exports[name] = true;
 };
-pp$8.checkPatternExport = function(exports$1, pat) {
+pp$8.checkPatternExport = function(exports, pat) {
 	var type = pat.type;
-	if (type === "Identifier") this.checkExport(exports$1, pat, pat.start);
-	else if (type === "ObjectPattern") for (var i$1 = 0, list$1 = pat.properties; i$1 < list$1.length; i$1 += 1) {
-		var prop = list$1[i$1];
-		this.checkPatternExport(exports$1, prop);
+	if (type === "Identifier") this.checkExport(exports, pat, pat.start);
+	else if (type === "ObjectPattern") for (var i = 0, list = pat.properties; i < list.length; i += 1) {
+		var prop = list[i];
+		this.checkPatternExport(exports, prop);
 	}
-	else if (type === "ArrayPattern") for (var i$1$1 = 0, list$1$1 = pat.elements; i$1$1 < list$1$1.length; i$1$1 += 1) {
-		var elt = list$1$1[i$1$1];
-		if (elt) this.checkPatternExport(exports$1, elt);
+	else if (type === "ArrayPattern") for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
+		var elt = list$1[i$1];
+		if (elt) this.checkPatternExport(exports, elt);
 	}
-	else if (type === "Property") this.checkPatternExport(exports$1, pat.value);
-	else if (type === "AssignmentPattern") this.checkPatternExport(exports$1, pat.left);
-	else if (type === "RestElement") this.checkPatternExport(exports$1, pat.argument);
+	else if (type === "Property") this.checkPatternExport(exports, pat.value);
+	else if (type === "AssignmentPattern") this.checkPatternExport(exports, pat.left);
+	else if (type === "RestElement") this.checkPatternExport(exports, pat.argument);
 };
-pp$8.checkVariableExport = function(exports$1, decls) {
-	if (!exports$1) return;
-	for (var i$1 = 0, list$1 = decls; i$1 < list$1.length; i$1 += 1) {
-		var decl = list$1[i$1];
-		this.checkPatternExport(exports$1, decl.id);
+pp$8.checkVariableExport = function(exports, decls) {
+	if (!exports) return;
+	for (var i = 0, list = decls; i < list.length; i += 1) {
+		var decl = list[i];
+		this.checkPatternExport(exports, decl.id);
 	}
 };
 pp$8.shouldParseExportStatement = function() {
 	return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
 };
-pp$8.parseExportSpecifier = function(exports$1) {
+pp$8.parseExportSpecifier = function(exports) {
 	var node = this.startNode();
 	node.local = this.parseModuleExportName();
 	node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
-	this.checkExport(exports$1, node.exported, node.exported.start);
+	this.checkExport(exports, node.exported, node.exported.start);
 	return this.finishNode(node, "ExportSpecifier");
 };
-pp$8.parseExportSpecifiers = function(exports$1) {
+pp$8.parseExportSpecifiers = function(exports) {
 	var nodes = [], first = true;
 	this.expect(types$1.braceL);
 	while (!this.eat(types$1.braceR)) {
@@ -4160,7 +4160,7 @@ pp$8.parseExportSpecifiers = function(exports$1) {
 			this.expect(types$1.comma);
 			if (this.afterTrailingComma(types$1.braceR)) break;
 		} else first = false;
-		nodes.push(this.parseExportSpecifier(exports$1));
+		nodes.push(this.parseExportSpecifier(exports));
 	}
 	return nodes;
 };
@@ -4259,7 +4259,7 @@ pp$8.parseModuleExportName = function() {
 	return this.parseIdent(true);
 };
 pp$8.adaptDirectivePrologue = function(statements) {
-	for (var i$1 = 0; i$1 < statements.length && this.isDirectiveCandidate(statements[i$1]); ++i$1) statements[i$1].directive = statements[i$1].expression.raw.slice(1, -1);
+	for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) statements[i].directive = statements[i].expression.raw.slice(1, -1);
 };
 pp$8.isDirectiveCandidate = function(statement) {
 	return this.options.ecmaVersion >= 5 && statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string" && (this.input[statement.start] === "\"" || this.input[statement.start] === "'");
@@ -4277,8 +4277,8 @@ pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) {
 		case "ObjectExpression":
 			node.type = "ObjectPattern";
 			if (refDestructuringErrors) this.checkPatternErrors(refDestructuringErrors, true);
-			for (var i$1 = 0, list$1 = node.properties; i$1 < list$1.length; i$1 += 1) {
-				var prop = list$1[i$1];
+			for (var i = 0, list = node.properties; i < list.length; i += 1) {
+				var prop = list[i];
 				this.toAssignable(prop, isBinding);
 				if (prop.type === "RestElement" && (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")) this.raise(prop.argument.start, "Unexpected token");
 			}
@@ -4317,8 +4317,8 @@ pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) {
 };
 pp$7.toAssignableList = function(exprList, isBinding) {
 	var end = exprList.length;
-	for (var i$1 = 0; i$1 < end; i$1++) {
-		var elt = exprList[i$1];
+	for (var i = 0; i < end; i++) {
+		var elt = exprList[i];
 		if (elt) this.toAssignable(elt, isBinding);
 	}
 	if (end) {
@@ -4416,14 +4416,14 @@ pp$7.checkLValPattern = function(expr, bindingType, checkClashes) {
 	if (bindingType === void 0) bindingType = BIND_NONE;
 	switch (expr.type) {
 		case "ObjectPattern":
-			for (var i$1 = 0, list$1 = expr.properties; i$1 < list$1.length; i$1 += 1) {
-				var prop = list$1[i$1];
+			for (var i = 0, list = expr.properties; i < list.length; i += 1) {
+				var prop = list[i];
 				this.checkLValInnerPattern(prop, bindingType, checkClashes);
 			}
 			break;
 		case "ArrayPattern":
-			for (var i$1$1 = 0, list$1$1 = expr.elements; i$1$1 < list$1$1.length; i$1$1 += 1) {
-				var elem = list$1$1[i$1$1];
+			for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
+				var elem = list$1[i$1];
 				if (elem) this.checkLValInnerPattern(elem, bindingType, checkClashes);
 			}
 			break;
@@ -4445,7 +4445,7 @@ pp$7.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
 		default: this.checkLValPattern(expr, bindingType, checkClashes);
 	}
 };
-var TokContext = function TokContext$1(token, isExpr, preserveSpace, override, generator) {
+var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
 	this.token = token;
 	this.isExpr = !!isExpr;
 	this.preserveSpace = !!preserveSpace;
@@ -4484,8 +4484,8 @@ pp$6.braceIsBlock = function(prevType) {
 	return !this.exprAllowed;
 };
 pp$6.inGeneratorContext = function() {
-	for (var i$1 = this.context.length - 1; i$1 >= 1; i$1--) {
-		var context = this.context[i$1];
+	for (var i = this.context.length - 1; i >= 1; i--) {
+		var context = this.context[i];
 		if (context.token === "function") return context.generator;
 	}
 	return false;
@@ -4556,19 +4556,19 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 	if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement") return;
 	if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand)) return;
 	var key = prop.key;
-	var name$3;
+	var name;
 	switch (key.type) {
 		case "Identifier":
-			name$3 = key.name;
+			name = key.name;
 			break;
 		case "Literal":
-			name$3 = String(key.value);
+			name = String(key.value);
 			break;
 		default: return;
 	}
 	var kind = prop.kind;
 	if (this.options.ecmaVersion >= 6) {
-		if (name$3 === "__proto__" && kind === "init") {
+		if (name === "__proto__" && kind === "init") {
 			if (propHash.proto) if (refDestructuringErrors) {
 				if (refDestructuringErrors.doubleProto < 0) refDestructuringErrors.doubleProto = key.start;
 			} else this.raiseRecoverable(key.start, "Redefinition of __proto__ property");
@@ -4576,14 +4576,14 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 		}
 		return;
 	}
-	name$3 = "$" + name$3;
-	var other = propHash[name$3];
+	name = "$" + name;
+	var other = propHash[name];
 	if (other) {
 		var redefinition;
 		if (kind === "init") redefinition = this.strict && other.init || other.get || other.set;
 		else redefinition = other.init || other[kind];
 		if (redefinition) this.raiseRecoverable(key.start, "Redefinition of property");
-	} else other = propHash[name$3] = {
+	} else other = propHash[name] = {
 		init: false,
 		get: false,
 		set: false
@@ -5026,8 +5026,8 @@ pp$5.parseNew = function() {
 	else node.arguments = empty;
 	return this.finishNode(node, "NewExpression");
 };
-pp$5.parseTemplateElement = function(ref$1) {
-	var isTagged = ref$1.isTagged;
+pp$5.parseTemplateElement = function(ref) {
+	var isTagged = ref.isTagged;
 	var elem = this.startNode();
 	if (this.type === types$1.invalidTemplate) {
 		if (!isTagged) this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
@@ -5043,9 +5043,9 @@ pp$5.parseTemplateElement = function(ref$1) {
 	elem.tail = this.type === types$1.backQuote;
 	return this.finishNode(elem, "TemplateElement");
 };
-pp$5.parseTemplate = function(ref$1) {
-	if (ref$1 === void 0) ref$1 = {};
-	var isTagged = ref$1.isTagged;
+pp$5.parseTemplate = function(ref) {
+	if (ref === void 0) ref = {};
+	var isTagged = ref.isTagged;
 	if (isTagged === void 0) isTagged = false;
 	var node = this.startNode();
 	this.next();
@@ -5222,13 +5222,13 @@ pp$5.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
 	this.exitScope();
 };
 pp$5.isSimpleParamList = function(params) {
-	for (var i$1 = 0, list$1 = params; i$1 < list$1.length; i$1 += 1) if (list$1[i$1].type !== "Identifier") return false;
+	for (var i = 0, list = params; i < list.length; i += 1) if (list[i].type !== "Identifier") return false;
 	return true;
 };
 pp$5.checkParams = function(node, allowDuplicates) {
 	var nameHash = Object.create(null);
-	for (var i$1 = 0, list$1 = node.params; i$1 < list$1.length; i$1 += 1) {
-		var param = list$1[i$1];
+	for (var i = 0, list = node.params; i < list.length; i += 1) {
+		var param = list[i];
 		this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash);
 	}
 };
@@ -5249,19 +5249,19 @@ pp$5.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestruct
 	}
 	return elts;
 };
-pp$5.checkUnreserved = function(ref$1) {
-	var start = ref$1.start;
-	var end = ref$1.end;
-	var name$3 = ref$1.name;
-	if (this.inGenerator && name$3 === "yield") this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator");
-	if (this.inAsync && name$3 === "await") this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function");
-	if (!(this.currentThisScope().flags & SCOPE_VAR) && name$3 === "arguments") this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer");
-	if (this.inClassStaticBlock && (name$3 === "arguments" || name$3 === "await")) this.raise(start, "Cannot use " + name$3 + " in class static initialization block");
-	if (this.keywords.test(name$3)) this.raise(start, "Unexpected keyword '" + name$3 + "'");
+pp$5.checkUnreserved = function(ref) {
+	var start = ref.start;
+	var end = ref.end;
+	var name = ref.name;
+	if (this.inGenerator && name === "yield") this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator");
+	if (this.inAsync && name === "await") this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function");
+	if (!(this.currentThisScope().flags & SCOPE_VAR) && name === "arguments") this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer");
+	if (this.inClassStaticBlock && (name === "arguments" || name === "await")) this.raise(start, "Cannot use " + name + " in class static initialization block");
+	if (this.keywords.test(name)) this.raise(start, "Unexpected keyword '" + name + "'");
 	if (this.options.ecmaVersion < 6 && this.input.slice(start, end).indexOf("\\") !== -1) return;
-	if ((this.strict ? this.reservedWordsStrict : this.reservedWords).test(name$3)) {
-		if (!this.inAsync && name$3 === "await") this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function");
-		this.raiseRecoverable(start, "The keyword '" + name$3 + "' is reserved");
+	if ((this.strict ? this.reservedWordsStrict : this.reservedWords).test(name)) {
+		if (!this.inAsync && name === "await") this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function");
+		this.raiseRecoverable(start, "The keyword '" + name + "' is reserved");
 	}
 };
 pp$5.parseIdent = function(liberal) {
@@ -5330,7 +5330,7 @@ pp$4.curPosition = function() {
 	if (this.options.locations) return new Position(this.curLine, this.pos - this.lineStart);
 };
 var pp$3 = Parser.prototype;
-var Scope = function Scope$1(flags) {
+var Scope = function Scope(flags) {
 	this.flags = flags;
 	this.var = [];
 	this.lexical = [];
@@ -5345,30 +5345,30 @@ pp$3.exitScope = function() {
 pp$3.treatFunctionsAsVarInScope = function(scope) {
 	return scope.flags & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_TOP;
 };
-pp$3.declareName = function(name$3, bindingType, pos) {
+pp$3.declareName = function(name, bindingType, pos) {
 	var redeclared = false;
 	if (bindingType === BIND_LEXICAL) {
 		var scope = this.currentScope();
-		redeclared = scope.lexical.indexOf(name$3) > -1 || scope.functions.indexOf(name$3) > -1 || scope.var.indexOf(name$3) > -1;
-		scope.lexical.push(name$3);
-		if (this.inModule && scope.flags & SCOPE_TOP) delete this.undefinedExports[name$3];
-	} else if (bindingType === BIND_SIMPLE_CATCH) this.currentScope().lexical.push(name$3);
+		redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+		scope.lexical.push(name);
+		if (this.inModule && scope.flags & SCOPE_TOP) delete this.undefinedExports[name];
+	} else if (bindingType === BIND_SIMPLE_CATCH) this.currentScope().lexical.push(name);
 	else if (bindingType === BIND_FUNCTION) {
 		var scope$2 = this.currentScope();
-		if (this.treatFunctionsAsVar) redeclared = scope$2.lexical.indexOf(name$3) > -1;
-		else redeclared = scope$2.lexical.indexOf(name$3) > -1 || scope$2.var.indexOf(name$3) > -1;
-		scope$2.functions.push(name$3);
-	} else for (var i$1 = this.scopeStack.length - 1; i$1 >= 0; --i$1) {
-		var scope$3 = this.scopeStack[i$1];
-		if (scope$3.lexical.indexOf(name$3) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH && scope$3.lexical[0] === name$3) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name$3) > -1) {
+		if (this.treatFunctionsAsVar) redeclared = scope$2.lexical.indexOf(name) > -1;
+		else redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1;
+		scope$2.functions.push(name);
+	} else for (var i = this.scopeStack.length - 1; i >= 0; --i) {
+		var scope$3 = this.scopeStack[i];
+		if (scope$3.lexical.indexOf(name) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH && scope$3.lexical[0] === name) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
 			redeclared = true;
 			break;
 		}
-		scope$3.var.push(name$3);
-		if (this.inModule && scope$3.flags & SCOPE_TOP) delete this.undefinedExports[name$3];
+		scope$3.var.push(name);
+		if (this.inModule && scope$3.flags & SCOPE_TOP) delete this.undefinedExports[name];
 		if (scope$3.flags & SCOPE_VAR) break;
 	}
-	if (redeclared) this.raiseRecoverable(pos, "Identifier '" + name$3 + "' has already been declared");
+	if (redeclared) this.raiseRecoverable(pos, "Identifier '" + name + "' has already been declared");
 };
 pp$3.checkLocalExport = function(id) {
 	if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && this.scopeStack[0].var.indexOf(id.name) === -1) this.undefinedExports[id.name] = id;
@@ -5377,18 +5377,18 @@ pp$3.currentScope = function() {
 	return this.scopeStack[this.scopeStack.length - 1];
 };
 pp$3.currentVarScope = function() {
-	for (var i$1 = this.scopeStack.length - 1;; i$1--) {
-		var scope = this.scopeStack[i$1];
+	for (var i = this.scopeStack.length - 1;; i--) {
+		var scope = this.scopeStack[i];
 		if (scope.flags & (SCOPE_VAR | SCOPE_CLASS_FIELD_INIT | SCOPE_CLASS_STATIC_BLOCK)) return scope;
 	}
 };
 pp$3.currentThisScope = function() {
-	for (var i$1 = this.scopeStack.length - 1;; i$1--) {
-		var scope = this.scopeStack[i$1];
+	for (var i = this.scopeStack.length - 1;; i--) {
+		var scope = this.scopeStack[i];
 		if (scope.flags & (SCOPE_VAR | SCOPE_CLASS_FIELD_INIT | SCOPE_CLASS_STATIC_BLOCK) && !(scope.flags & SCOPE_ARROW)) return scope;
 	}
 };
-var Node = function Node$1(parser, pos, loc) {
+var Node = function Node(parser, pos, loc) {
 	this.type = "";
 	this.start = pos;
 	this.end = 0;
@@ -5461,13 +5461,13 @@ var unicodeScriptValues = {
 	14: ecma14ScriptValues
 };
 var data = {};
-function buildUnicodeData(ecmaVersion$1) {
-	var d = data[ecmaVersion$1] = {
-		binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion$1] + " " + unicodeGeneralCategoryValues),
-		binaryOfStrings: wordsRegexp(unicodeBinaryPropertiesOfStrings[ecmaVersion$1]),
+function buildUnicodeData(ecmaVersion) {
+	var d = data[ecmaVersion] = {
+		binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
+		binaryOfStrings: wordsRegexp(unicodeBinaryPropertiesOfStrings[ecmaVersion]),
 		nonBinary: {
 			General_Category: wordsRegexp(unicodeGeneralCategoryValues),
-			Script: wordsRegexp(unicodeScriptValues[ecmaVersion$1])
+			Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
 		}
 	};
 	d.nonBinary.Script_Extensions = d.nonBinary.Script;
@@ -5487,7 +5487,7 @@ for (var i = 0, list = [
 	buildUnicodeData(ecmaVersion);
 }
 var pp$1 = Parser.prototype;
-var BranchID = function BranchID$1(parent, base) {
+var BranchID = function BranchID(parent, base) {
 	this.parent = parent;
 	this.base = base || this;
 };
@@ -5498,7 +5498,7 @@ BranchID.prototype.separatedFrom = function separatedFrom(alt) {
 BranchID.prototype.sibling = function sibling() {
 	return new BranchID(this.parent, this.base);
 };
-var RegExpValidationState = function RegExpValidationState$1(parser) {
+var RegExpValidationState = function RegExpValidationState(parser) {
 	this.parser = parser;
 	this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "") + (parser.options.ecmaVersion >= 15 ? "v" : "");
 	this.unicodeProperties = data[parser.options.ecmaVersion >= 14 ? 14 : parser.options.ecmaVersion];
@@ -5537,24 +5537,24 @@ RegExpValidationState.prototype.reset = function reset(start, pattern, flags) {
 RegExpValidationState.prototype.raise = function raise(message) {
 	this.parser.raiseRecoverable(this.start, "Invalid regular expression: /" + this.source + "/: " + message);
 };
-RegExpValidationState.prototype.at = function at(i$1, forceU) {
+RegExpValidationState.prototype.at = function at(i, forceU) {
 	if (forceU === void 0) forceU = false;
 	var s = this.source;
 	var l = s.length;
-	if (i$1 >= l) return -1;
-	var c = s.charCodeAt(i$1);
-	if (!(forceU || this.switchU) || c <= 55295 || c >= 57344 || i$1 + 1 >= l) return c;
-	var next = s.charCodeAt(i$1 + 1);
+	if (i >= l) return -1;
+	var c = s.charCodeAt(i);
+	if (!(forceU || this.switchU) || c <= 55295 || c >= 57344 || i + 1 >= l) return c;
+	var next = s.charCodeAt(i + 1);
 	return next >= 56320 && next <= 57343 ? (c << 10) + next - 56613888 : c;
 };
-RegExpValidationState.prototype.nextIndex = function nextIndex(i$1, forceU) {
+RegExpValidationState.prototype.nextIndex = function nextIndex(i, forceU) {
 	if (forceU === void 0) forceU = false;
 	var s = this.source;
 	var l = s.length;
-	if (i$1 >= l) return l;
-	var c = s.charCodeAt(i$1), next;
-	if (!(forceU || this.switchU) || c <= 55295 || c >= 57344 || i$1 + 1 >= l || (next = s.charCodeAt(i$1 + 1)) < 56320 || next > 57343) return i$1 + 1;
-	return i$1 + 2;
+	if (i >= l) return l;
+	var c = s.charCodeAt(i), next;
+	if (!(forceU || this.switchU) || c <= 55295 || c >= 57344 || i + 1 >= l || (next = s.charCodeAt(i + 1)) < 56320 || next > 57343) return i + 1;
+	return i + 2;
 };
 RegExpValidationState.prototype.current = function current(forceU) {
 	if (forceU === void 0) forceU = false;
@@ -5579,8 +5579,8 @@ RegExpValidationState.prototype.eat = function eat(ch, forceU) {
 RegExpValidationState.prototype.eatChars = function eatChars(chs, forceU) {
 	if (forceU === void 0) forceU = false;
 	var pos = this.pos;
-	for (var i$1 = 0, list$1 = chs; i$1 < list$1.length; i$1 += 1) {
-		var ch = list$1[i$1];
+	for (var i = 0, list = chs; i < list.length; i += 1) {
+		var ch = list[i];
 		var current = this.at(pos, forceU);
 		if (current === -1 || current !== ch) return false;
 		pos = this.nextIndex(pos, forceU);
@@ -5599,10 +5599,10 @@ pp$1.validateRegExpFlags = function(state) {
 	var flags = state.flags;
 	var u = false;
 	var v = false;
-	for (var i$1 = 0; i$1 < flags.length; i$1++) {
-		var flag = flags.charAt(i$1);
+	for (var i = 0; i < flags.length; i++) {
+		var flag = flags.charAt(i);
 		if (validFlags.indexOf(flag) === -1) this.raise(state.start, "Invalid regular expression flag");
-		if (flags.indexOf(flag, i$1 + 1) > -1) this.raise(state.start, "Duplicate regular expression flag");
+		if (flags.indexOf(flag, i + 1) > -1) this.raise(state.start, "Duplicate regular expression flag");
 		if (flag === "u") u = true;
 		if (flag === "v") v = true;
 	}
@@ -5641,9 +5641,9 @@ pp$1.regexp_pattern = function(state) {
 		if (state.eat(93) || state.eat(125)) state.raise("Lone quantifier brackets");
 	}
 	if (state.maxBackReference > state.numCapturingParens) state.raise("Invalid escape");
-	for (var i$1 = 0, list$1 = state.backReferenceNames; i$1 < list$1.length; i$1 += 1) {
-		var name$3 = list$1[i$1];
-		if (!state.groupNames[name$3]) state.raise("Invalid named capture referenced");
+	for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
+		var name = list[i];
+		if (!state.groupNames[name]) state.raise("Invalid named capture referenced");
 	}
 };
 pp$1.regexp_disjunction = function(state) {
@@ -5742,16 +5742,16 @@ pp$1.regexp_eatUncapturingGroup = function(state) {
 				var addModifiers = this.regexp_eatModifiers(state);
 				var hasHyphen = state.eat(45);
 				if (addModifiers || hasHyphen) {
-					for (var i$1 = 0; i$1 < addModifiers.length; i$1++) {
-						var modifier = addModifiers.charAt(i$1);
-						if (addModifiers.indexOf(modifier, i$1 + 1) > -1) state.raise("Duplicate regular expression modifiers");
+					for (var i = 0; i < addModifiers.length; i++) {
+						var modifier = addModifiers.charAt(i);
+						if (addModifiers.indexOf(modifier, i + 1) > -1) state.raise("Duplicate regular expression modifiers");
 					}
 					if (hasHyphen) {
 						var removeModifiers = this.regexp_eatModifiers(state);
 						if (!addModifiers && !removeModifiers && state.current() === 58) state.raise("Invalid regular expression modifiers");
-						for (var i$1$1 = 0; i$1$1 < removeModifiers.length; i$1$1++) {
-							var modifier$1 = removeModifiers.charAt(i$1$1);
-							if (removeModifiers.indexOf(modifier$1, i$1$1 + 1) > -1 || addModifiers.indexOf(modifier$1) > -1) state.raise("Duplicate regular expression modifiers");
+						for (var i$1 = 0; i$1 < removeModifiers.length; i$1++) {
+							var modifier$1 = removeModifiers.charAt(i$1);
+							if (removeModifiers.indexOf(modifier$1, i$1 + 1) > -1 || addModifiers.indexOf(modifier$1) > -1) state.raise("Duplicate regular expression modifiers");
 						}
 					}
 				}
@@ -5830,7 +5830,7 @@ pp$1.regexp_groupSpecifier = function(state) {
 		var trackDisjunction = this.options.ecmaVersion >= 16;
 		var known = state.groupNames[state.lastStringValue];
 		if (known) if (trackDisjunction) {
-			for (var i$1 = 0, list$1 = known; i$1 < list$1.length; i$1 += 1) if (!list$1[i$1].separatedFrom(state.branchID)) state.raise("Duplicate capture group name");
+			for (var i = 0, list = known; i < list.length; i += 1) if (!list[i].separatedFrom(state.branchID)) state.raise("Duplicate capture group name");
 		} else state.raise("Duplicate capture group name");
 		if (trackDisjunction) (known || (state.groupNames[state.lastStringValue] = [])).push(state.branchID);
 		else state.groupNames[state.lastStringValue] = true;
@@ -6064,10 +6064,10 @@ function isCharacterClassEscape(ch) {
 pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
 	var start = state.pos;
 	if (this.regexp_eatUnicodePropertyName(state) && state.eat(61)) {
-		var name$3 = state.lastStringValue;
+		var name = state.lastStringValue;
 		if (this.regexp_eatUnicodePropertyValue(state)) {
 			var value = state.lastStringValue;
-			this.regexp_validateUnicodePropertyNameAndValue(state, name$3, value);
+			this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
 			return CharSetOk;
 		}
 	}
@@ -6078,9 +6078,9 @@ pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
 	}
 	return CharSetNone;
 };
-pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name$3, value) {
-	if (!hasOwn(state.unicodeProperties.nonBinary, name$3)) state.raise("Invalid property name");
-	if (!state.unicodeProperties.nonBinary[name$3].test(value)) state.raise("Invalid property value");
+pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+	if (!hasOwn(state.unicodeProperties.nonBinary, name)) state.raise("Invalid property name");
+	if (!state.unicodeProperties.nonBinary[name].test(value)) state.raise("Invalid property value");
 };
 pp$1.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
 	if (state.unicodeProperties.binary.test(nameOrValue)) return CharSetOk;
@@ -6371,7 +6371,7 @@ function isOctalDigit(ch) {
 pp$1.regexp_eatFixedHexDigits = function(state, length) {
 	var start = state.pos;
 	state.lastIntValue = 0;
-	for (var i$1 = 0; i$1 < length; ++i$1) {
+	for (var i = 0; i < length; ++i) {
 		var ch = state.current();
 		if (!isHexDigit(ch)) {
 			state.pos = start;
@@ -6382,7 +6382,7 @@ pp$1.regexp_eatFixedHexDigits = function(state, length) {
 	}
 	return true;
 };
-var Token = function Token$1(p) {
+var Token = function Token(p) {
 	this.type = p.type;
 	this.value = p.value;
 	this.start = p.start;
@@ -6580,15 +6580,15 @@ pp.readToken_eq_excl = function(code) {
 	return this.finishOp(code === 61 ? types$1.eq : types$1.prefix, 1);
 };
 pp.readToken_question = function() {
-	var ecmaVersion$1 = this.options.ecmaVersion;
-	if (ecmaVersion$1 >= 11) {
+	var ecmaVersion = this.options.ecmaVersion;
+	if (ecmaVersion >= 11) {
 		var next = this.input.charCodeAt(this.pos + 1);
 		if (next === 46) {
 			var next2 = this.input.charCodeAt(this.pos + 2);
 			if (next2 < 48 || next2 > 57) return this.finishOp(types$1.questionDot, 2);
 		}
 		if (next === 63) {
-			if (ecmaVersion$1 >= 12) {
+			if (ecmaVersion >= 12) {
 				if (this.input.charCodeAt(this.pos + 2) === 61) return this.finishOp(types$1.assign, 3);
 			}
 			return this.finishOp(types$1.coalesce, 2);
@@ -6597,9 +6597,9 @@ pp.readToken_question = function() {
 	return this.finishOp(types$1.question, 1);
 };
 pp.readToken_numberSign = function() {
-	var ecmaVersion$1 = this.options.ecmaVersion;
+	var ecmaVersion = this.options.ecmaVersion;
 	var code = 35;
-	if (ecmaVersion$1 >= 13) {
+	if (ecmaVersion >= 13) {
 		++this.pos;
 		code = this.fullCharCodeAtPos();
 		if (isIdentifierStart(code, true) || code === 92) return this.finishToken(types$1.privateId, this.readWord1());
@@ -6718,12 +6718,12 @@ pp.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
 	var allowSeparators = this.options.ecmaVersion >= 12 && len === void 0;
 	var isLegacyOctalNumericLiteral = maybeLegacyOctalNumericLiteral && this.input.charCodeAt(this.pos) === 48;
 	var start = this.pos, total = 0, lastCode = 0;
-	for (var i$1 = 0, e = len == null ? Infinity : len; i$1 < e; ++i$1, ++this.pos) {
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i, ++this.pos) {
 		var code = this.input.charCodeAt(this.pos), val = void 0;
 		if (allowSeparators && code === 95) {
 			if (isLegacyOctalNumericLiteral) this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals");
 			if (lastCode === 95) this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore");
-			if (i$1 === 0) this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits");
+			if (i === 0) this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits");
 			lastCode = code;
 			continue;
 		}
@@ -7000,7 +7000,7 @@ Parser.acorn = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ufo@1.6.1/node_modules/ufo/dist/index.mjs
+//#region ../../node_modules/.pnpm/ufo@1.6.3/node_modules/ufo/dist/index.mjs
 const r = String.fromCharCode;
 const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -7011,15 +7011,15 @@ function hasTrailingSlash(input = "", respectQueryAndFragment) {
 function withTrailingSlash(input = "", respectQueryAndFragment) {
 	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
 	if (hasTrailingSlash(input, true)) return input || "/";
-	let path$13 = input;
+	let path = input;
 	let fragment = "";
 	const fragmentIndex = input.indexOf("#");
 	if (fragmentIndex !== -1) {
-		path$13 = input.slice(0, fragmentIndex);
+		path = input.slice(0, fragmentIndex);
 		fragment = input.slice(fragmentIndex);
-		if (!path$13) return fragment;
+		if (!path) return fragment;
 	}
-	const [s0, ...s] = path$13.split("?");
+	const [s0, ...s] = path.split("?");
 	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -7039,41 +7039,41 @@ const protocolRelative = Symbol.for("ufo:protocolRelative");
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 let _lazyMatch = () => {
 	var __lib__ = (() => {
-		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r$1, e) => {
-			for (var n in e) m(r$1, n, {
+		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e) => {
+			for (var n in e) m(r, n, {
 				get: e[n],
 				enumerable: true
 			});
-		}, H = (r$1, e, n, a) => {
-			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r$1, t) && t !== n && m(r$1, t, {
+		}, H = (r, e, n, a) => {
+			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r, t) && t !== n && m(r, t, {
 				get: () => e[t],
 				enumerable: !(a = V(e, t)) || a.enumerable
 			});
-			return r$1;
-		}, J = (r$1) => H(m({}, "__esModule", { value: true }), r$1), w = {};
+			return r;
+		}, J = (r) => H(m({}, "__esModule", { value: true }), r), w = {};
 		q(w, { default: () => re });
-		var A = (r$1) => Array.isArray(r$1), d = (r$1) => typeof r$1 == "function", Q = (r$1) => r$1.length === 0, W = (r$1) => typeof r$1 == "number", K = (r$1) => typeof r$1 == "object" && r$1 !== null, X = (r$1) => r$1 instanceof RegExp, b = (r$1) => typeof r$1 == "string", h = (r$1) => r$1 === void 0, Y = (r$1) => {
+		var A = (r) => Array.isArray(r), d = (r) => typeof r == "function", Q = (r) => r.length === 0, W = (r) => typeof r == "number", K = (r) => typeof r == "object" && r !== null, X = (r) => r instanceof RegExp, b = (r) => typeof r == "string", h = (r) => r === void 0, Y = (r) => {
 			const e = /* @__PURE__ */ new Map();
 			return (n) => {
 				const a = e.get(n);
 				if (a) return a;
-				const t = r$1(n);
+				const t = r(n);
 				return e.set(n, t), t;
 			};
-		}, rr = (r$1, e, n = {}) => {
+		}, rr = (r, e, n = {}) => {
 			const a = {
 				cache: {},
-				input: r$1,
+				input: r,
 				index: 0,
 				indexMax: 0,
 				options: n,
 				output: []
 			};
-			if (v(e)(a) && a.index === r$1.length) return a.output;
+			if (v(e)(a) && a.index === r.length) return a.output;
 			throw new Error(`Failed to parse at index ${a.indexMax}`);
-		}, i$1 = (r$1, e) => A(r$1) ? er(r$1, e) : b(r$1) ? ar(r$1, e) : nr(r$1, e), er = (r$1, e) => {
+		}, i = (r, e) => A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e) => {
 			const n = {};
-			for (const a of r$1) {
+			for (const a of r) {
 				if (a.length !== 1) throw new Error(`Invalid character: "${a}"`);
 				const t = a.charCodeAt(0);
 				n[t] = true;
@@ -7091,8 +7091,8 @@ let _lazyMatch = () => {
 				}
 				return true;
 			};
-		}, nr = (r$1, e) => {
-			const n = r$1.source, a = r$1.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+		}, nr = (r, e) => {
+			const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
 			return g((o) => {
 				t.lastIndex = o.index;
 				const u = t.exec(o.input);
@@ -7104,16 +7104,16 @@ let _lazyMatch = () => {
 					return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
 				} else return false;
 			});
-		}, ar = (r$1, e) => (n) => {
-			if (n.input.startsWith(r$1, n.index)) {
+		}, ar = (r, e) => (n) => {
+			if (n.input.startsWith(r, n.index)) {
 				if (!h(e) && !n.options.silent) {
-					const t = d(e) ? e(r$1, n.input, String(n.index)) : e;
+					const t = d(e) ? e(r, n.input, String(n.index)) : e;
 					h(t) || n.output.push(t);
 				}
-				return n.index += r$1.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+				return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
 			} else return false;
-		}, C = (r$1, e, n, a) => {
-			const t = v(r$1);
+		}, C = (r, e, n, a) => {
+			const t = v(r);
 			return g(_(M((o) => {
 				let u = 0;
 				for (; u < n;) {
@@ -7122,30 +7122,30 @@ let _lazyMatch = () => {
 				}
 				return u >= e;
 			})));
-		}, tr = (r$1, e) => C(r$1, 0, 1), f = (r$1, e) => C(r$1, 0, Infinity), x = (r$1, e) => {
-			const n = r$1.map(v);
+		}, tr = (r, e) => C(r, 0, 1), f = (r, e) => C(r, 0, Infinity), x = (r, e) => {
+			const n = r.map(v);
 			return g(_(M((a) => {
 				for (let t = 0, o = n.length; t < o; t++) if (!n[t](a)) return false;
 				return true;
 			})));
-		}, l = (r$1, e) => {
-			const n = r$1.map(v);
+		}, l = (r, e) => {
+			const n = r.map(v);
 			return g(_((a) => {
 				for (let t = 0, o = n.length; t < o; t++) if (n[t](a)) return true;
 				return false;
 			}));
-		}, M = (r$1, e = false) => {
-			const n = v(r$1);
+		}, M = (r, e = false) => {
+			const n = v(r);
 			return (a) => {
 				const t = a.index, o = a.output.length, u = n(a);
 				return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
 			};
-		}, _ = (r$1, e) => {
-			return v(r$1);
+		}, _ = (r, e) => {
+			return v(r);
 		}, g = (() => {
-			let r$1 = 0;
+			let r = 0;
 			return (e) => {
-				const n = v(e), a = r$1 += 1;
+				const n = v(e), a = r += 1;
 				return (t) => {
 					var o;
 					if (t.options.memoization === false) return n(t);
@@ -7169,55 +7169,55 @@ let _lazyMatch = () => {
 					}
 				};
 			};
-		})(), E = (r$1) => {
+		})(), E = (r) => {
 			let e;
-			return (n) => (e || (e = v(r$1())), e(n));
-		}, v = Y((r$1) => {
-			if (d(r$1)) return Q(r$1) ? E(r$1) : r$1;
-			if (b(r$1) || X(r$1)) return i$1(r$1);
-			if (A(r$1)) return x(r$1);
-			if (K(r$1)) return l(Object.values(r$1));
+			return (n) => (e || (e = v(r())), e(n));
+		}, v = Y((r) => {
+			if (d(r)) return Q(r) ? E(r) : r;
+			if (b(r) || X(r)) return i(r);
+			if (A(r)) return x(r);
+			if (K(r)) return l(Object.values(r));
 			throw new Error("Invalid rule");
-		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r$1) => {
+		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r) => {
 			let e = "";
-			for (; r$1 > 0;) e = P[(r$1 - 1) % 26] + e, r$1 = Math.floor((r$1 - 1) / 26);
+			for (; r > 0;) e = P[(r - 1) % 26] + e, r = Math.floor((r - 1) / 26);
 			return e;
-		}, O = (r$1) => {
+		}, O = (r) => {
 			let e = 0;
-			for (let n = 0, a = r$1.length; n < a; n++) e = e * 26 + P.indexOf(r$1[n]) + 1;
+			for (let n = 0, a = r.length; n < a; n++) e = e * 26 + P.indexOf(r[n]) + 1;
 			return e;
-		}, S = (r$1, e) => {
-			if (e < r$1) return S(e, r$1);
+		}, S = (r, e) => {
+			if (e < r) return S(e, r);
 			const n = [];
-			for (; r$1 <= e;) n.push(r$1++);
+			for (; r <= e;) n.push(r++);
 			return n;
-		}, or = (r$1, e, n) => S(r$1, e).map((a) => String(a).padStart(n, "0")), R = (r$1, e) => S(O(r$1), O(e)).map(ir), p = (r$1) => r$1, z = (r$1) => ur((e) => rr(e, r$1, { memoization: false }).join("")), ur = (r$1) => {
+		}, or = (r, e, n) => S(r, e).map((a) => String(a).padStart(n, "0")), R = (r, e) => S(O(r), O(e)).map(ir), p = (r) => r, z = (r) => ur((e) => rr(e, r, { memoization: false }).join("")), ur = (r) => {
 			const e = {};
-			return (n) => e[n] ?? (e[n] = r$1(n));
-		}, sr = i$1(/^\*\*\/\*$/, ".*"), cr = i$1(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r$1, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i$1(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r$1, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i$1(/\\./, p), pr = i$1(/[$.*+?^(){}[\]\|]/, (r$1) => `\\${r$1}`), vr = i$1(/./, p), fr = l([i$1(/^(?:!!)*!(.*)$/, (r$1, e) => `(?!^${L(e)}$).*?`), i$1(/^(!!)+/, "")]), j = l([
-			i$1(/\/(\*\*\/)+/, "(?:/.+/|/)"),
-			i$1(/^(\*\*\/)+/, "(?:^|.*/)"),
-			i$1(/\/(\*\*)$/, "(?:/.*|$)"),
-			i$1(/\*\*/, ".*")
-		]), N = l([i$1(/\*\/(?!\*\*\/)/, "[^/]*/"), i$1(/\*/, "[^/]*")]), k = i$1("?", "[^/]"), $r = i$1("[", p), wr = i$1("]", p), Ar = i$1(/[!^]/, "^/"), br = i$1(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
+			return (n) => e[n] ?? (e[n] = r(n));
+		}, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r) => `\\${r}`), vr = i(/./, p), fr = l([i(/^(?:!!)*!(.*)$/, (r, e) => `(?!^${L(e)}$).*?`), i(/^(!!)+/, "")]), j = l([
+			i(/\/(\*\*\/)+/, "(?:/.+/|/)"),
+			i(/^(\*\*\/)+/, "(?:^|.*/)"),
+			i(/\/(\*\*)$/, "(?:/.*|$)"),
+			i(/\*\*/, ".*")
+		]), N = l([i(/\*\/(?!\*\*\/)/, "[^/]*/"), i(/\*/, "[^/]*")]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
 			y,
-			i$1(/[$.*+?^(){}[\|]/, (r$1) => `\\${r$1}`),
+			i(/[$.*+?^(){}[\|]/, (r) => `\\${r}`),
 			br,
-			i$1(/[^\]]/, p)
+			i(/[^\]]/, p)
 		]), B = x([
 			$r,
 			tr(Ar),
 			f(Er),
 			wr
-		]), Pr = i$1("{", "(?:"), Or = i$1("}", ")"), I = x([
+		]), Pr = i("{", "(?:"), Or = i("}", ")"), I = x([
 			Pr,
 			l([
-				i$1(/(\d+)\.\.(\d+)/, (r$1, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
-				i$1(/([a-z]+)\.\.([a-z]+)/, (r$1, e, n) => R(e, n).join("|")),
-				i$1(/([A-Z]+)\.\.([A-Z]+)/, (r$1, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
+				i(/(\d+)\.\.(\d+)/, (r, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
+				i(/([a-z]+)\.\.([a-z]+)/, (r, e, n) => R(e, n).join("|")),
+				i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
 			]),
 			Or
-		]), kr = i$1("{", "(?:"), Br = i$1("}", ")"), Ir = i$1(",", "|"), Fr = i$1(/[$.*+?^(){[\]\|]/, (r$1) => `\\${r$1}`), Lr = i$1(/[^}]/, p), F = x([
+		]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r) => `\\${r}`), Lr = i(/[^}]/, p), F = x([
 			kr,
 			f(l([
 				j,
@@ -7246,36 +7246,36 @@ let _lazyMatch = () => {
 			y,
 			pr,
 			vr
-		]))), Tr = i$1(/\\./, p), qr = i$1(/./, p), Yr = z(f(l([
+		]))), Tr = i(/\\./, p), qr = i(/./, p), Yr = z(f(l([
 			Tr,
-			i$1(/\*\*\*+/, "*"),
-			i$1(/([^/{[(!])\*\*/, (r$1, e) => `${e}*`),
-			i$1(/(^|.)\*\*(?=[^*/)\]}])/, (r$1, e) => `${e}*`),
+			i(/\*\*\*+/, "*"),
+			i(/([^/{[(!])\*\*/, (r, e) => `${e}*`),
+			i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e) => `${e}*`),
 			qr
-		]))), $ = (r$1, e) => {
-			const n = Array.isArray(r$1) ? r$1 : [r$1];
+		]))), $ = (r, e) => {
+			const n = Array.isArray(r) ? r : [r];
 			if (!n.length) return false;
 			const a = n.map($.compile), t = n.every((s) => /(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
 			return a.some((s) => s.test(o));
 		};
-		$.compile = (r$1) => new RegExp(`^${L(Yr(r$1))}$`, "s");
+		$.compile = (r) => new RegExp(`^${L(Yr(r))}$`, "s");
 		var re = $;
 		return J(w);
 	})();
 	return __lib__.default || __lib__;
 };
 let _match;
-const zeptomatch = (path$13, pattern) => {
+const zeptomatch = (path, pattern) => {
 	if (!_match) {
 		_match = _lazyMatch();
 		_lazyMatch = null;
 	}
-	return _match(path$13, pattern);
+	return _match(path, pattern);
 };
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
 	if (!input) return input;
-	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r$1) => r$1.toUpperCase());
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
 const _UNC_REGEX = /^[/\\]{2}/;
 const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
@@ -7284,37 +7284,37 @@ const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
 const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
 const sep = "/";
-const normalize = function(path$13) {
-	if (path$13.length === 0) return ".";
-	path$13 = normalizeWindowsPath(path$13);
-	const isUNCPath = path$13.match(_UNC_REGEX);
-	const isPathAbsolute = isAbsolute(path$13);
-	const trailingSeparator = path$13[path$13.length - 1] === "/";
-	path$13 = normalizeString(path$13, !isPathAbsolute);
-	if (path$13.length === 0) {
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
 		if (isPathAbsolute) return "/";
 		return trailingSeparator ? "./" : ".";
 	}
-	if (trailingSeparator) path$13 += "/";
-	if (_DRIVE_LETTER_RE.test(path$13)) path$13 += "/";
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
 	if (isUNCPath) {
-		if (!isPathAbsolute) return `//./${path$13}`;
-		return `//${path$13}`;
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
 	}
-	return isPathAbsolute && !isAbsolute(path$13) ? `/${path$13}` : path$13;
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
 };
 const join = function(...segments) {
-	let path$13 = "";
+	let path = "";
 	for (const seg of segments) {
 		if (!seg) continue;
-		if (path$13.length > 0) {
-			const pathTrailing = path$13[path$13.length - 1] === "/";
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
 			const segLeading = seg[0] === "/";
-			if (pathTrailing && segLeading) path$13 += seg.slice(1);
-			else path$13 += pathTrailing || segLeading ? seg : `/${seg}`;
-		} else path$13 += seg;
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
 	}
-	return normalize(path$13);
+	return normalize(path);
 };
 function cwd$1() {
 	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
@@ -7325,23 +7325,23 @@ const resolve = function(...arguments_) {
 	let resolvedPath = "";
 	let resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-		const path$13 = index >= 0 ? arguments_[index] : cwd$1();
-		if (!path$13 || path$13.length === 0) continue;
-		resolvedPath = `${path$13}/${resolvedPath}`;
-		resolvedAbsolute = isAbsolute(path$13);
+		const path = index >= 0 ? arguments_[index] : cwd$1();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
 	}
 	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
 	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
 	return resolvedPath.length > 0 ? resolvedPath : ".";
 };
-function normalizeString(path$13, allowAboveRoot) {
+function normalizeString(path, allowAboveRoot) {
 	let res = "";
 	let lastSegmentLength = 0;
 	let lastSlash = -1;
 	let dots = 0;
 	let char = null;
-	for (let index = 0; index <= path$13.length; ++index) {
-		if (index < path$13.length) char = path$13[index];
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
 		else if (char === "/") break;
 		else char = "/";
 		if (char === "/") {
@@ -7373,8 +7373,8 @@ function normalizeString(path$13, allowAboveRoot) {
 					lastSegmentLength = 2;
 				}
 			} else {
-				if (res.length > 0) res += `/${path$13.slice(lastSlash + 1, index)}`;
-				else res = path$13.slice(lastSlash + 1, index);
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
 				lastSegmentLength = index - lastSlash - 1;
 			}
 			lastSlash = index;
@@ -7424,8 +7424,8 @@ const format$1 = function(p) {
 const basename = function(p, extension) {
 	const segments = normalizeWindowsPath(p).split("/");
 	let lastSegment = "";
-	for (let i$1 = segments.length - 1; i$1 >= 0; i$1--) {
-		const val = segments[i$1];
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
 		if (val) {
 			lastSegment = val;
 			break;
@@ -7445,8 +7445,8 @@ const parse$1 = function(p) {
 		name: base.slice(0, base.length - extension.length)
 	};
 };
-const matchesGlob = (path$13, pattern) => {
-	return zeptomatch(pattern, normalize(path$13));
+const matchesGlob = (path, pattern) => {
+	return zeptomatch(pattern, normalize(path));
 };
 const _path = {
 	__proto__: null,
@@ -7487,8 +7487,8 @@ const win32 = /* @__PURE__ */ mix(";");
 //#endregion
 //#region ../../node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.mjs
 const BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path$13) {
-	return path$13.replace(/\\/g, "/");
+function normalizeSlash(path) {
+	return path.replace(/\\/g, "/");
 }
 /**
 * @typedef ErrnoExceptionFields
@@ -7540,39 +7540,39 @@ codes.ERR_INVALID_ARG_TYPE = createError(
 	* @param {Array<string> | string} expected
 	* @param {unknown} actual
 	*/
-	(name$3, expected, actual) => {
-		assert(typeof name$3 === "string", "'name' must be a string");
+	(name, expected, actual) => {
+		assert(typeof name === "string", "'name' must be a string");
 		if (!Array.isArray(expected)) expected = [expected];
 		let message = "The ";
-		if (name$3.endsWith(" argument")) message += `${name$3} `;
+		if (name.endsWith(" argument")) message += `${name} `;
 		else {
-			const type = name$3.includes(".") ? "property" : "argument";
-			message += `"${name$3}" ${type} `;
+			const type = name.includes(".") ? "property" : "argument";
+			message += `"${name}" ${type} `;
 		}
 		message += "must be ";
 		/** @type {Array<string>} */
-		const types$2 = [];
+		const types = [];
 		/** @type {Array<string>} */
 		const instances = [];
 		/** @type {Array<string>} */
 		const other = [];
 		for (const value of expected) {
 			assert(typeof value === "string", "All expected entries have to be of type string");
-			if (kTypes.has(value)) types$2.push(value.toLowerCase());
+			if (kTypes.has(value)) types.push(value.toLowerCase());
 			else if (classRegExp.exec(value) === null) {
 				assert(value !== "object", "The value \"object\" should be written as \"Object\"");
 				other.push(value);
 			} else instances.push(value);
 		}
 		if (instances.length > 0) {
-			const pos = types$2.indexOf("object");
+			const pos = types.indexOf("object");
 			if (pos !== -1) {
-				types$2.slice(pos, 1);
+				types.slice(pos, 1);
 				instances.push("Object");
 			}
 		}
-		if (types$2.length > 0) {
-			message += `${types$2.length > 1 ? "one of type" : "of type"} ${formatList(types$2, "or")}`;
+		if (types.length > 0) {
+			message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
 			if (instances.length > 0 || other.length > 0) message += " or ";
 		}
 		if (instances.length > 0) {
@@ -7608,8 +7608,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
 	* @param {string} [base]
 	* @param {string} [message]
 	*/
-	(path$13, base, message) => {
-		return `Invalid package config ${path$13}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+	(path, base, message) => {
+		return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
 	},
 	Error
 );
@@ -7639,8 +7639,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
 	* @param {string} base
 	* @param {boolean} [exactUrl]
 	*/
-	(path$13, base, exactUrl = false) => {
-		return `Cannot find ${exactUrl ? "module" : "package"} '${path$13}' imported from ${base}`;
+	(path, base, exactUrl = false) => {
+		return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
 	},
 	Error
 );
@@ -7678,8 +7678,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
 	* @param {string} extension
 	* @param {string} path
 	*/
-	(extension, path$13) => {
-		return `Unknown file extension "${extension}" for ${path$13}`;
+	(extension, path) => {
+		return `Unknown file extension "${extension}" for ${path}`;
 	},
 	TypeError
 );
@@ -7690,10 +7690,10 @@ codes.ERR_INVALID_ARG_VALUE = createError(
 	* @param {unknown} value
 	* @param {string} [reason='is invalid']
 	*/
-	(name$3, value, reason = "is invalid") => {
+	(name, value, reason = "is invalid") => {
 		let inspected = inspect(value);
 		if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
-		return `The ${name$3.includes(".") ? "property" : "argument"} '${name$3}' ${reason}. Received ${inspected}`;
+		return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
 	},
 	TypeError
 );
@@ -7985,8 +7985,8 @@ function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
 		if (packageType === "none" || packageType === "commonjs") return "commonjs";
 		return "module";
 	}
-	const format$2 = extensionFormatMap[value];
-	if (format$2) return format$2;
+	const format = extensionFormatMap[value];
+	if (format) return format;
 	if (ignoreErrors) return;
 	throw new ERR_UNKNOWN_FILE_EXTENSION(value, fileURLToPath(url));
 }
@@ -8048,9 +8048,9 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 * @param {string} path
 * @returns {Stats | undefined}
 */
-function tryStatSync(path$13) {
+function tryStatSync(path) {
 	try {
-		return statSync(path$13);
+		return statSync(path);
 	} catch {}
 }
 /**
@@ -8081,7 +8081,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 	if (packageConfig.main !== void 0) {
 		guess = new URL$1(packageConfig.main, packageJsonUrl);
 		if (fileExists(guess)) return guess;
-		const tries$1 = [
+		const tries = [
 			`./${packageConfig.main}.js`,
 			`./${packageConfig.main}.json`,
 			`./${packageConfig.main}.node`,
@@ -8089,9 +8089,9 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 			`./${packageConfig.main}/index.json`,
 			`./${packageConfig.main}/index.node`
 		];
-		let i$2 = -1;
-		while (++i$2 < tries$1.length) {
-			guess = new URL$1(tries$1[i$2], packageJsonUrl);
+		let i = -1;
+		while (++i < tries.length) {
+			guess = new URL$1(tries[i], packageJsonUrl);
 			if (fileExists(guess)) break;
 			guess = void 0;
 		}
@@ -8105,9 +8105,9 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 		"./index.json",
 		"./index.node"
 	];
-	let i$1 = -1;
-	while (++i$1 < tries.length) {
-		guess = new URL$1(tries[i$1], packageJsonUrl);
+	let i = -1;
+	while (++i < tries.length) {
+		guess = new URL$1(tries[i], packageJsonUrl);
 		if (fileExists(guess)) break;
 		guess = void 0;
 	}
@@ -8270,9 +8270,9 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 		if (targetList.length === 0) return null;
 		/** @type {ErrnoException | null | undefined} */
 		let lastException;
-		let i$1 = -1;
-		while (++i$1 < targetList.length) {
-			const targetItem = targetList[i$1];
+		let i = -1;
+		while (++i < targetList.length) {
+			const targetItem = targetList[i];
 			/** @type {URL | null} */
 			let resolveResult;
 			try {
@@ -8295,14 +8295,14 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 	}
 	if (typeof target === "object" && target !== null) {
 		const keys = Object.getOwnPropertyNames(target);
-		let i$1 = -1;
-		while (++i$1 < keys.length) {
-			const key = keys[i$1];
+		let i = -1;
+		while (++i < keys.length) {
+			const key = keys[i];
 			if (isArrayIndex(key)) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), base, "\"exports\" cannot contain numeric property keys.");
 		}
-		i$1 = -1;
-		while (++i$1 < keys.length) {
-			const key = keys[i$1];
+		i = -1;
+		while (++i < keys.length) {
+			const key = keys[i];
 			if (key === "default" || conditions && conditions.has(key)) {
 				const conditionalTarget = target[key];
 				const resolveResult = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
@@ -8321,17 +8321,17 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 * @param {URL} base
 * @returns {boolean}
 */
-function isConditionalExportsMainSugar(exports$1, packageJsonUrl, base) {
-	if (typeof exports$1 === "string" || Array.isArray(exports$1)) return true;
-	if (typeof exports$1 !== "object" || exports$1 === null) return false;
-	const keys = Object.getOwnPropertyNames(exports$1);
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+	if (typeof exports === "string" || Array.isArray(exports)) return true;
+	if (typeof exports !== "object" || exports === null) return false;
+	const keys = Object.getOwnPropertyNames(exports);
 	let isConditionalSugar = false;
-	let i$1 = 0;
+	let i = 0;
 	let keyIndex = -1;
 	while (++keyIndex < keys.length) {
 		const key = keys[keyIndex];
 		const currentIsConditionalSugar = key === "" || key[0] !== ".";
-		if (i$1++ === 0) isConditionalSugar = currentIsConditionalSugar;
+		if (i++ === 0) isConditionalSugar = currentIsConditionalSugar;
 		else if (isConditionalSugar !== currentIsConditionalSugar) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), base, "\"exports\" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.");
 	}
 	return isConditionalSugar;
@@ -8357,20 +8357,20 @@ function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
 * @returns {URL}
 */
 function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-	let exports$1 = packageConfig.exports;
-	if (isConditionalExportsMainSugar(exports$1, packageJsonUrl, base)) exports$1 = { ".": exports$1 };
-	if (own.call(exports$1, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-		const target = exports$1[packageSubpath];
+	let exports = packageConfig.exports;
+	if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) exports = { ".": exports };
+	if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+		const target = exports[packageSubpath];
 		const resolveResult = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base, false, false, false, conditions);
 		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 		return resolveResult;
 	}
 	let bestMatch = "";
 	let bestMatchSubpath = "";
-	const keys = Object.getOwnPropertyNames(exports$1);
-	let i$1 = -1;
-	while (++i$1 < keys.length) {
-		const key = keys[i$1];
+	const keys = Object.getOwnPropertyNames(exports);
+	let i = -1;
+	while (++i < keys.length) {
+		const key = keys[i];
 		const patternIndex = key.indexOf("*");
 		if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
 			if (packageSubpath.endsWith("/")) emitTrailingSlashPatternDeprecation(packageSubpath, packageJsonUrl, base);
@@ -8382,7 +8382,7 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
 		}
 	}
 	if (bestMatch) {
-		const target = exports$1[bestMatch];
+		const target = exports[bestMatch];
 		const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, false, packageSubpath.endsWith("/"), conditions);
 		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 		return resolveResult;
@@ -8412,30 +8412,30 @@ function patternKeyCompare(a, b) {
 * @param {Set<string>} [conditions]
 * @returns {URL}
 */
-function packageImportsResolve(name$3, base, conditions) {
-	if (name$3 === "#" || name$3.startsWith("#/") || name$3.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name$3, "is not a valid internal imports specifier name", fileURLToPath(base));
+function packageImportsResolve(name, base, conditions) {
+	if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
 	/** @type {URL | undefined} */
 	let packageJsonUrl;
 	const packageConfig = getPackageScopeConfig(base);
 	if (packageConfig.exists) {
 		packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
 		const imports = packageConfig.imports;
-		if (imports) if (own.call(imports, name$3) && !name$3.includes("*")) {
-			const resolveResult = resolvePackageTarget(packageJsonUrl, imports[name$3], "", name$3, base, false, true, false, conditions);
+		if (imports) if (own.call(imports, name) && !name.includes("*")) {
+			const resolveResult = resolvePackageTarget(packageJsonUrl, imports[name], "", name, base, false, true, false, conditions);
 			if (resolveResult !== null && resolveResult !== void 0) return resolveResult;
 		} else {
 			let bestMatch = "";
 			let bestMatchSubpath = "";
 			const keys = Object.getOwnPropertyNames(imports);
-			let i$1 = -1;
-			while (++i$1 < keys.length) {
-				const key = keys[i$1];
+			let i = -1;
+			while (++i < keys.length) {
+				const key = keys[i];
 				const patternIndex = key.indexOf("*");
-				if (patternIndex !== -1 && name$3.startsWith(key.slice(0, -1))) {
+				if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
 					const patternTrailer = key.slice(patternIndex + 1);
-					if (name$3.length >= key.length && name$3.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+					if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
 						bestMatch = key;
-						bestMatchSubpath = name$3.slice(patternIndex, name$3.length - patternTrailer.length);
+						bestMatchSubpath = name.slice(patternIndex, name.length - patternTrailer.length);
 					}
 				}
 			}
@@ -8446,7 +8446,7 @@ function packageImportsResolve(name$3, base, conditions) {
 			}
 		}
 	}
-	throw importNotDefined(name$3, packageJsonUrl, base);
+	throw importNotDefined(name, packageJsonUrl, base);
 }
 /**
 * @param {string} specifier
@@ -8482,8 +8482,8 @@ function packageResolve(specifier, base, conditions) {
 	const packageConfig = getPackageScopeConfig(base);
 	/* c8 ignore next 16 */
 	if (packageConfig.exists) {
-		const packageJsonUrl$1 = pathToFileURL(packageConfig.pjsonPath);
-		if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl$1, packageSubpath, packageConfig, base, conditions);
+		const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+		if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
 	}
 	let packageJsonUrl = new URL$1("./node_modules/" + packageName + "/package.json", base);
 	let packageJsonPath = fileURLToPath(packageJsonUrl);
@@ -8497,12 +8497,12 @@ function packageResolve(specifier, base, conditions) {
 			packageJsonPath = fileURLToPath(packageJsonUrl);
 			continue;
 		}
-		const packageConfig$1 = read(packageJsonPath, {
+		const packageConfig = read(packageJsonPath, {
 			base,
 			specifier
 		});
-		if (packageConfig$1.exports !== void 0 && packageConfig$1.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig$1, base, conditions);
-		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig$1, base);
+		if (packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig, base);
 		return new URL$1(packageSubpath, packageJsonUrl);
 	} while (packageJsonPath.length !== lastPath.length);
 	throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false);
@@ -8712,7 +8712,7 @@ const routeJSXReg = /^\s+(route)\s+/gm;
 function parseJSX(code) {
 	return extractComments(code).slice(0, 1).filter((comment) => routeJSXReg.test(comment.value) && comment.value.includes(":") && comment.loc.start.line === 1);
 }
-function parseYamlComment(code, path$13) {
+function parseYamlComment(code, path) {
 	return code.reduce((memo, item) => {
 		const { value } = item;
 		const v = value.replace(routeJSXReg, "");
@@ -8723,12 +8723,12 @@ function parseYamlComment(code, path$13) {
 				...yamlResult
 			};
 		} catch (err) {
-			throw new Error(`Invalid YAML format of comment in ${path$13}\n${err.message}`);
+			throw new Error(`Invalid YAML format of comment in ${path}\n${err.message}`);
 		}
 	}, {});
 }
-function getRouteBlock(path$13) {
-	return parseYamlComment(parseJSX(import_lib.default.readFileSync(path$13, "utf-8")), path$13);
+function getRouteBlock(path) {
+	return parseYamlComment(parseJSX(import_lib.default.readFileSync(path, "utf-8")), path);
 }
 function extendRoute(route) {
 	if (!route.element) return;
@@ -8745,9 +8745,9 @@ const name$2 = "vixt:preset-react";
 var preset_react_default = defineVixtModule({
 	meta: { name: name$2 },
 	setup(_, vixt) {
-		const { components = [], constants: constants$1 = [], hooks = [], layouts = [], pages = [], stores = [], utils = [] } = resolveLayersDirs([...vixt._layers].reverse());
+		const { components = [], constants = [], hooks = [], layouts = [], pages = [], stores = [], utils = [] } = resolveLayersDirs([...vixt._layers].reverse());
 		const { buildTypesDir } = vixt.options;
-		const defaultOptions$1 = {
+		const defaultOptions = {
 			react: {},
 			pages: {
 				dirs: pages,
@@ -8769,7 +8769,7 @@ var preset_react_default = defineVixtModule({
 				],
 				dts: `${buildTypesDir}/auto-imports.d.ts`,
 				dirs: [
-					constants$1,
+					constants,
 					hooks,
 					stores,
 					utils
@@ -8777,7 +8777,7 @@ var preset_react_default = defineVixtModule({
 			},
 			unocss: {}
 		};
-		const options = vixt.options = defu(vixt.options, defaultOptions$1);
+		const options = vixt.options = defu(vixt.options, defaultOptions);
 		return [
 			UnoCSS(options.unocss),
 			React(options.react),
@@ -8824,8 +8824,8 @@ var virtual_root_component_default = defineVixtModule({
 			},
 			load(id) {
 				if (id === name$1) {
-					const { path: path$13, code } = resolveRootComponent(vixt);
-					this.addWatchFile(path$13);
+					const { path, code } = resolveRootComponent(vixt);
+					this.addWatchFile(path);
 					return code;
 				}
 			}