@dylanpiercey/work 0.0.1

package/dist/_JcAWG3K1.js

@@ -0,0 +1,2422 @@
+import { a as __toCommonJS, i as __require, n as __esmMin, r as __exportAll, t as __commonJSMin } from "./_BMI-E3GI.js";
+import { n as require_ms, r as require_inherits, t as require_src } from "./_xlrdOUsL.js";
+import { t as require_mime_db } from "./_DmVVbFOa.js";
+//#region node_modules/.pnpm/encodeurl@2.0.0/node_modules/encodeurl/index.js
+/*!
+* encodeurl
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_encodeurl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = encodeUrl;
+	/**
+	* RegExp to match non-URL code points, *after* encoding (i.e. not including "%")
+	* and including invalid escape sequences.
+	* @private
+	*/
+	var ENCODE_CHARS_REGEXP = /(?:[^\x21\x23-\x3B\x3D\x3F-\x5F\x61-\x7A\x7C\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;
+	/**
+	* RegExp to match unmatched surrogate pair.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
+	/**
+	* String to replace unmatched surrogate pair with.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REPLACE = "$1�$2";
+	/**
+	* Encode a URL to a percent-encoded form, excluding already-encoded sequences.
+	*
+	* This function will take an already-encoded URL and encode all the non-URL
+	* code points. This function will not encode the "%" character unless it is
+	* not part of a valid sequence (`%20` will be left as-is, but `%foo` will
+	* be encoded as `%25foo`).
+	*
+	* This encode is meant to be "safe" and does not throw errors. It will try as
+	* hard as it can to properly encode the given URL, including replacing any raw,
+	* unpaired surrogate pairs with the Unicode replacement character prior to
+	* encoding.
+	*
+	* @param {string} url
+	* @return {string}
+	* @public
+	*/
+	function encodeUrl(url) {
+		return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js
+/*!
+* escape-html
+* Copyright(c) 2012-2013 TJ Holowaychuk
+* Copyright(c) 2015 Andreas Lubbe
+* Copyright(c) 2015 Tiancheng "Timothy" Gu
+* MIT Licensed
+*/
+var require_escape_html = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module variables.
+	* @private
+	*/
+	var matchHtmlRegExp = /["'&<>]/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = escapeHtml;
+	/**
+	* Escape special characters in the given string of html.
+	*
+	* @param  {string} string The string to escape for inserting into HTML
+	* @return {string}
+	* @public
+	*/
+	function escapeHtml(string) {
+		var str = "" + string;
+		var match = matchHtmlRegExp.exec(str);
+		if (!match) return str;
+		var escape;
+		var html = "";
+		var index = 0;
+		var lastIndex = 0;
+		for (index = match.index; index < str.length; index++) {
+			switch (str.charCodeAt(index)) {
+				case 34:
+					escape = "&quot;";
+					break;
+				case 38:
+					escape = "&amp;";
+					break;
+				case 39:
+					escape = "&#39;";
+					break;
+				case 60:
+					escape = "&lt;";
+					break;
+				case 62:
+					escape = "&gt;";
+					break;
+				default: continue;
+			}
+			if (lastIndex !== index) html += str.substring(lastIndex, index);
+			lastIndex = index + 1;
+			html += escape;
+		}
+		return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js
+/*!
+* parseurl
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_parseurl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var url$1 = __require("url");
+	var parse = url$1.parse;
+	var Url = url$1.Url;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = parseurl;
+	module.exports.original = originalurl;
+	/**
+	* Parse the `req` url with memoization.
+	*
+	* @param {ServerRequest} req
+	* @return {Object}
+	* @public
+	*/
+	function parseurl(req) {
+		var url = req.url;
+		if (url === void 0) return;
+		var parsed = req._parsedUrl;
+		if (fresh(url, parsed)) return parsed;
+		parsed = fastparse(url);
+		parsed._raw = url;
+		return req._parsedUrl = parsed;
+	}
+	/**
+	* Parse the `req` original url with fallback and memoization.
+	*
+	* @param {ServerRequest} req
+	* @return {Object}
+	* @public
+	*/
+	function originalurl(req) {
+		var url = req.originalUrl;
+		if (typeof url !== "string") return parseurl(req);
+		var parsed = req._parsedOriginalUrl;
+		if (fresh(url, parsed)) return parsed;
+		parsed = fastparse(url);
+		parsed._raw = url;
+		return req._parsedOriginalUrl = parsed;
+	}
+	/**
+	* Parse the `str` url with fast-path short-cut.
+	*
+	* @param {string} str
+	* @return {Object}
+	* @private
+	*/
+	function fastparse(str) {
+		if (typeof str !== "string" || str.charCodeAt(0) !== 47) return parse(str);
+		var pathname = str;
+		var query = null;
+		var search = null;
+		for (var i = 1; i < str.length; i++) switch (str.charCodeAt(i)) {
+			case 63:
+				if (search === null) {
+					pathname = str.substring(0, i);
+					query = str.substring(i + 1);
+					search = str.substring(i);
+				}
+				break;
+			case 9:
+			case 10:
+			case 12:
+			case 13:
+			case 32:
+			case 35:
+			case 160:
+			case 65279: return parse(str);
+		}
+		var url = Url !== void 0 ? new Url() : {};
+		url.path = str;
+		url.href = str;
+		url.pathname = pathname;
+		if (search !== null) {
+			url.query = query;
+			url.search = search;
+		}
+		return url;
+	}
+	/**
+	* Determine if parsed is still fresh for url.
+	*
+	* @param {string} url
+	* @param {object} parsedUrl
+	* @return {boolean}
+	* @private
+	*/
+	function fresh(url, parsedUrl) {
+		return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js
+var require_depd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	* depd
+	* Copyright(c) 2014-2018 Douglas Christopher Wilson
+	* MIT Licensed
+	*/
+	/**
+	* Module dependencies.
+	*/
+	var relative = __require("path").relative;
+	/**
+	* Module exports.
+	*/
+	module.exports = depd;
+	/**
+	* Get the path to base files on.
+	*/
+	var basePath = process.cwd();
+	/**
+	* Determine if namespace is contained in the string.
+	*/
+	function containsNamespace(str, namespace) {
+		var vals = str.split(/[ ,]+/);
+		var ns = String(namespace).toLowerCase();
+		for (var i = 0; i < vals.length; i++) {
+			var val = vals[i];
+			if (val && (val === "*" || val.toLowerCase() === ns)) return true;
+		}
+		return false;
+	}
+	/**
+	* Convert a data descriptor to accessor descriptor.
+	*/
+	function convertDataDescriptorToAccessor(obj, prop, message) {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+		var value = descriptor.value;
+		descriptor.get = function getter() {
+			return value;
+		};
+		if (descriptor.writable) descriptor.set = function setter(val) {
+			return value = val;
+		};
+		delete descriptor.value;
+		delete descriptor.writable;
+		Object.defineProperty(obj, prop, descriptor);
+		return descriptor;
+	}
+	/**
+	* Create arguments string to keep arity.
+	*/
+	function createArgumentsString(arity) {
+		var str = "";
+		for (var i = 0; i < arity; i++) str += ", arg" + i;
+		return str.substr(2);
+	}
+	/**
+	* Create stack string from stack.
+	*/
+	function createStackString(stack) {
+		var str = this.name + ": " + this.namespace;
+		if (this.message) str += " deprecated " + this.message;
+		for (var i = 0; i < stack.length; i++) str += "\n    at " + stack[i].toString();
+		return str;
+	}
+	/**
+	* Create deprecate for namespace in caller.
+	*/
+	function depd(namespace) {
+		if (!namespace) throw new TypeError("argument namespace is required");
+		var file = callSiteLocation(getStack()[1])[0];
+		function deprecate(message) {
+			log.call(deprecate, message);
+		}
+		deprecate._file = file;
+		deprecate._ignored = isignored(namespace);
+		deprecate._namespace = namespace;
+		deprecate._traced = istraced(namespace);
+		deprecate._warned = Object.create(null);
+		deprecate.function = wrapfunction;
+		deprecate.property = wrapproperty;
+		return deprecate;
+	}
+	/**
+	* Determine if event emitter has listeners of a given type.
+	*
+	* The way to do this check is done three different ways in Node.js >= 0.8
+	* so this consolidates them into a minimal set using instance methods.
+	*
+	* @param {EventEmitter} emitter
+	* @param {string} type
+	* @returns {boolean}
+	* @private
+	*/
+	function eehaslisteners(emitter, type) {
+		return (typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type)) > 0;
+	}
+	/**
+	* Determine if namespace is ignored.
+	*/
+	function isignored(namespace) {
+		if (process.noDeprecation) return true;
+		return containsNamespace(process.env.NO_DEPRECATION || "", namespace);
+	}
+	/**
+	* Determine if namespace is traced.
+	*/
+	function istraced(namespace) {
+		if (process.traceDeprecation) return true;
+		return containsNamespace(process.env.TRACE_DEPRECATION || "", namespace);
+	}
+	/**
+	* Display deprecation message.
+	*/
+	function log(message, site) {
+		var haslisteners = eehaslisteners(process, "deprecation");
+		if (!haslisteners && this._ignored) return;
+		var caller;
+		var callFile;
+		var callSite;
+		var depSite;
+		var i = 0;
+		var seen = false;
+		var stack = getStack();
+		var file = this._file;
+		if (site) {
+			depSite = site;
+			callSite = callSiteLocation(stack[1]);
+			callSite.name = depSite.name;
+			file = callSite[0];
+		} else {
+			i = 2;
+			depSite = callSiteLocation(stack[i]);
+			callSite = depSite;
+		}
+		for (; i < stack.length; i++) {
+			caller = callSiteLocation(stack[i]);
+			callFile = caller[0];
+			if (callFile === file) seen = true;
+			else if (callFile === this._file) file = this._file;
+			else if (seen) break;
+		}
+		var key = caller ? depSite.join(":") + "__" + caller.join(":") : void 0;
+		if (key !== void 0 && key in this._warned) return;
+		this._warned[key] = true;
+		var msg = message;
+		if (!msg) msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);
+		if (haslisteners) {
+			var err = DeprecationError(this._namespace, msg, stack.slice(i));
+			process.emit("deprecation", err);
+			return;
+		}
+		var output = (process.stderr.isTTY ? formatColor : formatPlain).call(this, msg, caller, stack.slice(i));
+		process.stderr.write(output + "\n", "utf8");
+	}
+	/**
+	* Get call site location as array.
+	*/
+	function callSiteLocation(callSite) {
+		var file = callSite.getFileName() || "<anonymous>";
+		var line = callSite.getLineNumber();
+		var colm = callSite.getColumnNumber();
+		if (callSite.isEval()) file = callSite.getEvalOrigin() + ", " + file;
+		var site = [
+			file,
+			line,
+			colm
+		];
+		site.callSite = callSite;
+		site.name = callSite.getFunctionName();
+		return site;
+	}
+	/**
+	* Generate a default message from the site.
+	*/
+	function defaultMessage(site) {
+		var callSite = site.callSite;
+		var funcName = site.name;
+		if (!funcName) funcName = "<anonymous@" + formatLocation(site) + ">";
+		var context = callSite.getThis();
+		var typeName = context && callSite.getTypeName();
+		if (typeName === "Object") typeName = void 0;
+		if (typeName === "Function") typeName = context.name || typeName;
+		return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
+	}
+	/**
+	* Format deprecation message without color.
+	*/
+	function formatPlain(msg, caller, stack) {
+		var formatted = (/* @__PURE__ */ new Date()).toUTCString() + " " + this._namespace + " deprecated " + msg;
+		if (this._traced) {
+			for (var i = 0; i < stack.length; i++) formatted += "\n    at " + stack[i].toString();
+			return formatted;
+		}
+		if (caller) formatted += " at " + formatLocation(caller);
+		return formatted;
+	}
+	/**
+	* Format deprecation message with color.
+	*/
+	function formatColor(msg, caller, stack) {
+		var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m \x1B[33;1mdeprecated\x1B[22;39m \x1B[0m" + msg + "\x1B[39m";
+		if (this._traced) {
+			for (var i = 0; i < stack.length; i++) formatted += "\n    \x1B[36mat " + stack[i].toString() + "\x1B[39m";
+			return formatted;
+		}
+		if (caller) formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m";
+		return formatted;
+	}
+	/**
+	* Format call site location.
+	*/
+	function formatLocation(callSite) {
+		return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+	}
+	/**
+	* Get the stack as array of call sites.
+	*/
+	function getStack() {
+		var limit = Error.stackTraceLimit;
+		var obj = {};
+		var prep = Error.prepareStackTrace;
+		Error.prepareStackTrace = prepareObjectStackTrace;
+		Error.stackTraceLimit = Math.max(10, limit);
+		Error.captureStackTrace(obj);
+		var stack = obj.stack.slice(1);
+		Error.prepareStackTrace = prep;
+		Error.stackTraceLimit = limit;
+		return stack;
+	}
+	/**
+	* Capture call site stack from v8.
+	*/
+	function prepareObjectStackTrace(obj, stack) {
+		return stack;
+	}
+	/**
+	* Return a wrapped function in a deprecation message.
+	*/
+	function wrapfunction(fn, message) {
+		if (typeof fn !== "function") throw new TypeError("argument fn must be a function");
+		var args = createArgumentsString(fn.length);
+		var site = callSiteLocation(getStack()[1]);
+		site.name = fn.name;
+		return new Function("fn", "log", "deprecate", "message", "site", "\"use strict\"\nreturn function (" + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}")(fn, log, this, message, site);
+	}
+	/**
+	* Wrap property in a deprecation message.
+	*/
+	function wrapproperty(obj, prop, message) {
+		if (!obj || typeof obj !== "object" && typeof obj !== "function") throw new TypeError("argument obj must be object");
+		var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+		if (!descriptor) throw new TypeError("must call property on owner object");
+		if (!descriptor.configurable) throw new TypeError("property must be configurable");
+		var deprecate = this;
+		var site = callSiteLocation(getStack()[1]);
+		site.name = prop;
+		if ("value" in descriptor) descriptor = convertDataDescriptorToAccessor(obj, prop, message);
+		var get = descriptor.get;
+		var set = descriptor.set;
+		if (typeof get === "function") descriptor.get = function getter() {
+			log.call(deprecate, message, site);
+			return get.apply(this, arguments);
+		};
+		if (typeof set === "function") descriptor.set = function setter() {
+			log.call(deprecate, message, site);
+			return set.apply(this, arguments);
+		};
+		Object.defineProperty(obj, prop, descriptor);
+	}
+	/**
+	* Create DeprecationError for deprecation
+	*/
+	function DeprecationError(namespace, message, stack) {
+		var error = /* @__PURE__ */ new Error();
+		var stackString;
+		Object.defineProperty(error, "constructor", { value: DeprecationError });
+		Object.defineProperty(error, "message", {
+			configurable: true,
+			enumerable: false,
+			value: message,
+			writable: true
+		});
+		Object.defineProperty(error, "name", {
+			enumerable: false,
+			configurable: true,
+			value: "DeprecationError",
+			writable: true
+		});
+		Object.defineProperty(error, "namespace", {
+			configurable: true,
+			enumerable: false,
+			value: namespace,
+			writable: true
+		});
+		Object.defineProperty(error, "stack", {
+			configurable: true,
+			enumerable: false,
+			get: function() {
+				if (stackString !== void 0) return stackString;
+				return stackString = createStackString.call(this, stack);
+			},
+			set: function setter(val) {
+				stackString = val;
+			}
+		});
+		return error;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/setprototypeof@1.2.0/node_modules/setprototypeof/index.js
+var require_setprototypeof = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
+	function setProtoOf(obj, proto) {
+		obj.__proto__ = proto;
+		return obj;
+	}
+	function mixinProperties(obj, proto) {
+		for (var prop in proto) if (!Object.prototype.hasOwnProperty.call(obj, prop)) obj[prop] = proto[prop];
+		return obj;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json
+var codes_exports = /* @__PURE__ */ __exportAll({ default: () => codes_default });
+var codes_default;
+var init_codes = __esmMin((() => {
+	codes_default = {
+		"100": "Continue",
+		"101": "Switching Protocols",
+		"102": "Processing",
+		"103": "Early Hints",
+		"200": "OK",
+		"201": "Created",
+		"202": "Accepted",
+		"203": "Non-Authoritative Information",
+		"204": "No Content",
+		"205": "Reset Content",
+		"206": "Partial Content",
+		"207": "Multi-Status",
+		"208": "Already Reported",
+		"226": "IM Used",
+		"300": "Multiple Choices",
+		"301": "Moved Permanently",
+		"302": "Found",
+		"303": "See Other",
+		"304": "Not Modified",
+		"305": "Use Proxy",
+		"307": "Temporary Redirect",
+		"308": "Permanent Redirect",
+		"400": "Bad Request",
+		"401": "Unauthorized",
+		"402": "Payment Required",
+		"403": "Forbidden",
+		"404": "Not Found",
+		"405": "Method Not Allowed",
+		"406": "Not Acceptable",
+		"407": "Proxy Authentication Required",
+		"408": "Request Timeout",
+		"409": "Conflict",
+		"410": "Gone",
+		"411": "Length Required",
+		"412": "Precondition Failed",
+		"413": "Payload Too Large",
+		"414": "URI Too Long",
+		"415": "Unsupported Media Type",
+		"416": "Range Not Satisfiable",
+		"417": "Expectation Failed",
+		"418": "I'm a Teapot",
+		"421": "Misdirected Request",
+		"422": "Unprocessable Entity",
+		"423": "Locked",
+		"424": "Failed Dependency",
+		"425": "Too Early",
+		"426": "Upgrade Required",
+		"428": "Precondition Required",
+		"429": "Too Many Requests",
+		"431": "Request Header Fields Too Large",
+		"451": "Unavailable For Legal Reasons",
+		"500": "Internal Server Error",
+		"501": "Not Implemented",
+		"502": "Bad Gateway",
+		"503": "Service Unavailable",
+		"504": "Gateway Timeout",
+		"505": "HTTP Version Not Supported",
+		"506": "Variant Also Negotiates",
+		"507": "Insufficient Storage",
+		"508": "Loop Detected",
+		"509": "Bandwidth Limit Exceeded",
+		"510": "Not Extended",
+		"511": "Network Authentication Required"
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js
+/*!
+* statuses
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_statuses = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var codes = (init_codes(), __toCommonJS(codes_exports).default);
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = status;
+	status.message = codes;
+	status.code = createMessageToStatusCodeMap(codes);
+	status.codes = createStatusCodeList(codes);
+	status.redirect = {
+		300: true,
+		301: true,
+		302: true,
+		303: true,
+		305: true,
+		307: true,
+		308: true
+	};
+	status.empty = {
+		204: true,
+		205: true,
+		304: true
+	};
+	status.retry = {
+		502: true,
+		503: true,
+		504: true
+	};
+	/**
+	* Create a map of message to status code.
+	* @private
+	*/
+	function createMessageToStatusCodeMap(codes) {
+		var map = {};
+		Object.keys(codes).forEach(function forEachCode(code) {
+			var message = codes[code];
+			var status = Number(code);
+			map[message.toLowerCase()] = status;
+		});
+		return map;
+	}
+	/**
+	* Create a list of all status codes.
+	* @private
+	*/
+	function createStatusCodeList(codes) {
+		return Object.keys(codes).map(function mapCode(code) {
+			return Number(code);
+		});
+	}
+	/**
+	* Get the status code for given message.
+	* @private
+	*/
+	function getStatusCode(message) {
+		var msg = message.toLowerCase();
+		if (!Object.prototype.hasOwnProperty.call(status.code, msg)) throw new Error("invalid status message: \"" + message + "\"");
+		return status.code[msg];
+	}
+	/**
+	* Get the status message for given code.
+	* @private
+	*/
+	function getStatusMessage(code) {
+		if (!Object.prototype.hasOwnProperty.call(status.message, code)) throw new Error("invalid status code: " + code);
+		return status.message[code];
+	}
+	/**
+	* Get the status code.
+	*
+	* Given a number, this will throw if it is not a known status
+	* code, otherwise the code will be returned. Given a string,
+	* the string will be parsed for a number and return the code
+	* if valid, otherwise will lookup the code assuming this is
+	* the status message.
+	*
+	* @param {string|number} code
+	* @returns {number}
+	* @public
+	*/
+	function status(code) {
+		if (typeof code === "number") return getStatusMessage(code);
+		if (typeof code !== "string") throw new TypeError("code must be a number or string");
+		var n = parseInt(code, 10);
+		if (!isNaN(n)) return getStatusMessage(n);
+		return getStatusCode(code);
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js
+/*!
+* toidentifier
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_toidentifier = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = toIdentifier;
+	/**
+	* Trasform the given string into a JavaScript identifier
+	*
+	* @param {string} str
+	* @returns {string}
+	* @public
+	*/
+	function toIdentifier(str) {
+		return str.split(" ").map(function(token) {
+			return token.slice(0, 1).toUpperCase() + token.slice(1);
+		}).join("").replace(/[^ _0-9a-z]/gi, "");
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/http-errors@2.0.1/node_modules/http-errors/index.js
+/*!
+* http-errors
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_http_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var deprecate = require_depd()("http-errors");
+	var setPrototypeOf = require_setprototypeof();
+	var statuses = require_statuses();
+	var inherits = require_inherits();
+	var toIdentifier = require_toidentifier();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = createError;
+	module.exports.HttpError = createHttpErrorConstructor();
+	module.exports.isHttpError = createIsHttpErrorFunction(module.exports.HttpError);
+	populateConstructorExports(module.exports, statuses.codes, module.exports.HttpError);
+	/**
+	* Get the code class of a status code.
+	* @private
+	*/
+	function codeClass(status) {
+		return Number(String(status).charAt(0) + "00");
+	}
+	/**
+	* Create a new HTTP Error.
+	*
+	* @returns {Error}
+	* @public
+	*/
+	function createError() {
+		var err;
+		var msg;
+		var status = 500;
+		var props = {};
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			var type = typeof arg;
+			if (type === "object" && arg instanceof Error) {
+				err = arg;
+				status = err.status || err.statusCode || status;
+			} else if (type === "number" && i === 0) status = arg;
+			else if (type === "string") msg = arg;
+			else if (type === "object") props = arg;
+			else throw new TypeError("argument #" + (i + 1) + " unsupported type " + type);
+		}
+		if (typeof status === "number" && (status < 400 || status >= 600)) deprecate("non-error status code; use only 4xx or 5xx status codes");
+		if (typeof status !== "number" || !statuses.message[status] && (status < 400 || status >= 600)) status = 500;
+		var HttpError = createError[status] || createError[codeClass(status)];
+		if (!err) {
+			err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]);
+			Error.captureStackTrace(err, createError);
+		}
+		if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
+			err.expose = status < 500;
+			err.status = err.statusCode = status;
+		}
+		for (var key in props) if (key !== "status" && key !== "statusCode") err[key] = props[key];
+		return err;
+	}
+	/**
+	* Create HTTP error abstract base class.
+	* @private
+	*/
+	function createHttpErrorConstructor() {
+		function HttpError() {
+			throw new TypeError("cannot construct abstract class");
+		}
+		inherits(HttpError, Error);
+		return HttpError;
+	}
+	/**
+	* Create a constructor for a client error.
+	* @private
+	*/
+	function createClientErrorConstructor(HttpError, name, code) {
+		var className = toClassName(name);
+		function ClientError(message) {
+			var msg = message != null ? message : statuses.message[code];
+			var err = new Error(msg);
+			Error.captureStackTrace(err, ClientError);
+			setPrototypeOf(err, ClientError.prototype);
+			Object.defineProperty(err, "message", {
+				enumerable: true,
+				configurable: true,
+				value: msg,
+				writable: true
+			});
+			Object.defineProperty(err, "name", {
+				enumerable: false,
+				configurable: true,
+				value: className,
+				writable: true
+			});
+			return err;
+		}
+		inherits(ClientError, HttpError);
+		nameFunc(ClientError, className);
+		ClientError.prototype.status = code;
+		ClientError.prototype.statusCode = code;
+		ClientError.prototype.expose = true;
+		return ClientError;
+	}
+	/**
+	* Create function to test is a value is a HttpError.
+	* @private
+	*/
+	function createIsHttpErrorFunction(HttpError) {
+		return function isHttpError(val) {
+			if (!val || typeof val !== "object") return false;
+			if (val instanceof HttpError) return true;
+			return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode;
+		};
+	}
+	/**
+	* Create a constructor for a server error.
+	* @private
+	*/
+	function createServerErrorConstructor(HttpError, name, code) {
+		var className = toClassName(name);
+		function ServerError(message) {
+			var msg = message != null ? message : statuses.message[code];
+			var err = new Error(msg);
+			Error.captureStackTrace(err, ServerError);
+			setPrototypeOf(err, ServerError.prototype);
+			Object.defineProperty(err, "message", {
+				enumerable: true,
+				configurable: true,
+				value: msg,
+				writable: true
+			});
+			Object.defineProperty(err, "name", {
+				enumerable: false,
+				configurable: true,
+				value: className,
+				writable: true
+			});
+			return err;
+		}
+		inherits(ServerError, HttpError);
+		nameFunc(ServerError, className);
+		ServerError.prototype.status = code;
+		ServerError.prototype.statusCode = code;
+		ServerError.prototype.expose = false;
+		return ServerError;
+	}
+	/**
+	* Set the name of a function, if possible.
+	* @private
+	*/
+	function nameFunc(func, name) {
+		var desc = Object.getOwnPropertyDescriptor(func, "name");
+		if (desc && desc.configurable) {
+			desc.value = name;
+			Object.defineProperty(func, "name", desc);
+		}
+	}
+	/**
+	* Populate the exports object with constructors for every error class.
+	* @private
+	*/
+	function populateConstructorExports(exports$1, codes, HttpError) {
+		codes.forEach(function forEachCode(code) {
+			var CodeError;
+			var name = toIdentifier(statuses.message[code]);
+			switch (codeClass(code)) {
+				case 400:
+					CodeError = createClientErrorConstructor(HttpError, name, code);
+					break;
+				case 500: CodeError = createServerErrorConstructor(HttpError, name, code);
+			}
+			if (CodeError) {
+				exports$1[code] = CodeError;
+				exports$1[name] = CodeError;
+			}
+		});
+	}
+	/**
+	* Get a class name from a name identifier.
+	*
+	* @param {string} name
+	* @returns {string}
+	* @private
+	*/
+	function toClassName(name) {
+		return name.slice(-5) === "Error" ? name : name + "Error";
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js
+/*!
+* etag
+* Copyright(c) 2014-2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_etag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = etag;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var crypto = __require("crypto");
+	var Stats = __require("fs").Stats;
+	/**
+	* Module variables.
+	* @private
+	*/
+	var toString = Object.prototype.toString;
+	/**
+	* Generate an entity tag.
+	*
+	* @param {Buffer|string} entity
+	* @return {string}
+	* @private
+	*/
+	function entitytag(entity) {
+		if (entity.length === 0) return "\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"";
+		var hash = crypto.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
+		return "\"" + (typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length).toString(16) + "-" + hash + "\"";
+	}
+	/**
+	* Create a simple ETag.
+	*
+	* @param {string|Buffer|Stats} entity
+	* @param {object} [options]
+	* @param {boolean} [options.weak]
+	* @return {String}
+	* @public
+	*/
+	function etag(entity, options) {
+		if (entity == null) throw new TypeError("argument entity is required");
+		var isStats = isstats(entity);
+		var weak = options && typeof options.weak === "boolean" ? options.weak : isStats;
+		if (!isStats && typeof entity !== "string" && !Buffer.isBuffer(entity)) throw new TypeError("argument entity must be string, Buffer, or fs.Stats");
+		var tag = isStats ? stattag(entity) : entitytag(entity);
+		return weak ? "W/" + tag : tag;
+	}
+	/**
+	* Determine if object is a Stats object.
+	*
+	* @param {object} obj
+	* @return {boolean}
+	* @api private
+	*/
+	function isstats(obj) {
+		if (typeof Stats === "function" && obj instanceof Stats) return true;
+		return obj && typeof obj === "object" && "ctime" in obj && toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
+	}
+	/**
+	* Generate a tag for a stat.
+	*
+	* @param {object} stat
+	* @return {string}
+	* @private
+	*/
+	function stattag(stat) {
+		var mtime = stat.mtime.getTime().toString(16);
+		return "\"" + stat.size.toString(16) + "-" + mtime + "\"";
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/fresh@2.0.0/node_modules/fresh/index.js
+/*!
+* fresh
+* Copyright(c) 2012 TJ Holowaychuk
+* Copyright(c) 2016-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_fresh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* RegExp to check for no-cache token in Cache-Control.
+	* @private
+	*/
+	var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = fresh;
+	/**
+	* Check freshness of the response using request and response headers.
+	*
+	* @param {Object} reqHeaders
+	* @param {Object} resHeaders
+	* @return {Boolean}
+	* @public
+	*/
+	function fresh(reqHeaders, resHeaders) {
+		var modifiedSince = reqHeaders["if-modified-since"];
+		var noneMatch = reqHeaders["if-none-match"];
+		if (!modifiedSince && !noneMatch) return false;
+		var cacheControl = reqHeaders["cache-control"];
+		if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) return false;
+		if (noneMatch) {
+			if (noneMatch === "*") return true;
+			var etag = resHeaders.etag;
+			if (!etag) return false;
+			var matches = parseTokenList(noneMatch);
+			for (var i = 0; i < matches.length; i++) {
+				var match = matches[i];
+				if (match === etag || match === "W/" + etag || "W/" + match === etag) return true;
+			}
+			return false;
+		}
+		if (modifiedSince) {
+			var lastModified = resHeaders["last-modified"];
+			if (!lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince))) return false;
+		}
+		return true;
+	}
+	/**
+	* Parse an HTTP Date into a number.
+	*
+	* @param {string} date
+	* @private
+	*/
+	function parseHttpDate(date) {
+		var timestamp = date && Date.parse(date);
+		// istanbul ignore next: guard against date.js Date.parse patching
+		return typeof timestamp === "number" ? timestamp : NaN;
+	}
+	/**
+	* Parse a HTTP token list.
+	*
+	* @param {string} str
+	* @private
+	*/
+	function parseTokenList(str) {
+		var end = 0;
+		var list = [];
+		var start = 0;
+		for (var i = 0, len = str.length; i < len; i++) switch (str.charCodeAt(i)) {
+			case 32:
+				if (start === end) start = end = i + 1;
+				break;
+			case 44:
+				list.push(str.substring(start, end));
+				start = end = i + 1;
+				break;
+			default: end = i + 1;
+		}
+		list.push(str.substring(start, end));
+		return list;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/mime-types@3.0.2/node_modules/mime-types/mimeScore.js
+var require_mimeScore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var FACET_SCORES = {
+		"prs.": 100,
+		"x-": 200,
+		"x.": 300,
+		"vnd.": 400,
+		default: 900
+	};
+	var SOURCE_SCORES = {
+		nginx: 10,
+		apache: 20,
+		iana: 40,
+		default: 30
+	};
+	var TYPE_SCORES = {
+		application: 1,
+		font: 2,
+		audio: 2,
+		video: 3,
+		default: 0
+	};
+	/**
+	* Get each component of the score for a mime type.  The sum of these is the
+	* total score.  The higher the score, the more "official" the type.
+	*/
+	module.exports = function mimeScore(mimeType, source = "default") {
+		if (mimeType === "application/octet-stream") return 0;
+		const [type, subtype] = mimeType.split("/");
+		const facetScore = FACET_SCORES[subtype.replace(/(\.|x-).*/, "$1")] || FACET_SCORES.default;
+		const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;
+		const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;
+		const lengthScore = 1 - mimeType.length / 100;
+		return facetScore + sourceScore + typeScore + lengthScore;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/mime-types@3.0.2/node_modules/mime-types/index.js
+/*!
+* mime-types
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_mime_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var db = require_mime_db();
+	var extname = __require("path").extname;
+	var mimeScore = require_mimeScore();
+	/**
+	* Module variables.
+	* @private
+	*/
+	var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+	var TEXT_TYPE_REGEXP = /^text\//i;
+	/**
+	* Module exports.
+	* @public
+	*/
+	exports.charset = charset;
+	exports.charsets = { lookup: charset };
+	exports.contentType = contentType;
+	exports.extension = extension;
+	exports.extensions = Object.create(null);
+	exports.lookup = lookup;
+	exports.types = Object.create(null);
+	exports._extensionConflicts = [];
+	populateMaps(exports.extensions, exports.types);
+	/**
+	* Get the default charset for a MIME type.
+	*
+	* @param {string} type
+	* @return {false|string}
+	*/
+	function charset(type) {
+		if (!type || typeof type !== "string") return false;
+		var match = EXTRACT_TYPE_REGEXP.exec(type);
+		var mime = match && db[match[1].toLowerCase()];
+		if (mime && mime.charset) return mime.charset;
+		if (match && TEXT_TYPE_REGEXP.test(match[1])) return "UTF-8";
+		return false;
+	}
+	/**
+	* Create a full Content-Type header given a MIME type or extension.
+	*
+	* @param {string} str
+	* @return {false|string}
+	*/
+	function contentType(str) {
+		if (!str || typeof str !== "string") return false;
+		var mime = str.indexOf("/") === -1 ? exports.lookup(str) : str;
+		if (!mime) return false;
+		if (mime.indexOf("charset") === -1) {
+			var charset = exports.charset(mime);
+			if (charset) mime += "; charset=" + charset.toLowerCase();
+		}
+		return mime;
+	}
+	/**
+	* Get the default extension for a MIME type.
+	*
+	* @param {string} type
+	* @return {false|string}
+	*/
+	function extension(type) {
+		if (!type || typeof type !== "string") return false;
+		var match = EXTRACT_TYPE_REGEXP.exec(type);
+		var exts = match && exports.extensions[match[1].toLowerCase()];
+		if (!exts || !exts.length) return false;
+		return exts[0];
+	}
+	/**
+	* Lookup the MIME type for a file path/extension.
+	*
+	* @param {string} path
+	* @return {false|string}
+	*/
+	function lookup(path) {
+		if (!path || typeof path !== "string") return false;
+		var extension = extname("x." + path).toLowerCase().slice(1);
+		if (!extension) return false;
+		return exports.types[extension] || false;
+	}
+	/**
+	* Populate the extensions and types maps.
+	* @private
+	*/
+	function populateMaps(extensions, types) {
+		Object.keys(db).forEach(function forEachMimeType(type) {
+			var exts = db[type].extensions;
+			if (!exts || !exts.length) return;
+			extensions[type] = exts;
+			for (var i = 0; i < exts.length; i++) {
+				var extension = exts[i];
+				types[extension] = _preferredType(extension, types[extension], type);
+				const legacyType = _preferredTypeLegacy(extension, types[extension], type);
+				if (legacyType !== types[extension]) exports._extensionConflicts.push([
+					extension,
+					legacyType,
+					types[extension]
+				]);
+			}
+		});
+	}
+	function _preferredType(ext, type0, type1) {
+		return (type0 ? mimeScore(type0, db[type0].source) : 0) > (type1 ? mimeScore(type1, db[type1].source) : 0) ? type0 : type1;
+	}
+	function _preferredTypeLegacy(ext, type0, type1) {
+		var SOURCE_RANK = [
+			"nginx",
+			"apache",
+			void 0,
+			"iana"
+		];
+		var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0;
+		var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0;
+		if (exports.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports.types[extension]?.slice(0, 12) === "application/")) return type0;
+		return score0 > score1 ? type0 : type1;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js
+/*!
+* ee-first
+* Copyright(c) 2014 Jonathan Ong
+* MIT Licensed
+*/
+var require_ee_first = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = first;
+	/**
+	* Get the first event in a set of event emitters and event pairs.
+	*
+	* @param {array} stuff
+	* @param {function} done
+	* @public
+	*/
+	function first(stuff, done) {
+		if (!Array.isArray(stuff)) throw new TypeError("arg must be an array of [ee, events...] arrays");
+		var cleanups = [];
+		for (var i = 0; i < stuff.length; i++) {
+			var arr = stuff[i];
+			if (!Array.isArray(arr) || arr.length < 2) throw new TypeError("each array member must be [ee, events...]");
+			var ee = arr[0];
+			for (var j = 1; j < arr.length; j++) {
+				var event = arr[j];
+				var fn = listener(event, callback);
+				ee.on(event, fn);
+				cleanups.push({
+					ee,
+					event,
+					fn
+				});
+			}
+		}
+		function callback() {
+			cleanup();
+			done.apply(null, arguments);
+		}
+		function cleanup() {
+			var x;
+			for (var i = 0; i < cleanups.length; i++) {
+				x = cleanups[i];
+				x.ee.removeListener(x.event, x.fn);
+			}
+		}
+		function thunk(fn) {
+			done = fn;
+		}
+		thunk.cancel = cleanup;
+		return thunk;
+	}
+	/**
+	* Create the event listener.
+	* @private
+	*/
+	function listener(event, done) {
+		return function onevent(arg1) {
+			var args = new Array(arguments.length);
+			var ee = this;
+			var err = event === "error" ? arg1 : null;
+			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+			done(err, ee, event, args);
+		};
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/on-finished@2.4.1/node_modules/on-finished/index.js
+/*!
+* on-finished
+* Copyright(c) 2013 Jonathan Ong
+* Copyright(c) 2014 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_on_finished = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = onFinished;
+	module.exports.isFinished = isFinished;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var asyncHooks = tryRequireAsyncHooks();
+	var first = require_ee_first();
+	/**
+	* Variables.
+	* @private
+	*/
+	/* istanbul ignore next */
+	var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
+		process.nextTick(fn.bind.apply(fn, arguments));
+	};
+	/**
+	* Invoke callback when the response has finished, useful for
+	* cleaning up resources afterwards.
+	*
+	* @param {object} msg
+	* @param {function} listener
+	* @return {object}
+	* @public
+	*/
+	function onFinished(msg, listener) {
+		if (isFinished(msg) !== false) {
+			defer(listener, null, msg);
+			return msg;
+		}
+		attachListener(msg, wrap(listener));
+		return msg;
+	}
+	/**
+	* Determine if message is already finished.
+	*
+	* @param {object} msg
+	* @return {boolean}
+	* @public
+	*/
+	function isFinished(msg) {
+		var socket = msg.socket;
+		if (typeof msg.finished === "boolean") return Boolean(msg.finished || socket && !socket.writable);
+		if (typeof msg.complete === "boolean") return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
+	}
+	/**
+	* Attach a finished listener to the message.
+	*
+	* @param {object} msg
+	* @param {function} callback
+	* @private
+	*/
+	function attachFinishedListener(msg, callback) {
+		var eeMsg;
+		var eeSocket;
+		var finished = false;
+		function onFinish(error) {
+			eeMsg.cancel();
+			eeSocket.cancel();
+			finished = true;
+			callback(error);
+		}
+		eeMsg = eeSocket = first([[
+			msg,
+			"end",
+			"finish"
+		]], onFinish);
+		function onSocket(socket) {
+			msg.removeListener("socket", onSocket);
+			if (finished) return;
+			if (eeMsg !== eeSocket) return;
+			eeSocket = first([[
+				socket,
+				"error",
+				"close"
+			]], onFinish);
+		}
+		if (msg.socket) {
+			onSocket(msg.socket);
+			return;
+		}
+		msg.on("socket", onSocket);
+		if (msg.socket === void 0)
+ // istanbul ignore next: node.js 0.8 patch
+		patchAssignSocket(msg, onSocket);
+	}
+	/**
+	* Attach the listener to the message.
+	*
+	* @param {object} msg
+	* @return {function}
+	* @private
+	*/
+	function attachListener(msg, listener) {
+		var attached = msg.__onFinished;
+		if (!attached || !attached.queue) {
+			attached = msg.__onFinished = createListener(msg);
+			attachFinishedListener(msg, attached);
+		}
+		attached.queue.push(listener);
+	}
+	/**
+	* Create listener on message.
+	*
+	* @param {object} msg
+	* @return {function}
+	* @private
+	*/
+	function createListener(msg) {
+		function listener(err) {
+			if (msg.__onFinished === listener) msg.__onFinished = null;
+			if (!listener.queue) return;
+			var queue = listener.queue;
+			listener.queue = null;
+			for (var i = 0; i < queue.length; i++) queue[i](err, msg);
+		}
+		listener.queue = [];
+		return listener;
+	}
+	/**
+	* Patch ServerResponse.prototype.assignSocket for node.js 0.8.
+	*
+	* @param {ServerResponse} res
+	* @param {function} callback
+	* @private
+	*/
+	// istanbul ignore next: node.js 0.8 patch
+	function patchAssignSocket(res, callback) {
+		var assignSocket = res.assignSocket;
+		if (typeof assignSocket !== "function") return;
+		res.assignSocket = function _assignSocket(socket) {
+			assignSocket.call(this, socket);
+			callback(socket);
+		};
+	}
+	/**
+	* Try to require async_hooks
+	* @private
+	*/
+	function tryRequireAsyncHooks() {
+		try {
+			return __require("async_hooks");
+		} catch (e) {
+			return {};
+		}
+	}
+	/**
+	* Wrap function with async resource, if possible.
+	* AsyncResource.bind static method backported.
+	* @private
+	*/
+	function wrap(fn) {
+		var res;
+		if (asyncHooks.AsyncResource) res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
+		if (!res || !res.runInAsyncScope) return fn;
+		return res.runInAsyncScope.bind(res, fn, null);
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/range-parser@1.3.0/node_modules/range-parser/index.js
+/*!
+* range-parser
+* Copyright(c) 2012-2014 TJ Holowaychuk
+* Copyright(c) 2015-2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_range_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = rangeParser;
+	/**
+	* Parse "Range" header `str` relative to the given file `size`.
+	*
+	* @param {Number} size
+	* @param {String} str
+	* @param {Object} [options]
+	* @return {Array}
+	* @public
+	*/
+	function rangeParser(size, str, options) {
+		if (typeof str !== "string") throw new TypeError("argument str must be a string");
+		var index = str.indexOf("=");
+		if (index === -1) return -2;
+		var arr = str.slice(index + 1).split(",");
+		var ranges = [];
+		ranges.type = str.slice(0, index);
+		for (var i = 0; i < arr.length; i++) {
+			var indexOf = arr[i].indexOf("-");
+			if (indexOf === -1) return -2;
+			var startStr = arr[i].slice(0, indexOf).trim();
+			var endStr = arr[i].slice(indexOf + 1).trim();
+			var start = parsePos(startStr);
+			var end = parsePos(endStr);
+			if (startStr.length === 0) {
+				start = size - end;
+				end = size - 1;
+			} else if (endStr.length === 0) end = size - 1;
+			if (end > size - 1) end = size - 1;
+			if (isNaN(start) || isNaN(end)) return -2;
+			if (start > end || start < 0) continue;
+			ranges.push({
+				start,
+				end
+			});
+		}
+		if (ranges.length < 1) return -1;
+		return options && options.combine ? combineRanges(ranges) : ranges;
+	}
+	/**
+	* Parse string to integer.
+	* @private
+	*/
+	function parsePos(str) {
+		if (/^\d+$/.test(str)) return Number(str);
+		return NaN;
+	}
+	/**
+	* Combine overlapping & adjacent ranges.
+	* @private
+	*/
+	function combineRanges(ranges) {
+		var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
+		for (var j = 0, i = 1; i < ordered.length; i++) {
+			var range = ordered[i];
+			var current = ordered[j];
+			if (range.start > current.end + 1) ordered[++j] = range;
+			else if (range.end > current.end) {
+				current.end = range.end;
+				current.index = Math.min(current.index, range.index);
+			}
+		}
+		ordered.length = j + 1;
+		var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
+		combined.type = ranges.type;
+		return combined;
+	}
+	/**
+	* Map function to add index value to ranges.
+	* @private
+	*/
+	function mapWithIndex(range, index) {
+		return {
+			start: range.start,
+			end: range.end,
+			index
+		};
+	}
+	/**
+	* Map function to remove index value from ranges.
+	* @private
+	*/
+	function mapWithoutIndex(range) {
+		return {
+			start: range.start,
+			end: range.end
+		};
+	}
+	/**
+	* Sort function to sort ranges by index.
+	* @private
+	*/
+	function sortByRangeIndex(a, b) {
+		return a.index - b.index;
+	}
+	/**
+	* Sort function to sort ranges by start position.
+	* @private
+	*/
+	function sortByRangeStart(a, b) {
+		return a.start - b.start;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/send@1.2.1_supports-color@10.2.2/node_modules/send/index.js
+/*!
+* send
+* Copyright(c) 2012 TJ Holowaychuk
+* Copyright(c) 2014-2022 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_send = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var createError = require_http_errors();
+	var debug = require_src()("send");
+	var encodeUrl = require_encodeurl();
+	var escapeHtml = require_escape_html();
+	var etag = require_etag();
+	var fresh = require_fresh();
+	var fs = __require("fs");
+	var mime = require_mime_types();
+	var ms = require_ms();
+	var onFinished = require_on_finished();
+	var parseRange = require_range_parser();
+	var path = __require("path");
+	var statuses = require_statuses();
+	var Stream = __require("stream");
+	var util = __require("util");
+	/**
+	* Path function references.
+	* @private
+	*/
+	var extname = path.extname;
+	var join = path.join;
+	var normalize = path.normalize;
+	var resolve = path.resolve;
+	var sep = path.sep;
+	/**
+	* Regular expression for identifying a bytes Range header.
+	* @private
+	*/
+	var BYTES_RANGE_REGEXP = /^ *bytes=/;
+	/**
+	* Maximum value allowed for the max age.
+	* @private
+	*/
+	var MAX_MAXAGE = 31536e6;
+	/**
+	* Regular expression to match a path with a directory up component.
+	* @private
+	*/
+	var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = send;
+	/**
+	* Return a `SendStream` for `req` and `path`.
+	*
+	* @param {object} req
+	* @param {string} path
+	* @param {object} [options]
+	* @return {SendStream}
+	* @public
+	*/
+	function send(req, path, options) {
+		return new SendStream(req, path, options);
+	}
+	/**
+	* Initialize a `SendStream` with the given `path`.
+	*
+	* @param {Request} req
+	* @param {String} path
+	* @param {object} [options]
+	* @private
+	*/
+	function SendStream(req, path, options) {
+		Stream.call(this);
+		var opts = options || {};
+		this.options = opts;
+		this.path = path;
+		this.req = req;
+		this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;
+		this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;
+		this._etag = opts.etag !== void 0 ? Boolean(opts.etag) : true;
+		this._dotfiles = opts.dotfiles !== void 0 ? opts.dotfiles : "ignore";
+		if (this._dotfiles !== "ignore" && this._dotfiles !== "allow" && this._dotfiles !== "deny") throw new TypeError("dotfiles option must be \"allow\", \"deny\", or \"ignore\"");
+		this._extensions = opts.extensions !== void 0 ? normalizeList(opts.extensions, "extensions option") : [];
+		this._immutable = opts.immutable !== void 0 ? Boolean(opts.immutable) : false;
+		this._index = opts.index !== void 0 ? normalizeList(opts.index, "index option") : ["index.html"];
+		this._lastModified = opts.lastModified !== void 0 ? Boolean(opts.lastModified) : true;
+		this._maxage = opts.maxAge || opts.maxage;
+		this._maxage = typeof this._maxage === "string" ? ms(this._maxage) : Number(this._maxage);
+		this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
+		this._root = opts.root ? resolve(opts.root) : null;
+	}
+	/**
+	* Inherits from `Stream`.
+	*/
+	util.inherits(SendStream, Stream);
+	/**
+	* Emit error with `status`.
+	*
+	* @param {number} status
+	* @param {Error} [err]
+	* @private
+	*/
+	SendStream.prototype.error = function error(status, err) {
+		if (hasListeners(this, "error")) return this.emit("error", createHttpError(status, err));
+		var res = this.res;
+		var doc = createHtmlDocument("Error", escapeHtml(statuses.message[status] || String(status)));
+		clearHeaders(res);
+		if (err && err.headers) setHeaders(res, err.headers);
+		res.statusCode = status;
+		res.setHeader("Content-Type", "text/html; charset=UTF-8");
+		res.setHeader("Content-Length", Buffer.byteLength(doc));
+		res.setHeader("Content-Security-Policy", "default-src 'none'");
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		res.end(doc);
+	};
+	/**
+	* Check if the pathname ends with "/".
+	*
+	* @return {boolean}
+	* @private
+	*/
+	SendStream.prototype.hasTrailingSlash = function hasTrailingSlash() {
+		return this.path[this.path.length - 1] === "/";
+	};
+	/**
+	* Check if this is a conditional GET request.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isConditionalGET = function isConditionalGET() {
+		return this.req.headers["if-match"] || this.req.headers["if-unmodified-since"] || this.req.headers["if-none-match"] || this.req.headers["if-modified-since"];
+	};
+	/**
+	* Check if the request preconditions failed.
+	*
+	* @return {boolean}
+	* @private
+	*/
+	SendStream.prototype.isPreconditionFailure = function isPreconditionFailure() {
+		var req = this.req;
+		var res = this.res;
+		var match = req.headers["if-match"];
+		if (match) {
+			var etag = res.getHeader("ETag");
+			return !etag || match !== "*" && parseTokenList(match).every(function(match) {
+				return match !== etag && match !== "W/" + etag && "W/" + match !== etag;
+			});
+		}
+		var unmodifiedSince = parseHttpDate(req.headers["if-unmodified-since"]);
+		if (!isNaN(unmodifiedSince)) {
+			var lastModified = parseHttpDate(res.getHeader("Last-Modified"));
+			return isNaN(lastModified) || lastModified > unmodifiedSince;
+		}
+		return false;
+	};
+	/**
+	* Strip various content header fields for a change in entity.
+	*
+	* @private
+	*/
+	SendStream.prototype.removeContentHeaderFields = function removeContentHeaderFields() {
+		var res = this.res;
+		res.removeHeader("Content-Encoding");
+		res.removeHeader("Content-Language");
+		res.removeHeader("Content-Length");
+		res.removeHeader("Content-Range");
+		res.removeHeader("Content-Type");
+	};
+	/**
+	* Respond with 304 not modified.
+	*
+	* @api private
+	*/
+	SendStream.prototype.notModified = function notModified() {
+		var res = this.res;
+		debug("not modified");
+		this.removeContentHeaderFields();
+		res.statusCode = 304;
+		res.end();
+	};
+	/**
+	* Raise error that headers already sent.
+	*
+	* @api private
+	*/
+	SendStream.prototype.headersAlreadySent = function headersAlreadySent() {
+		var err = /* @__PURE__ */ new Error("Can't set headers after they are sent.");
+		debug("headers already sent");
+		this.error(500, err);
+	};
+	/**
+	* Check if the request is cacheable, aka
+	* responded with 2xx or 304 (see RFC 2616 section 14.2{5,6}).
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isCachable = function isCachable() {
+		var statusCode = this.res.statusCode;
+		return statusCode >= 200 && statusCode < 300 || statusCode === 304;
+	};
+	/**
+	* Handle stat() error.
+	*
+	* @param {Error} error
+	* @private
+	*/
+	SendStream.prototype.onStatError = function onStatError(error) {
+		switch (error.code) {
+			case "ENAMETOOLONG":
+			case "ENOENT":
+			case "ENOTDIR":
+				this.error(404, error);
+				break;
+			default: this.error(500, error);
+		}
+	};
+	/**
+	* Check if the cache is fresh.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isFresh = function isFresh() {
+		return fresh(this.req.headers, {
+			etag: this.res.getHeader("ETag"),
+			"last-modified": this.res.getHeader("Last-Modified")
+		});
+	};
+	/**
+	* Check if the range is fresh.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isRangeFresh = function isRangeFresh() {
+		var ifRange = this.req.headers["if-range"];
+		if (!ifRange) return true;
+		if (ifRange.indexOf("\"") !== -1) {
+			var etag = this.res.getHeader("ETag");
+			return Boolean(etag && ifRange.indexOf(etag) !== -1);
+		}
+		return parseHttpDate(this.res.getHeader("Last-Modified")) <= parseHttpDate(ifRange);
+	};
+	/**
+	* Redirect to path.
+	*
+	* @param {string} path
+	* @private
+	*/
+	SendStream.prototype.redirect = function redirect(path) {
+		var res = this.res;
+		if (hasListeners(this, "directory")) {
+			this.emit("directory", res, path);
+			return;
+		}
+		if (this.hasTrailingSlash()) {
+			this.error(403);
+			return;
+		}
+		var loc = encodeUrl(collapseLeadingSlashes(this.path + "/"));
+		var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc));
+		res.statusCode = 301;
+		res.setHeader("Content-Type", "text/html; charset=UTF-8");
+		res.setHeader("Content-Length", Buffer.byteLength(doc));
+		res.setHeader("Content-Security-Policy", "default-src 'none'");
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		res.setHeader("Location", loc);
+		res.end(doc);
+	};
+	/**
+	* Pipe to `res.
+	*
+	* @param {Stream} res
+	* @return {Stream} res
+	* @api public
+	*/
+	SendStream.prototype.pipe = function pipe(res) {
+		var root = this._root;
+		this.res = res;
+		var path = decode(this.path);
+		if (path === -1) {
+			this.error(400);
+			return res;
+		}
+		if (~path.indexOf("\0")) {
+			this.error(400);
+			return res;
+		}
+		var parts;
+		if (root !== null) {
+			if (path) path = normalize("." + sep + path);
+			if (UP_PATH_REGEXP.test(path)) {
+				debug("malicious path \"%s\"", path);
+				this.error(403);
+				return res;
+			}
+			parts = path.split(sep);
+			path = normalize(join(root, path));
+		} else {
+			if (UP_PATH_REGEXP.test(path)) {
+				debug("malicious path \"%s\"", path);
+				this.error(403);
+				return res;
+			}
+			parts = normalize(path).split(sep);
+			path = resolve(path);
+		}
+		if (containsDotFile(parts)) {
+			debug("%s dotfile \"%s\"", this._dotfiles, path);
+			switch (this._dotfiles) {
+				case "allow": break;
+				case "deny":
+					this.error(403);
+					return res;
+				default:
+					this.error(404);
+					return res;
+			}
+		}
+		if (this._index.length && this.hasTrailingSlash()) {
+			this.sendIndex(path);
+			return res;
+		}
+		this.sendFile(path);
+		return res;
+	};
+	/**
+	* Transfer `path`.
+	*
+	* @param {String} path
+	* @api public
+	*/
+	SendStream.prototype.send = function send(path, stat) {
+		var len = stat.size;
+		var options = this.options;
+		var opts = {};
+		var res = this.res;
+		var req = this.req;
+		var ranges = req.headers.range;
+		var offset = options.start || 0;
+		if (res.headersSent) {
+			this.headersAlreadySent();
+			return;
+		}
+		debug("pipe \"%s\"", path);
+		this.setHeader(path, stat);
+		this.type(path);
+		if (this.isConditionalGET()) {
+			if (this.isPreconditionFailure()) {
+				this.error(412);
+				return;
+			}
+			if (this.isCachable() && this.isFresh()) {
+				this.notModified();
+				return;
+			}
+		}
+		len = Math.max(0, len - offset);
+		if (options.end !== void 0) {
+			var bytes = options.end - offset + 1;
+			if (len > bytes) len = bytes;
+		}
+		if (this._acceptRanges && BYTES_RANGE_REGEXP.test(ranges)) {
+			ranges = parseRange(len, ranges, { combine: true });
+			if (!this.isRangeFresh()) {
+				debug("range stale");
+				ranges = -2;
+			}
+			if (ranges === -1) {
+				debug("range unsatisfiable");
+				res.setHeader("Content-Range", contentRange("bytes", len));
+				return this.error(416, { headers: { "Content-Range": res.getHeader("Content-Range") } });
+			}
+			if (ranges !== -2 && ranges.length === 1) {
+				debug("range %j", ranges);
+				res.statusCode = 206;
+				res.setHeader("Content-Range", contentRange("bytes", len, ranges[0]));
+				offset += ranges[0].start;
+				len = ranges[0].end - ranges[0].start + 1;
+			}
+		}
+		for (var prop in options) opts[prop] = options[prop];
+		opts.start = offset;
+		opts.end = Math.max(offset, offset + len - 1);
+		res.setHeader("Content-Length", len);
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		this.stream(path, opts);
+	};
+	/**
+	* Transfer file for `path`.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.sendFile = function sendFile(path) {
+		var i = 0;
+		var self = this;
+		debug("stat \"%s\"", path);
+		fs.stat(path, function onstat(err, stat) {
+			var pathEndsWithSep = path[path.length - 1] === sep;
+			if (err && err.code === "ENOENT" && !extname(path) && !pathEndsWithSep) return next(err);
+			if (err) return self.onStatError(err);
+			if (stat.isDirectory()) return self.redirect(path);
+			if (pathEndsWithSep) return self.error(404);
+			self.emit("file", path, stat);
+			self.send(path, stat);
+		});
+		function next(err) {
+			if (self._extensions.length <= i) return err ? self.onStatError(err) : self.error(404);
+			var p = path + "." + self._extensions[i++];
+			debug("stat \"%s\"", p);
+			fs.stat(p, function(err, stat) {
+				if (err) return next(err);
+				if (stat.isDirectory()) return next();
+				self.emit("file", p, stat);
+				self.send(p, stat);
+			});
+		}
+	};
+	/**
+	* Transfer index for `path`.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.sendIndex = function sendIndex(path) {
+		var i = -1;
+		var self = this;
+		function next(err) {
+			if (++i >= self._index.length) {
+				if (err) return self.onStatError(err);
+				return self.error(404);
+			}
+			var p = join(path, self._index[i]);
+			debug("stat \"%s\"", p);
+			fs.stat(p, function(err, stat) {
+				if (err) return next(err);
+				if (stat.isDirectory()) return next();
+				self.emit("file", p, stat);
+				self.send(p, stat);
+			});
+		}
+		next();
+	};
+	/**
+	* Stream `path` to the response.
+	*
+	* @param {String} path
+	* @param {Object} options
+	* @api private
+	*/
+	SendStream.prototype.stream = function stream(path, options) {
+		var self = this;
+		var res = this.res;
+		var stream = fs.createReadStream(path, options);
+		this.emit("stream", stream);
+		stream.pipe(res);
+		function cleanup() {
+			stream.destroy();
+		}
+		onFinished(res, cleanup);
+		stream.on("error", function onerror(err) {
+			cleanup();
+			self.onStatError(err);
+		});
+		stream.on("end", function onend() {
+			self.emit("end");
+		});
+	};
+	/**
+	* Set content-type based on `path`
+	* if it hasn't been explicitly set.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.type = function type(path) {
+		var res = this.res;
+		if (res.getHeader("Content-Type")) return;
+		var ext = extname(path);
+		var type = mime.contentType(ext) || "application/octet-stream";
+		debug("content-type %s", type);
+		res.setHeader("Content-Type", type);
+	};
+	/**
+	* Set response header fields, most
+	* fields may be pre-defined.
+	*
+	* @param {String} path
+	* @param {Object} stat
+	* @api private
+	*/
+	SendStream.prototype.setHeader = function setHeader(path, stat) {
+		var res = this.res;
+		this.emit("headers", res, path, stat);
+		if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
+			debug("accept ranges");
+			res.setHeader("Accept-Ranges", "bytes");
+		}
+		if (this._cacheControl && !res.getHeader("Cache-Control")) {
+			var cacheControl = "public, max-age=" + Math.floor(this._maxage / 1e3);
+			if (this._immutable) cacheControl += ", immutable";
+			debug("cache-control %s", cacheControl);
+			res.setHeader("Cache-Control", cacheControl);
+		}
+		if (this._lastModified && !res.getHeader("Last-Modified")) {
+			var modified = stat.mtime.toUTCString();
+			debug("modified %s", modified);
+			res.setHeader("Last-Modified", modified);
+		}
+		if (this._etag && !res.getHeader("ETag")) {
+			var val = etag(stat);
+			debug("etag %s", val);
+			res.setHeader("ETag", val);
+		}
+	};
+	/**
+	* Clear all headers from a response.
+	*
+	* @param {object} res
+	* @private
+	*/
+	function clearHeaders(res) {
+		for (const header of res.getHeaderNames()) res.removeHeader(header);
+	}
+	/**
+	* Collapse all leading slashes into a single slash
+	*
+	* @param {string} str
+	* @private
+	*/
+	function collapseLeadingSlashes(str) {
+		for (var i = 0; i < str.length; i++) if (str[i] !== "/") break;
+		return i > 1 ? "/" + str.substr(i) : str;
+	}
+	/**
+	* Determine if path parts contain a dotfile.
+	*
+	* @api private
+	*/
+	function containsDotFile(parts) {
+		for (var i = 0; i < parts.length; i++) {
+			var part = parts[i];
+			if (part.length > 1 && part[0] === ".") return true;
+		}
+		return false;
+	}
+	/**
+	* Create a Content-Range header.
+	*
+	* @param {string} type
+	* @param {number} size
+	* @param {array} [range]
+	*/
+	function contentRange(type, size, range) {
+		return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size;
+	}
+	/**
+	* Create a minimal HTML document.
+	*
+	* @param {string} title
+	* @param {string} body
+	* @private
+	*/
+	function createHtmlDocument(title, body) {
+		return "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>" + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
+	}
+	/**
+	* Create a HttpError object from simple arguments.
+	*
+	* @param {number} status
+	* @param {Error|object} err
+	* @private
+	*/
+	function createHttpError(status, err) {
+		if (!err) return createError(status);
+		return err instanceof Error ? createError(status, err, { expose: false }) : createError(status, err);
+	}
+	/**
+	* decodeURIComponent.
+	*
+	* Allows V8 to only deoptimize this fn instead of all
+	* of send().
+	*
+	* @param {String} path
+	* @api private
+	*/
+	function decode(path) {
+		try {
+			return decodeURIComponent(path);
+		} catch (err) {
+			return -1;
+		}
+	}
+	/**
+	* Determine if emitter has listeners of a given type.
+	*
+	* The way to do this check is done three different ways in Node.js >= 0.10
+	* so this consolidates them into a minimal set using instance methods.
+	*
+	* @param {EventEmitter} emitter
+	* @param {string} type
+	* @returns {boolean}
+	* @private
+	*/
+	function hasListeners(emitter, type) {
+		return (typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type)) > 0;
+	}
+	/**
+	* Normalize the index option into an array.
+	*
+	* @param {boolean|string|array} val
+	* @param {string} name
+	* @private
+	*/
+	function normalizeList(val, name) {
+		var list = [].concat(val || []);
+		for (var i = 0; i < list.length; i++) if (typeof list[i] !== "string") throw new TypeError(name + " must be array of strings or false");
+		return list;
+	}
+	/**
+	* Parse an HTTP Date into a number.
+	*
+	* @param {string} date
+	* @private
+	*/
+	function parseHttpDate(date) {
+		var timestamp = date && Date.parse(date);
+		return typeof timestamp === "number" ? timestamp : NaN;
+	}
+	/**
+	* Parse a HTTP token list.
+	*
+	* @param {string} str
+	* @private
+	*/
+	function parseTokenList(str) {
+		var end = 0;
+		var list = [];
+		var start = 0;
+		for (var i = 0, len = str.length; i < len; i++) switch (str.charCodeAt(i)) {
+			case 32:
+				if (start === end) start = end = i + 1;
+				break;
+			case 44:
+				if (start !== end) list.push(str.substring(start, end));
+				start = end = i + 1;
+				break;
+			default: end = i + 1;
+		}
+		if (start !== end) list.push(str.substring(start, end));
+		return list;
+	}
+	/**
+	* Set an object of headers on a response.
+	*
+	* @param {object} res
+	* @param {object} headers
+	* @private
+	*/
+	function setHeaders(res, headers) {
+		var keys = Object.keys(headers);
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			res.setHeader(key, headers[key]);
+		}
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/serve-static@2.2.1_supports-color@10.2.2/node_modules/serve-static/index.js
+/*!
+* serve-static
+* Copyright(c) 2010 Sencha Inc.
+* Copyright(c) 2011 TJ Holowaychuk
+* Copyright(c) 2014-2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_serve_static = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var encodeUrl = require_encodeurl();
+	var escapeHtml = require_escape_html();
+	var parseUrl = require_parseurl();
+	var resolve = __require("path").resolve;
+	var send = require_send();
+	var url = __require("url");
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = serveStatic;
+	/**
+	* @param {string} root
+	* @param {object} [options]
+	* @return {function}
+	* @public
+	*/
+	function serveStatic(root, options) {
+		if (!root) throw new TypeError("root path required");
+		if (typeof root !== "string") throw new TypeError("root path must be a string");
+		var opts = Object.create(options || null);
+		var fallthrough = opts.fallthrough !== false;
+		var redirect = opts.redirect !== false;
+		var setHeaders = opts.setHeaders;
+		if (setHeaders && typeof setHeaders !== "function") throw new TypeError("option setHeaders must be function");
+		opts.maxage = opts.maxage || opts.maxAge || 0;
+		opts.root = resolve(root);
+		var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
+		return function serveStatic(req, res, next) {
+			if (req.method !== "GET" && req.method !== "HEAD") {
+				if (fallthrough) return next();
+				res.statusCode = 405;
+				res.setHeader("Allow", "GET, HEAD");
+				res.setHeader("Content-Length", "0");
+				res.end();
+				return;
+			}
+			var forwardError = !fallthrough;
+			var originalUrl = parseUrl.original(req);
+			var path = parseUrl(req).pathname;
+			if (path === "/" && originalUrl.pathname.substr(-1) !== "/") path = "";
+			var stream = send(req, path, opts);
+			stream.on("directory", onDirectory);
+			if (setHeaders) stream.on("headers", setHeaders);
+			if (fallthrough) stream.on("file", function onFile() {
+				forwardError = true;
+			});
+			stream.on("error", function error(err) {
+				if (forwardError || !(err.statusCode < 500)) {
+					next(err);
+					return;
+				}
+				next();
+			});
+			stream.pipe(res);
+		};
+	}
+	/**
+	* Collapse all leading slashes into a single slash
+	* @private
+	*/
+	function collapseLeadingSlashes(str) {
+		for (var i = 0; i < str.length; i++) if (str.charCodeAt(i) !== 47) break;
+		return i > 1 ? "/" + str.substr(i) : str;
+	}
+	/**
+	* Create a minimal HTML document.
+	*
+	* @param {string} title
+	* @param {string} body
+	* @private
+	*/
+	function createHtmlDocument(title, body) {
+		return "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>" + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
+	}
+	/**
+	* Create a directory listener that just 404s.
+	* @private
+	*/
+	function createNotFoundDirectoryListener() {
+		return function notFound() {
+			this.error(404);
+		};
+	}
+	/**
+	* Create a directory listener that performs a redirect.
+	* @private
+	*/
+	function createRedirectDirectoryListener() {
+		return function redirect(res) {
+			if (this.hasTrailingSlash()) {
+				this.error(404);
+				return;
+			}
+			var originalUrl = parseUrl.original(this.req);
+			originalUrl.path = null;
+			originalUrl.pathname = collapseLeadingSlashes(originalUrl.pathname + "/");
+			var loc = encodeUrl(url.format(originalUrl));
+			var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc));
+			res.statusCode = 301;
+			res.setHeader("Content-Type", "text/html; charset=UTF-8");
+			res.setHeader("Content-Length", Buffer.byteLength(doc));
+			res.setHeader("Content-Security-Policy", "default-src 'none'");
+			res.setHeader("X-Content-Type-Options", "nosniff");
+			res.setHeader("Location", loc);
+			res.end(doc);
+		};
+	}
+}));
+//#endregion
+export default require_serve_static();
+export {};