@hot-updater/console 0.16.7-0 → 0.18.0

package/dist/index.cjs

@@ -1,2054 +1,2003 @@
-"use strict";
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
-var __webpack_modules__ = {
-    "../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.8.3/node_modules/typia/lib/internal/_validateReport.js": function(__unused_webpack_module, exports1) {
-        exports1._validateReport = void 0;
-        const _validateReport = (array)=>{
-            const reportable = (path)=>{
-                if (0 === array.length) return true;
-                const last = array[array.length - 1].path;
-                return path.length > last.length || last.substring(0, path.length) !== path;
-            };
-            return (exceptable, error)=>{
-                if (exceptable && reportable(error.path)) array.push(error);
-                return false;
-            };
-        };
-        exports1._validateReport = _validateReport;
-    }
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") 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),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const path = __toESM(require("path"));
+const url = __toESM(require("url"));
+const fs = __toESM(require("fs"));
+const __hot_updater_plugin_core = __toESM(require("@hot-updater/plugin-core"));
+
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/filepath.js
+var getFilePath = (options) => {
+	let filename = options.filename;
+	const defaultDocument = options.defaultDocument || "index.html";
+	if (filename.endsWith("/")) filename = filename.concat(defaultDocument);
+	else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) filename = filename.concat("/" + defaultDocument);
+	const path$2 = getFilePathWithoutDefaultDocument({
+		root: options.root,
+		filename
+	});
+	return path$2;
+};
+var getFilePathWithoutDefaultDocument = (options) => {
+	let root = options.root || "";
+	let filename = options.filename;
+	if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) return;
+	filename = filename.replace(/^\.?[\/\\]/, "");
+	filename = filename.replace(/\\/, "/");
+	root = root.replace(/\/$/, "");
+	let path$2 = root ? root + "/" + filename : filename;
+	path$2 = path$2.replace(/^\.?\//, "");
+	if (root[0] !== "/" && path$2[0] === "/") return;
+	return path$2;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/mime.js
+var getMimeType = (filename, mimes = baseMimes) => {
+	const regexp = /\.([a-zA-Z0-9]+?)$/;
+	const match = filename.match(regexp);
+	if (!match) return;
+	let mimeType = mimes[match[1]];
+	if (mimeType && mimeType.startsWith("text") || mimeType === "application/json") mimeType += "; charset=utf-8";
+	return mimeType;
+};
+var baseMimes = {
+	aac: "audio/aac",
+	avi: "video/x-msvideo",
+	avif: "image/avif",
+	av1: "video/av1",
+	bin: "application/octet-stream",
+	bmp: "image/bmp",
+	css: "text/css",
+	csv: "text/csv",
+	eot: "application/vnd.ms-fontobject",
+	epub: "application/epub+zip",
+	gif: "image/gif",
+	gz: "application/gzip",
+	htm: "text/html",
+	html: "text/html",
+	ico: "image/x-icon",
+	ics: "text/calendar",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	js: "text/javascript",
+	json: "application/json",
+	jsonld: "application/ld+json",
+	map: "application/json",
+	mid: "audio/x-midi",
+	midi: "audio/x-midi",
+	mjs: "text/javascript",
+	mp3: "audio/mpeg",
+	mp4: "video/mp4",
+	mpeg: "video/mpeg",
+	oga: "audio/ogg",
+	ogv: "video/ogg",
+	ogx: "application/ogg",
+	opus: "audio/opus",
+	otf: "font/otf",
+	pdf: "application/pdf",
+	png: "image/png",
+	rtf: "application/rtf",
+	svg: "image/svg+xml",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	ts: "video/mp2t",
+	ttf: "font/ttf",
+	txt: "text/plain",
+	wasm: "application/wasm",
+	webm: "video/webm",
+	weba: "audio/webm",
+	webp: "image/webp",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	xhtml: "application/xhtml+xml",
+	xml: "application/xml",
+	zip: "application/zip",
+	"3gp": "video/3gpp",
+	"3g2": "video/3gpp2",
+	gltf: "model/gltf+json",
+	glb: "model/gltf-binary"
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@hono+node-server@1.13.4_hono@4.6.3/node_modules/@hono/node-server/dist/serve-static.mjs
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+var ENCODINGS = {
+	br: ".br",
+	zstd: ".zst",
+	gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var createStreamBody = (stream) => {
+	const body = new ReadableStream({
+		start(controller) {
+			stream.on("data", (chunk) => {
+				controller.enqueue(chunk);
+			});
+			stream.on("end", () => {
+				controller.close();
+			});
+		},
+		cancel() {
+			stream.destroy();
+		}
+	});
+	return body;
+};
+var addCurrentDirPrefix = (path$2) => {
+	return `./${path$2}`;
+};
+var getStats = (path$2) => {
+	let stats;
+	try {
+		stats = (0, fs.lstatSync)(path$2);
+	} catch {}
+	return stats;
+};
+var serveStatic = (options = { root: "" }) => {
+	return async (c, next) => {
+		if (c.finalized) return next();
+		let filename;
+		try {
+			filename = options.path ?? decodeURIComponent(c.req.path);
+		} catch {
+			await options.onNotFound?.(c.req.path, c);
+			return next();
+		}
+		let path$2 = getFilePathWithoutDefaultDocument({
+			filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+			root: options.root
+		});
+		if (path$2) path$2 = addCurrentDirPrefix(path$2);
+		else return next();
+		let stats = getStats(path$2);
+		if (stats && stats.isDirectory()) {
+			path$2 = getFilePath({
+				filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+				root: options.root,
+				defaultDocument: options.index ?? "index.html"
+			});
+			if (path$2) path$2 = addCurrentDirPrefix(path$2);
+			else return next();
+			stats = getStats(path$2);
+		}
+		if (!stats) {
+			await options.onNotFound?.(path$2, c);
+			return next();
+		}
+		await options.onFound?.(path$2, c);
+		const mimeType = getMimeType(path$2);
+		c.header("Content-Type", mimeType || "application/octet-stream");
+		if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+			const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+			for (const encoding of ENCODINGS_ORDERED_KEYS) {
+				if (!acceptEncodingSet.has(encoding)) continue;
+				const precompressedStats = getStats(path$2 + ENCODINGS[encoding]);
+				if (precompressedStats) {
+					c.header("Content-Encoding", encoding);
+					c.header("Vary", "Accept-Encoding", { append: true });
+					stats = precompressedStats;
+					path$2 = path$2 + ENCODINGS[encoding];
+					break;
+				}
+			}
+		}
+		const size = stats.size;
+		if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+			c.header("Content-Length", size.toString());
+			c.status(200);
+			return c.body(null);
+		}
+		const range = c.req.header("range") || "";
+		if (!range) {
+			c.header("Content-Length", size.toString());
+			return c.body(createStreamBody((0, fs.createReadStream)(path$2)), 200);
+		}
+		c.header("Accept-Ranges", "bytes");
+		c.header("Date", stats.birthtime.toUTCString());
+		const parts = range.replace(/bytes=/, "").split("-", 2);
+		const start = parts[0] ? parseInt(parts[0], 10) : 0;
+		let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+		if (size < end - start + 1) end = size - 1;
+		const chunksize = end - start + 1;
+		const stream = (0, fs.createReadStream)(path$2, {
+			start,
+			end
+		});
+		c.header("Content-Length", chunksize.toString());
+		c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+		return c.body(createStreamBody(stream), 206);
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/body.js
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+	const { all = false, dot = false } = options;
+	const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+	const contentType = headers.get("Content-Type");
+	if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
+		all,
+		dot
+	});
+	return {};
+};
+async function parseFormData(request, options) {
+	const formData = await request.formData();
+	if (formData) return convertFormDataToBodyData(formData, options);
+	return {};
 }
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+function convertFormDataToBodyData(formData, options) {
+	const form = /* @__PURE__ */ Object.create(null);
+	formData.forEach((value, key) => {
+		const shouldParseAllValues = options.all || key.endsWith("[]");
+		if (!shouldParseAllValues) form[key] = value;
+		else handleParsingAllValues(form, key, value);
+	});
+	if (options.dot) Object.entries(form).forEach(([key, value]) => {
+		const shouldParseDotValues = key.includes(".");
+		if (shouldParseDotValues) {
+			handleParsingNestedValues(form, key, value);
+			delete form[key];
+		}
+	});
+	return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+	if (form[key] !== void 0) if (Array.isArray(form[key])) form[key].push(value);
+	else form[key] = [form[key], value];
+	else form[key] = value;
+};
+var handleParsingNestedValues = (form, key, value) => {
+	let nestedForm = form;
+	const keys = key.split(".");
+	keys.forEach((key2, index) => {
+		if (index === keys.length - 1) nestedForm[key2] = value;
+		else {
+			if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+			nestedForm = nestedForm[key2];
+		}
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path$2) => {
+	const paths = path$2.split("/");
+	if (paths[0] === "") paths.shift();
+	return paths;
+};
+var splitRoutingPath = (routePath) => {
+	const { groups, path: path$2 } = extractGroupsFromPath(routePath);
+	const paths = splitPath(path$2);
+	return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path$2) => {
+	const groups = [];
+	path$2 = path$2.replace(/\{[^}]+\}/g, (match, index) => {
+		const mark = `@${index}`;
+		groups.push([mark, match]);
+		return mark;
+	});
+	return {
+		groups,
+		path: path$2
+	};
+};
+var replaceGroupMarks = (paths, groups) => {
+	for (let i = groups.length - 1; i >= 0; i--) {
+		const [mark] = groups[i];
+		for (let j = paths.length - 1; j >= 0; j--) if (paths[j].includes(mark)) {
+			paths[j] = paths[j].replace(mark, groups[i][1]);
+			break;
+		}
+	}
+	return paths;
+};
+var patternCache = {};
+var getPattern = (label) => {
+	if (label === "*") return "*";
+	const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+	if (match) {
+		if (!patternCache[label]) if (match[2]) patternCache[label] = [
+			label,
+			match[1],
+			new RegExp("^" + match[2] + "$")
+		];
+		else patternCache[label] = [
+			label,
+			match[1],
+			true
+		];
+		return patternCache[label];
+	}
+	return null;
+};
+var tryDecodeURI = (str) => {
+	try {
+		return decodeURI(str);
+	} catch {
+		return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+			try {
+				return decodeURI(match);
+			} catch {
+				return match;
+			}
+		});
+	}
+};
+var getPath = (request) => {
+	const url$1 = request.url;
+	const start = url$1.indexOf("/", 8);
+	let i = start;
+	for (; i < url$1.length; i++) {
+		const charCode = url$1.charCodeAt(i);
+		if (charCode === 37) {
+			const queryIndex = url$1.indexOf("?", i);
+			const path$2 = url$1.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+			return tryDecodeURI(path$2.includes("%25") ? path$2.replace(/%25/g, "%2525") : path$2);
+		} else if (charCode === 63) break;
+	}
+	return url$1.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+	const result = getPath(request);
+	return result.length > 1 && result[result.length - 1] === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (...paths) => {
+	let p = "";
+	let endsWithSlash = false;
+	for (let path$2 of paths) {
+		if (p[p.length - 1] === "/") {
+			p = p.slice(0, -1);
+			endsWithSlash = true;
+		}
+		if (path$2[0] !== "/") path$2 = `/${path$2}`;
+		if (path$2 === "/" && endsWithSlash) p = `${p}/`;
+		else if (path$2 !== "/") p = `${p}${path$2}`;
+		if (path$2 === "/" && p === "") p = "/";
+	}
+	return p;
+};
+var checkOptionalParameter = (path$2) => {
+	if (!path$2.match(/\:.+\?$/)) return null;
+	const segments = path$2.split("/");
+	const results = [];
+	let basePath = "";
+	segments.forEach((segment) => {
+		if (segment !== "" && !/\:/.test(segment)) basePath += "/" + segment;
+		else if (/\:/.test(segment)) if (/\?/.test(segment)) {
+			if (results.length === 0 && basePath === "") results.push("/");
+			else results.push(basePath);
+			const optionalSegment = segment.replace("?", "");
+			basePath += "/" + optionalSegment;
+			results.push(basePath);
+		} else basePath += "/" + segment;
+	});
+	return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+	if (!/[%+]/.test(value)) return value;
+	if (value.indexOf("+") !== -1) value = value.replace(/\+/g, " ");
+	return /%/.test(value) ? decodeURIComponent_(value) : value;
+};
+var _getQueryParam = (url$1, key, multiple) => {
+	let encoded;
+	if (!multiple && key && !/[%+]/.test(key)) {
+		let keyIndex2 = url$1.indexOf(`?${key}`, 8);
+		if (keyIndex2 === -1) keyIndex2 = url$1.indexOf(`&${key}`, 8);
+		while (keyIndex2 !== -1) {
+			const trailingKeyCode = url$1.charCodeAt(keyIndex2 + key.length + 1);
+			if (trailingKeyCode === 61) {
+				const valueIndex = keyIndex2 + key.length + 2;
+				const endIndex = url$1.indexOf("&", valueIndex);
+				return _decodeURI(url$1.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+			} else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) return "";
+			keyIndex2 = url$1.indexOf(`&${key}`, keyIndex2 + 1);
+		}
+		encoded = /[%+]/.test(url$1);
+		if (!encoded) return void 0;
+	}
+	const results = {};
+	encoded ??= /[%+]/.test(url$1);
+	let keyIndex = url$1.indexOf("?", 8);
+	while (keyIndex !== -1) {
+		const nextKeyIndex = url$1.indexOf("&", keyIndex + 1);
+		let valueIndex = url$1.indexOf("=", keyIndex);
+		if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) valueIndex = -1;
+		let name = url$1.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex);
+		if (encoded) name = _decodeURI(name);
+		keyIndex = nextKeyIndex;
+		if (name === "") continue;
+		let value;
+		if (valueIndex === -1) value = "";
+		else {
+			value = url$1.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+			if (encoded) value = _decodeURI(value);
+		}
+		if (multiple) {
+			if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
+			results[name].push(value);
+		} else results[name] ??= value;
+	}
+	return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url$1, key) => {
+	return _getQueryParam(url$1, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/request.js
+var HonoRequest = class {
+	raw;
+	#validatedData;
+	#matchResult;
+	routeIndex = 0;
+	path;
+	bodyCache = {};
+	constructor(request, path$2 = "/", matchResult = [[]]) {
+		this.raw = request;
+		this.path = path$2;
+		this.#matchResult = matchResult;
+		this.#validatedData = {};
+	}
+	param(key) {
+		return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+	}
+	getDecodedParam(key) {
+		const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+		const param = this.getParamValue(paramKey);
+		return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
+	}
+	getAllDecodedParams() {
+		const decoded = {};
+		const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+		for (const key of keys) {
+			const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+			if (value && typeof value === "string") decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
+		}
+		return decoded;
+	}
+	getParamValue(paramKey) {
+		return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+	}
+	query(key) {
+		return getQueryParam(this.url, key);
+	}
+	queries(key) {
+		return getQueryParams(this.url, key);
+	}
+	header(name) {
+		if (name) return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+		const headerData = {};
+		this.raw.headers.forEach((value, key) => {
+			headerData[key] = value;
+		});
+		return headerData;
+	}
+	async parseBody(options) {
+		return this.bodyCache.parsedBody ??= await parseBody(this, options);
+	}
+	cachedBody = (key) => {
+		const { bodyCache, raw: raw$1 } = this;
+		const cachedBody = bodyCache[key];
+		if (cachedBody) return cachedBody;
+		const anyCachedKey = Object.keys(bodyCache)[0];
+		if (anyCachedKey) return bodyCache[anyCachedKey].then((body) => {
+			if (anyCachedKey === "json") body = JSON.stringify(body);
+			return new Response(body)[key]();
+		});
+		return bodyCache[key] = raw$1[key]();
+	};
+	json() {
+		return this.cachedBody("json");
+	}
+	text() {
+		return this.cachedBody("text");
+	}
+	arrayBuffer() {
+		return this.cachedBody("arrayBuffer");
+	}
+	blob() {
+		return this.cachedBody("blob");
+	}
+	formData() {
+		return this.cachedBody("formData");
+	}
+	addValidatedData(target, data) {
+		this.#validatedData[target] = data;
+	}
+	valid(target) {
+		return this.#validatedData[target];
+	}
+	get url() {
+		return this.raw.url;
+	}
+	get method() {
+		return this.raw.method;
+	}
+	get matchedRoutes() {
+		return this.#matchResult[0].map(([[, route]]) => route);
+	}
+	get routePath() {
+		return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+	Stringify: 1,
+	BeforeStream: 2,
+	Stream: 3
+};
+var raw = (value, callbacks) => {
+	const escapedString = new String(value);
+	escapedString.isEscaped = true;
+	escapedString.callbacks = callbacks;
+	return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+	if (typeof str === "object" && !(str instanceof String)) {
+		if (!(str instanceof Promise)) str = str.toString();
+		if (str instanceof Promise) str = await str;
+	}
+	const callbacks = str.callbacks;
+	if (!callbacks?.length) return Promise.resolve(str);
+	if (buffer) buffer[0] += str;
+	else buffer = [str];
+	const resStr = Promise.all(callbacks.map((c) => c({
+		phase,
+		buffer,
+		context
+	}))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+	if (preserveCallbacks) return raw(await resStr, callbacks);
+	else return resStr;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setHeaders = (headers, map = {}) => {
+	Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+	return headers;
+};
+var Context = class {
+	#rawRequest;
+	#req;
+	env = {};
+	#var;
+	finalized = false;
+	error;
+	#status = 200;
+	#executionCtx;
+	#headers;
+	#preparedHeaders;
+	#res;
+	#isFresh = true;
+	#layout;
+	#renderer;
+	#notFoundHandler;
+	#matchResult;
+	#path;
+	constructor(req, options) {
+		this.#rawRequest = req;
+		if (options) {
+			this.#executionCtx = options.executionCtx;
+			this.env = options.env;
+			this.#notFoundHandler = options.notFoundHandler;
+			this.#path = options.path;
+			this.#matchResult = options.matchResult;
+		}
+	}
+	get req() {
+		this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+		return this.#req;
+	}
+	get event() {
+		if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
+		else throw Error("This context has no FetchEvent");
+	}
+	get executionCtx() {
+		if (this.#executionCtx) return this.#executionCtx;
+		else throw Error("This context has no ExecutionContext");
+	}
+	get res() {
+		this.#isFresh = false;
+		return this.#res ||= new Response("404 Not Found", { status: 404 });
+	}
+	set res(_res) {
+		this.#isFresh = false;
+		if (this.#res && _res) try {
+			for (const [k, v] of this.#res.headers.entries()) {
+				if (k === "content-type") continue;
+				if (k === "set-cookie") {
+					const cookies = this.#res.headers.getSetCookie();
+					_res.headers.delete("set-cookie");
+					for (const cookie of cookies) _res.headers.append("set-cookie", cookie);
+				} else _res.headers.set(k, v);
+			}
+		} catch (e) {
+			if (e instanceof TypeError && e.message.includes("immutable")) {
+				this.res = new Response(_res.body, {
+					headers: _res.headers,
+					status: _res.status
+				});
+				return;
+			} else throw e;
+		}
+		this.#res = _res;
+		this.finalized = true;
+	}
+	render = (...args) => {
+		this.#renderer ??= (content) => this.html(content);
+		return this.#renderer(...args);
+	};
+	setLayout = (layout) => this.#layout = layout;
+	getLayout = () => this.#layout;
+	setRenderer = (renderer) => {
+		this.#renderer = renderer;
+	};
+	header = (name, value, options) => {
+		if (value === void 0) {
+			if (this.#headers) this.#headers.delete(name);
+			else if (this.#preparedHeaders) delete this.#preparedHeaders[name.toLocaleLowerCase()];
+			if (this.finalized) this.res.headers.delete(name);
+			return;
+		}
+		if (options?.append) {
+			if (!this.#headers) {
+				this.#isFresh = false;
+				this.#headers = new Headers(this.#preparedHeaders);
+				this.#preparedHeaders = {};
+			}
+			this.#headers.append(name, value);
+		} else if (this.#headers) this.#headers.set(name, value);
+		else {
+			this.#preparedHeaders ??= {};
+			this.#preparedHeaders[name.toLowerCase()] = value;
+		}
+		if (this.finalized) if (options?.append) this.res.headers.append(name, value);
+		else this.res.headers.set(name, value);
+	};
+	status = (status) => {
+		this.#isFresh = false;
+		this.#status = status;
+	};
+	set = (key, value) => {
+		this.#var ??= /* @__PURE__ */ new Map();
+		this.#var.set(key, value);
+	};
+	get = (key) => {
+		return this.#var ? this.#var.get(key) : void 0;
+	};
+	get var() {
+		if (!this.#var) return {};
+		return Object.fromEntries(this.#var);
+	}
+	newResponse = (data, arg, headers) => {
+		if (this.#isFresh && !headers && !arg && this.#status === 200) return new Response(data, { headers: this.#preparedHeaders });
+		if (arg && typeof arg !== "number") {
+			const header = new Headers(arg.headers);
+			if (this.#headers) this.#headers.forEach((v, k) => {
+				if (k === "set-cookie") header.append(k, v);
+				else header.set(k, v);
+			});
+			const headers2 = setHeaders(header, this.#preparedHeaders);
+			return new Response(data, {
+				headers: headers2,
+				status: arg.status ?? this.#status
+			});
+		}
+		const status = typeof arg === "number" ? arg : this.#status;
+		this.#preparedHeaders ??= {};
+		this.#headers ??= new Headers();
+		setHeaders(this.#headers, this.#preparedHeaders);
+		if (this.#res) {
+			this.#res.headers.forEach((v, k) => {
+				if (k === "set-cookie") this.#headers?.append(k, v);
+				else this.#headers?.set(k, v);
+			});
+			setHeaders(this.#headers, this.#preparedHeaders);
+		}
+		headers ??= {};
+		for (const [k, v] of Object.entries(headers)) if (typeof v === "string") this.#headers.set(k, v);
+		else {
+			this.#headers.delete(k);
+			for (const v2 of v) this.#headers.append(k, v2);
+		}
+		return new Response(data, {
+			status,
+			headers: this.#headers
+		});
+	};
+	body = (data, arg, headers) => {
+		return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+	};
+	text = (text, arg, headers) => {
+		if (!this.#preparedHeaders) {
+			if (this.#isFresh && !headers && !arg) return new Response(text);
+			this.#preparedHeaders = {};
+		}
+		this.#preparedHeaders["content-type"] = TEXT_PLAIN;
+		return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+	};
+	json = (object, arg, headers) => {
+		const body = JSON.stringify(object);
+		this.#preparedHeaders ??= {};
+		this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
+		return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+	};
+	html = (html, arg, headers) => {
+		this.#preparedHeaders ??= {};
+		this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
+		if (typeof html === "object") return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
+			return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+		});
+		return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+	};
+	redirect = (location, status) => {
+		this.#headers ??= new Headers();
+		this.#headers.set("Location", location);
+		return this.newResponse(null, status ?? 302);
+	};
+	notFound = () => {
+		this.#notFoundHandler ??= () => new Response();
+		return this.#notFoundHandler(this);
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+	return (context, next) => {
+		let index = -1;
+		return dispatch(0);
+		async function dispatch(i) {
+			if (i <= index) throw new Error("next() called multiple times");
+			index = i;
+			let res;
+			let isError = false;
+			let handler;
+			if (middleware[i]) {
+				handler = middleware[i][0][0];
+				if (context instanceof Context) context.req.routeIndex = i;
+			} else handler = i === middleware.length && next || void 0;
+			if (!handler) {
+				if (context instanceof Context && context.finalized === false && onNotFound) res = await onNotFound(context);
+			} else try {
+				res = await handler(context, () => {
+					return dispatch(i + 1);
+				});
+			} catch (err) {
+				if (err instanceof Error && context instanceof Context && onError) {
+					context.error = err;
+					res = await onError(err, context);
+					isError = true;
+				} else throw err;
+			}
+			if (res && (context.finalized === false || isError)) context.res = res;
+			return context;
+		}
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"options",
+	"patch"
+];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono-base.js
+var COMPOSED_HANDLER = Symbol("composedHandler");
+var notFoundHandler = (c) => {
+	return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+	if ("getResponse" in err) return err.getResponse();
+	console.error(err);
+	return c.text("Internal Server Error", 500);
+};
+var Hono$1 = class {
+	get;
+	post;
+	put;
+	delete;
+	options;
+	patch;
+	all;
+	on;
+	use;
+	router;
+	getPath;
+	_basePath = "/";
+	#path = "/";
+	routes = [];
+	constructor(options = {}) {
+		const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+		allMethods.forEach((method) => {
+			this[method] = (args1, ...args) => {
+				if (typeof args1 === "string") this.#path = args1;
+				else this.addRoute(method, this.#path, args1);
+				args.forEach((handler) => {
+					if (typeof handler !== "string") this.addRoute(method, this.#path, handler);
+				});
+				return this;
+			};
+		});
+		this.on = (method, path$2, ...handlers) => {
+			for (const p of [path$2].flat()) {
+				this.#path = p;
+				for (const m of [method].flat()) handlers.map((handler) => {
+					this.addRoute(m.toUpperCase(), this.#path, handler);
+				});
+			}
+			return this;
+		};
+		this.use = (arg1, ...handlers) => {
+			if (typeof arg1 === "string") this.#path = arg1;
+			else {
+				this.#path = "*";
+				handlers.unshift(arg1);
+			}
+			handlers.forEach((handler) => {
+				this.addRoute(METHOD_NAME_ALL, this.#path, handler);
+			});
+			return this;
+		};
+		const strict = options.strict ?? true;
+		delete options.strict;
+		Object.assign(this, options);
+		this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
+	}
+	clone() {
+		const clone = new Hono$1({
+			router: this.router,
+			getPath: this.getPath
+		});
+		clone.routes = this.routes;
+		return clone;
+	}
+	notFoundHandler = notFoundHandler;
+	errorHandler = errorHandler;
+	route(path$2, app$1) {
+		const subApp = this.basePath(path$2);
+		app$1.routes.map((r) => {
+			let handler;
+			if (app$1.errorHandler === errorHandler) handler = r.handler;
+			else {
+				handler = async (c, next) => (await compose([], app$1.errorHandler)(c, () => r.handler(c, next))).res;
+				handler[COMPOSED_HANDLER] = r.handler;
+			}
+			subApp.addRoute(r.method, r.path, handler);
+		});
+		return this;
+	}
+	basePath(path$2) {
+		const subApp = this.clone();
+		subApp._basePath = mergePath(this._basePath, path$2);
+		return subApp;
+	}
+	onError = (handler) => {
+		this.errorHandler = handler;
+		return this;
+	};
+	notFound = (handler) => {
+		this.notFoundHandler = handler;
+		return this;
+	};
+	mount(path$2, applicationHandler, options) {
+		let replaceRequest;
+		let optionHandler;
+		if (options) if (typeof options === "function") optionHandler = options;
+		else {
+			optionHandler = options.optionHandler;
+			replaceRequest = options.replaceRequest;
+		}
+		const getOptions = optionHandler ? (c) => {
+			const options2 = optionHandler(c);
+			return Array.isArray(options2) ? options2 : [options2];
+		} : (c) => {
+			let executionContext = void 0;
+			try {
+				executionContext = c.executionCtx;
+			} catch {}
+			return [c.env, executionContext];
+		};
+		replaceRequest ||= (() => {
+			const mergedPath = mergePath(this._basePath, path$2);
+			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+			return (request) => {
+				const url$1 = new URL(request.url);
+				url$1.pathname = url$1.pathname.slice(pathPrefixLength) || "/";
+				return new Request(url$1, request);
+			};
+		})();
+		const handler = async (c, next) => {
+			const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+			if (res) return res;
+			await next();
+		};
+		this.addRoute(METHOD_NAME_ALL, mergePath(path$2, "*"), handler);
+		return this;
+	}
+	addRoute(method, path$2, handler) {
+		method = method.toUpperCase();
+		path$2 = mergePath(this._basePath, path$2);
+		const r = {
+			path: path$2,
+			method,
+			handler
+		};
+		this.router.add(method, path$2, [handler, r]);
+		this.routes.push(r);
+	}
+	matchRoute(method, path$2) {
+		return this.router.match(method, path$2);
+	}
+	handleError(err, c) {
+		if (err instanceof Error) return this.errorHandler(err, c);
+		throw err;
+	}
+	dispatch(request, executionCtx, env, method) {
+		if (method === "HEAD") return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+		const path$2 = this.getPath(request, { env });
+		const matchResult = this.matchRoute(method, path$2);
+		const c = new Context(request, {
+			path: path$2,
+			matchResult,
+			env,
+			executionCtx,
+			notFoundHandler: this.notFoundHandler
+		});
+		if (matchResult[0].length === 1) {
+			let res;
+			try {
+				res = matchResult[0][0][0][0](c, async () => {
+					c.res = await this.notFoundHandler(c);
+				});
+			} catch (err) {
+				return this.handleError(err, c);
+			}
+			return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+		}
+		const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
+		return (async () => {
+			try {
+				const context = await composed(c);
+				if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+				return context.res;
+			} catch (err) {
+				return this.handleError(err, c);
+			}
+		})();
+	}
+	fetch = (request, ...rest) => {
+		return this.dispatch(request, rest[1], rest[0], request.method);
+	};
+	request = (input, requestInit, Env, executionCtx) => {
+		if (input instanceof Request) {
+			if (requestInit !== void 0) input = new Request(input, requestInit);
+			return this.fetch(input, Env, executionCtx);
+		}
+		input = input.toString();
+		const path$2 = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
+		const req = new Request(path$2, requestInit);
+		return this.fetch(req, Env, executionCtx);
+	};
+	fire = () => {
+		addEventListener("fetch", (event) => {
+			event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+		});
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+	if (a.length === 1) return b.length === 1 ? a < b ? -1 : 1 : -1;
+	if (b.length === 1) return 1;
+	if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) return 1;
+	else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) return -1;
+	if (a === LABEL_REG_EXP_STR) return 1;
+	else if (b === LABEL_REG_EXP_STR) return -1;
+	return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node$1 = class {
+	index;
+	varIndex;
+	children = /* @__PURE__ */ Object.create(null);
+	insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+		if (tokens.length === 0) {
+			if (this.index !== void 0) throw PATH_ERROR;
+			if (pathErrorCheckOnly) return;
+			this.index = index;
+			return;
+		}
+		const [token, ...restTokens] = tokens;
+		const pattern = token === "*" ? restTokens.length === 0 ? [
+			"",
+			"",
+			ONLY_WILDCARD_REG_EXP_STR
+		] : [
+			"",
+			"",
+			LABEL_REG_EXP_STR
+		] : token === "/*" ? [
+			"",
+			"",
+			TAIL_WILDCARD_REG_EXP_STR
+		] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+		let node;
+		if (pattern) {
+			const name = pattern[1];
+			let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+			if (name && pattern[2]) {
+				regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+				if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
+			}
+			node = this.children[regexpStr];
+			if (!node) {
+				if (Object.keys(this.children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
+				if (pathErrorCheckOnly) return;
+				node = this.children[regexpStr] = new Node$1();
+				if (name !== "") node.varIndex = context.varIndex++;
+			}
+			if (!pathErrorCheckOnly && name !== "") paramMap.push([name, node.varIndex]);
+		} else {
+			node = this.children[token];
+			if (!node) {
+				if (Object.keys(this.children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
+				if (pathErrorCheckOnly) return;
+				node = this.children[token] = new Node$1();
+			}
+		}
+		node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+	}
+	buildRegExpStr() {
+		const childKeys = Object.keys(this.children).sort(compareKey);
+		const strList = childKeys.map((k) => {
+			const c = this.children[k];
+			return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+		});
+		if (typeof this.index === "number") strList.unshift(`#${this.index}`);
+		if (strList.length === 0) return "";
+		if (strList.length === 1) return strList[0];
+		return "(?:" + strList.join("|") + ")";
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+	context = { varIndex: 0 };
+	root = new Node$1();
+	insert(path$2, index, pathErrorCheckOnly) {
+		const paramAssoc = [];
+		const groups = [];
+		for (let i = 0;;) {
+			let replaced = false;
+			path$2 = path$2.replace(/\{[^}]+\}/g, (m) => {
+				const mark = `@\\${i}`;
+				groups[i] = [mark, m];
+				i++;
+				replaced = true;
+				return mark;
+			});
+			if (!replaced) break;
+		}
+		const tokens = path$2.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+		for (let i = groups.length - 1; i >= 0; i--) {
+			const [mark] = groups[i];
+			for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
+				tokens[j] = tokens[j].replace(mark, groups[i][1]);
+				break;
+			}
+		}
+		this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+		return paramAssoc;
+	}
+	buildRegExp() {
+		let regexp = this.root.buildRegExpStr();
+		if (regexp === "") return [
+			/^$/,
+			[],
+			[]
+		];
+		let captureIndex = 0;
+		const indexReplacementMap = [];
+		const paramReplacementMap = [];
+		regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+			if (typeof handlerIndex !== "undefined") {
+				indexReplacementMap[++captureIndex] = Number(handlerIndex);
+				return "$()";
+			}
+			if (typeof paramIndex !== "undefined") {
+				paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+				return "";
+			}
+			return "";
+		});
+		return [
+			new RegExp(`^${regexp}`),
+			indexReplacementMap,
+			paramReplacementMap
+		];
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var emptyParam = [];
+var nullMatcher = [
+	/^$/,
+	[],
+	/* @__PURE__ */ Object.create(null)
+];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path$2) {
+	return wildcardRegExpCache[path$2] ??= new RegExp(path$2 === "*" ? "" : `^${path$2.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
+}
+function clearWildcardRegExpCache() {
+	wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+	const trie = new Trie();
+	const handlerData = [];
+	if (routes.length === 0) return nullMatcher;
+	const routesWithStaticPathFlag = routes.map((route) => [!/\*|\/:/.test(route[0]), ...route]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
+	const staticMap = /* @__PURE__ */ Object.create(null);
+	for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+		const [pathErrorCheckOnly, path$2, handlers] = routesWithStaticPathFlag[i];
+		if (pathErrorCheckOnly) staticMap[path$2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+		else j++;
+		let paramAssoc;
+		try {
+			paramAssoc = trie.insert(path$2, j, pathErrorCheckOnly);
+		} catch (e) {
+			throw e === PATH_ERROR ? new UnsupportedPathError(path$2) : e;
+		}
+		if (pathErrorCheckOnly) continue;
+		handlerData[j] = handlers.map(([h, paramCount]) => {
+			const paramIndexMap = /* @__PURE__ */ Object.create(null);
+			paramCount -= 1;
+			for (; paramCount >= 0; paramCount--) {
+				const [key, value] = paramAssoc[paramCount];
+				paramIndexMap[key] = value;
+			}
+			return [h, paramIndexMap];
+		});
+	}
+	const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+	for (let i = 0, len = handlerData.length; i < len; i++) for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+		const map = handlerData[i][j]?.[1];
+		if (!map) continue;
+		const keys = Object.keys(map);
+		for (let k = 0, len3 = keys.length; k < len3; k++) map[keys[k]] = paramReplacementMap[map[keys[k]]];
+	}
+	const handlerMap = [];
+	for (const i in indexReplacementMap) handlerMap[i] = handlerData[indexReplacementMap[i]];
+	return [
+		regexp,
+		handlerMap,
+		staticMap
+	];
+}
+function findMiddleware(middleware, path$2) {
+	if (!middleware) return void 0;
+	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path$2)) return [...middleware[k]];
+	return void 0;
+}
+var RegExpRouter = class {
+	name = "RegExpRouter";
+	middleware;
+	routes;
+	constructor() {
+		this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+		this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+	}
+	add(method, path$2, handler) {
+		const { middleware, routes } = this;
+		if (!middleware || !routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		if (!middleware[method]) [middleware, routes].forEach((handlerMap) => {
+			handlerMap[method] = /* @__PURE__ */ Object.create(null);
+			Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+				handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+			});
+		});
+		if (path$2 === "/*") path$2 = "*";
+		const paramCount = (path$2.match(/\/:/g) || []).length;
+		if (/\*$/.test(path$2)) {
+			const re = buildWildcardRegExp(path$2);
+			if (method === METHOD_NAME_ALL) Object.keys(middleware).forEach((m) => {
+				middleware[m][path$2] ||= findMiddleware(middleware[m], path$2) || findMiddleware(middleware[METHOD_NAME_ALL], path$2) || [];
+			});
+			else middleware[method][path$2] ||= findMiddleware(middleware[method], path$2) || findMiddleware(middleware[METHOD_NAME_ALL], path$2) || [];
+			Object.keys(middleware).forEach((m) => {
+				if (method === METHOD_NAME_ALL || method === m) Object.keys(middleware[m]).forEach((p) => {
+					re.test(p) && middleware[m][p].push([handler, paramCount]);
+				});
+			});
+			Object.keys(routes).forEach((m) => {
+				if (method === METHOD_NAME_ALL || method === m) Object.keys(routes[m]).forEach((p) => re.test(p) && routes[m][p].push([handler, paramCount]));
+			});
+			return;
+		}
+		const paths = checkOptionalParameter(path$2) || [path$2];
+		for (let i = 0, len = paths.length; i < len; i++) {
+			const path2 = paths[i];
+			Object.keys(routes).forEach((m) => {
+				if (method === METHOD_NAME_ALL || method === m) {
+					routes[m][path2] ||= [...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []];
+					routes[m][path2].push([handler, paramCount - len + i + 1]);
+				}
+			});
+		}
+	}
+	match(method, path$2) {
+		clearWildcardRegExpCache();
+		const matchers = this.buildAllMatchers();
+		this.match = (method2, path2) => {
+			const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+			const staticMatch = matcher[2][path2];
+			if (staticMatch) return staticMatch;
+			const match = path2.match(matcher[0]);
+			if (!match) return [[], emptyParam];
+			const index = match.indexOf("", 1);
+			return [matcher[1][index], match];
+		};
+		return this.match(method, path$2);
+	}
+	buildAllMatchers() {
+		const matchers = /* @__PURE__ */ Object.create(null);
+		[...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
+			matchers[method] ||= this.buildMatcher(method);
+		});
+		this.middleware = this.routes = void 0;
+		return matchers;
+	}
+	buildMatcher(method) {
+		const routes = [];
+		let hasOwnRoute = method === METHOD_NAME_ALL;
+		[this.middleware, this.routes].forEach((r) => {
+			const ownRoute = r[method] ? Object.keys(r[method]).map((path$2) => [path$2, r[method][path$2]]) : [];
+			if (ownRoute.length !== 0) {
+				hasOwnRoute ||= true;
+				routes.push(...ownRoute);
+			} else if (method !== METHOD_NAME_ALL) routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path$2) => [path$2, r[METHOD_NAME_ALL][path$2]]));
+		});
+		if (!hasOwnRoute) return null;
+		else return buildMatcherFromPreprocessedRoutes(routes);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+	name = "SmartRouter";
+	routers = [];
+	routes = [];
+	constructor(init) {
+		Object.assign(this, init);
+	}
+	add(method, path$2, handler) {
+		if (!this.routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		this.routes.push([
+			method,
+			path$2,
+			handler
+		]);
+	}
+	match(method, path$2) {
+		if (!this.routes) throw new Error("Fatal error");
+		const { routers, routes } = this;
+		const len = routers.length;
+		let i = 0;
+		let res;
+		for (; i < len; i++) {
+			const router = routers[i];
+			try {
+				routes.forEach((args) => {
+					router.add(...args);
+				});
+				res = router.match(method, path$2);
+			} catch (e) {
+				if (e instanceof UnsupportedPathError) continue;
+				throw e;
+			}
+			this.match = router.match.bind(router);
+			this.routers = [router];
+			this.routes = void 0;
+			break;
+		}
+		if (i === len) throw new Error("Fatal error");
+		this.name = `SmartRouter + ${this.activeRouter.name}`;
+		return res;
+	}
+	get activeRouter() {
+		if (this.routes || this.routers.length !== 1) throw new Error("No active router has been determined yet.");
+		return this.routers[0];
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/node.js
+var Node = class {
+	methods;
+	children;
+	patterns;
+	order = 0;
+	name;
+	params = /* @__PURE__ */ Object.create(null);
+	constructor(method, handler, children) {
+		this.children = children || /* @__PURE__ */ Object.create(null);
+		this.methods = [];
+		this.name = "";
+		if (method && handler) {
+			const m = /* @__PURE__ */ Object.create(null);
+			m[method] = {
+				handler,
+				possibleKeys: [],
+				score: 0,
+				name: this.name
+			};
+			this.methods = [m];
+		}
+		this.patterns = [];
+	}
+	insert(method, path$2, handler) {
+		this.name = `${method} ${path$2}`;
+		this.order = ++this.order;
+		let curNode = this;
+		const parts = splitRoutingPath(path$2);
+		const possibleKeys = [];
+		for (let i = 0, len = parts.length; i < len; i++) {
+			const p = parts[i];
+			if (Object.keys(curNode.children).includes(p)) {
+				curNode = curNode.children[p];
+				const pattern2 = getPattern(p);
+				if (pattern2) possibleKeys.push(pattern2[1]);
+				continue;
+			}
+			curNode.children[p] = new Node();
+			const pattern = getPattern(p);
+			if (pattern) {
+				curNode.patterns.push(pattern);
+				possibleKeys.push(pattern[1]);
+			}
+			curNode = curNode.children[p];
+		}
+		if (!curNode.methods.length) curNode.methods = [];
+		const m = /* @__PURE__ */ Object.create(null);
+		const handlerSet = {
+			handler,
+			possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+			name: this.name,
+			score: this.order
+		};
+		m[method] = handlerSet;
+		curNode.methods.push(m);
+		return curNode;
+	}
+	gHSets(node, method, nodeParams, params) {
+		const handlerSets = [];
+		for (let i = 0, len = node.methods.length; i < len; i++) {
+			const m = node.methods[i];
+			const handlerSet = m[method] || m[METHOD_NAME_ALL];
+			const processedSet = /* @__PURE__ */ Object.create(null);
+			if (handlerSet !== void 0) {
+				handlerSet.params = /* @__PURE__ */ Object.create(null);
+				handlerSet.possibleKeys.forEach((key) => {
+					const processed = processedSet[handlerSet.name];
+					handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
+					processedSet[handlerSet.name] = true;
+				});
+				handlerSets.push(handlerSet);
+			}
+		}
+		return handlerSets;
+	}
+	search(method, path$2) {
+		const handlerSets = [];
+		this.params = /* @__PURE__ */ Object.create(null);
+		const curNode = this;
+		let curNodes = [curNode];
+		const parts = splitPath(path$2);
+		for (let i = 0, len = parts.length; i < len; i++) {
+			const part = parts[i];
+			const isLast = i === len - 1;
+			const tempNodes = [];
+			for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+				const node = curNodes[j];
+				const nextNode = node.children[part];
+				if (nextNode) {
+					nextNode.params = node.params;
+					if (isLast === true) {
+						if (nextNode.children["*"]) handlerSets.push(...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null)));
+						handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+					} else tempNodes.push(nextNode);
+				}
+				for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+					const pattern = node.patterns[k];
+					const params = { ...node.params };
+					if (pattern === "*") {
+						const astNode = node.children["*"];
+						if (astNode) {
+							handlerSets.push(...this.gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+							tempNodes.push(astNode);
+						}
+						continue;
+					}
+					if (part === "") continue;
+					const [key, name, matcher] = pattern;
+					const child = node.children[key];
+					const restPathString = parts.slice(i).join("/");
+					if (matcher instanceof RegExp && matcher.test(restPathString)) {
+						params[name] = restPathString;
+						handlerSets.push(...this.gHSets(child, method, node.params, params));
+						continue;
+					}
+					if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+						if (typeof key === "string") {
+							params[name] = part;
+							if (isLast === true) {
+								handlerSets.push(...this.gHSets(child, method, params, node.params));
+								if (child.children["*"]) handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
+							} else {
+								child.params = params;
+								tempNodes.push(child);
+							}
+						}
+					}
+				}
+			}
+			curNodes = tempNodes;
+		}
+		const results = handlerSets.sort((a, b) => {
+			return a.score - b.score;
+		});
+		return [results.map(({ handler, params }) => [handler, params])];
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+	name = "TrieRouter";
+	node;
+	constructor() {
+		this.node = new Node();
+	}
+	add(method, path$2, handler) {
+		const results = checkOptionalParameter(path$2);
+		if (results) {
+			for (const p of results) this.node.insert(method, p, handler);
+			return;
+		}
+		this.node.insert(method, path$2, handler);
+	}
+	match(method, path$2) {
+		return this.node.search(method, path$2);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono.js
+var Hono = class extends Hono$1 {
+	constructor(options = {}) {
+		super(options);
+		this.router = options.router ?? new SmartRouter({ routers: [new RegExpRouter(), new TrieRouter()] });
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.8.3/node_modules/typia/lib/internal/_validateReport.js
+var require__validateReport = __commonJS({ "../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.8.3/node_modules/typia/lib/internal/_validateReport.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports._validateReport = void 0;
+	const _validateReport = (array) => {
+		const reportable = (path$2) => {
+			if (array.length === 0) return true;
+			const last = array[array.length - 1].path;
+			return path$2.length > last.length || last.substring(0, path$2.length) !== path$2;
+		};
+		return (exceptable, error) => {
+			if (exceptable && reportable(error.path)) array.push(error);
+			return false;
+		};
+	};
+	exports._validateReport = _validateReport;
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/cookie.js
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+var parse = (cookie, name) => {
+	const pairs = cookie.trim().split(";");
+	return pairs.reduce((parsedCookie, pairStr) => {
+		pairStr = pairStr.trim();
+		const valueStartPos = pairStr.indexOf("=");
+		if (valueStartPos === -1) return parsedCookie;
+		const cookieName = pairStr.substring(0, valueStartPos).trim();
+		if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) return parsedCookie;
+		let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+		if (cookieValue.startsWith("\"") && cookieValue.endsWith("\"")) cookieValue = cookieValue.slice(1, -1);
+		if (validCookieValueRegEx.test(cookieValue)) parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
+		return parsedCookie;
+	}, {});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/helper/cookie/index.js
+var getCookie = (c, key, prefix) => {
+	const cookie = c.req.raw.headers.get("Cookie");
+	if (typeof key === "string") {
+		if (!cookie) return void 0;
+		let finalKey = key;
+		if (prefix === "secure") finalKey = "__Secure-" + key;
+		else if (prefix === "host") finalKey = "__Host-" + key;
+		const obj2 = parse(cookie, finalKey);
+		return obj2[finalKey];
+	}
+	if (!cookie) return {};
+	const obj = parse(cookie);
+	return obj;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+	res;
+	status;
+	constructor(status = 500, options) {
+		super(options?.message, { cause: options?.cause });
+		this.res = options?.res;
+		this.status = status;
+	}
+	getResponse() {
+		if (this.res) {
+			const newResponse = new Response(this.res.body, {
+				status: this.status,
+				headers: this.res.headers
+			});
+			return newResponse;
+		}
+		return new Response(this.message, { status: this.status });
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+	const response = new Response(arrayBuffer, { headers: { "Content-Type": contentType } });
+	return response.formData();
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/validator/validator.js
+var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
+var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+var validator = (target, validationFunc) => {
+	return async (c, next) => {
+		let value = {};
+		const contentType = c.req.header("Content-Type");
+		switch (target) {
+			case "json":
+				if (!contentType || !jsonRegex.test(contentType)) break;
+				try {
+					value = await c.req.json();
+				} catch {
+					const message = "Malformed JSON in request body";
+					throw new HTTPException(400, { message });
+				}
+				break;
+			case "form": {
+				if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) break;
+				let formData;
+				if (c.req.bodyCache.formData) formData = await c.req.bodyCache.formData;
+				else try {
+					const arrayBuffer = await c.req.arrayBuffer();
+					formData = await bufferToFormData(arrayBuffer, contentType);
+					c.req.bodyCache.formData = formData;
+				} catch (e) {
+					let message = "Malformed FormData request.";
+					message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+					throw new HTTPException(400, { message });
+				}
+				const form = {};
+				formData.forEach((value2, key) => {
+					if (key.endsWith("[]")) (form[key] ??= []).push(value2);
+					else if (Array.isArray(form[key])) form[key].push(value2);
+					else if (key in form) form[key] = [form[key], value2];
+					else form[key] = value2;
+				});
+				value = form;
+				break;
+			}
+			case "query":
+				value = Object.fromEntries(Object.entries(c.req.queries()).map(([k, v]) => {
+					return v.length === 1 ? [k, v[0]] : [k, v];
+				}));
+				break;
+			case "param":
+				value = c.req.param();
+				break;
+			case "header":
+				value = c.req.header();
+				break;
+			case "cookie":
+				value = getCookie(c);
+				break;
+		}
+		const res = await validationFunc(value, c);
+		if (res instanceof Response) return res;
+		c.req.addValidatedData(target, res);
+		await next();
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@hono+typia-validator@0.1.2_hono@4.6.3_typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.8.3_/node_modules/@hono/typia-validator/dist/esm/index.js
+const typiaValidator = (target, validate, hook) => validator(target, async (value, c) => {
+	const result = validate(value);
+	if (hook) {
+		const hookResult = await hook({
+			...result,
+			data: value
+		}, c);
+		if (hookResult) {
+			if (hookResult instanceof Response || hookResult instanceof Promise) return hookResult;
+			if ("response" in hookResult) return hookResult.response;
+		}
+	}
+	if (!result.success) return c.json({
+		success: false,
+		error: result.errors
+	}, 400);
+	return result.data;
+});
+
+//#endregion
+//#region src-server/rpc.ts
+var import__validateReport = __toESM(require__validateReport(), 1);
+const queryBundlesSchema = (() => {
+	const _io0 = (input) => (void 0 === input.channel || "string" === typeof input.channel) && (void 0 === input.platform || "ios" === input.platform || "android" === input.platform) && (void 0 === input.limit || "string" === typeof input.limit) && (void 0 === input.offset || "string" === typeof input.offset);
+	const _vo0 = (input, _path, _exceptionable = true) => [
+		void 0 === input.channel || "string" === typeof input.channel || _report(_exceptionable, {
+			path: _path + ".channel",
+			expected: "(string | undefined)",
+			value: input.channel
+		}),
+		void 0 === input.platform || "ios" === input.platform || "android" === input.platform || _report(_exceptionable, {
+			path: _path + ".platform",
+			expected: "(\"android\" | \"ios\" | undefined)",
+			value: input.platform
+		}),
+		void 0 === input.limit || "string" === typeof input.limit || _report(_exceptionable, {
+			path: _path + ".limit",
+			expected: "(string | undefined)",
+			value: input.limit
+		}),
+		void 0 === input.offset || "string" === typeof input.offset || _report(_exceptionable, {
+			path: _path + ".offset",
+			expected: "(string | undefined)",
+			value: input.offset
+		})
+	].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+	let errors;
+	let _report;
+	return (input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = import__validateReport._validateReport(errors);
+			((input$1, _path, _exceptionable = true) => ("object" === typeof input$1 && null !== input$1 && false === Array.isArray(input$1) || _report(true, {
+				path: _path + "",
+				expected: "__type",
+				value: input$1
+			})) && _vo0(input$1, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "__type",
+				value: input$1
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	};
 })();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
+const paramBundleIdSchema = (() => {
+	const _io0 = (input) => "string" === typeof input.bundleId;
+	const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.bundleId || _report(_exceptionable, {
+		path: _path + ".bundleId",
+		expected: "string",
+		value: input.bundleId
+	})].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+	let errors;
+	let _report;
+	return (input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = import__validateReport._validateReport(errors);
+			((input$1, _path, _exceptionable = true) => ("object" === typeof input$1 && null !== input$1 || _report(true, {
+				path: _path + "",
+				expected: "__type",
+				value: input$1
+			})) && _vo0(input$1, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "__type",
+				value: input$1
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	};
 })();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        default: ()=>src_server
-    });
-    const external_path_namespaceObject = require("path");
-    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-    const external_url_namespaceObject = require("url");
-    var getFilePath = (options)=>{
-        let filename = options.filename;
-        const defaultDocument = options.defaultDocument || "index.html";
-        if (filename.endsWith("/")) filename = filename.concat(defaultDocument);
-        else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) filename = filename.concat("/" + defaultDocument);
-        const path = getFilePathWithoutDefaultDocument({
-            root: options.root,
-            filename
-        });
-        return path;
-    };
-    var getFilePathWithoutDefaultDocument = (options)=>{
-        let root = options.root || "";
-        let filename = options.filename;
-        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) return;
-        filename = filename.replace(/^\.?[\/\\]/, "");
-        filename = filename.replace(/\\/, "/");
-        root = root.replace(/\/$/, "");
-        let path = root ? root + "/" + filename : filename;
-        path = path.replace(/^\.?\//, "");
-        if ("/" !== root[0] && "/" === path[0]) return;
-        return path;
-    };
-    var getMimeType = (filename, mimes = baseMimes)=>{
-        const regexp = /\.([a-zA-Z0-9]+?)$/;
-        const match = filename.match(regexp);
-        if (!match) return;
-        let mimeType = mimes[match[1]];
-        if (mimeType && mimeType.startsWith("text") || "application/json" === mimeType) mimeType += "; charset=utf-8";
-        return mimeType;
-    };
-    var baseMimes = {
-        aac: "audio/aac",
-        avi: "video/x-msvideo",
-        avif: "image/avif",
-        av1: "video/av1",
-        bin: "application/octet-stream",
-        bmp: "image/bmp",
-        css: "text/css",
-        csv: "text/csv",
-        eot: "application/vnd.ms-fontobject",
-        epub: "application/epub+zip",
-        gif: "image/gif",
-        gz: "application/gzip",
-        htm: "text/html",
-        html: "text/html",
-        ico: "image/x-icon",
-        ics: "text/calendar",
-        jpeg: "image/jpeg",
-        jpg: "image/jpeg",
-        js: "text/javascript",
-        json: "application/json",
-        jsonld: "application/ld+json",
-        map: "application/json",
-        mid: "audio/x-midi",
-        midi: "audio/x-midi",
-        mjs: "text/javascript",
-        mp3: "audio/mpeg",
-        mp4: "video/mp4",
-        mpeg: "video/mpeg",
-        oga: "audio/ogg",
-        ogv: "video/ogg",
-        ogx: "application/ogg",
-        opus: "audio/opus",
-        otf: "font/otf",
-        pdf: "application/pdf",
-        png: "image/png",
-        rtf: "application/rtf",
-        svg: "image/svg+xml",
-        tif: "image/tiff",
-        tiff: "image/tiff",
-        ts: "video/mp2t",
-        ttf: "font/ttf",
-        txt: "text/plain",
-        wasm: "application/wasm",
-        webm: "video/webm",
-        weba: "audio/webm",
-        webp: "image/webp",
-        woff: "font/woff",
-        woff2: "font/woff2",
-        xhtml: "application/xhtml+xml",
-        xml: "application/xml",
-        zip: "application/zip",
-        "3gp": "video/3gpp",
-        "3g2": "video/3gpp2",
-        gltf: "model/gltf+json",
-        glb: "model/gltf-binary"
-    };
-    const external_fs_namespaceObject = require("fs");
-    var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
-    var ENCODINGS = {
-        br: ".br",
-        zstd: ".zst",
-        gzip: ".gz"
-    };
-    var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-    var createStreamBody = (stream)=>{
-        const body = new ReadableStream({
-            start (controller) {
-                stream.on("data", (chunk)=>{
-                    controller.enqueue(chunk);
-                });
-                stream.on("end", ()=>{
-                    controller.close();
-                });
-            },
-            cancel () {
-                stream.destroy();
-            }
-        });
-        return body;
-    };
-    var addCurrentDirPrefix = (path)=>`./${path}`;
-    var getStats = (path)=>{
-        let stats;
-        try {
-            stats = (0, external_fs_namespaceObject.lstatSync)(path);
-        } catch  {}
-        return stats;
-    };
-    var serveStatic = (options = {
-        root: ""
-    })=>async (c, next)=>{
-            if (c.finalized) return next();
-            let filename;
-            try {
-                filename = options.path ?? decodeURIComponent(c.req.path);
-            } catch  {
-                await options.onNotFound?.(c.req.path, c);
-                return next();
-            }
-            let path = getFilePathWithoutDefaultDocument({
-                filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-                root: options.root
-            });
-            if (!path) return next();
-            path = addCurrentDirPrefix(path);
-            let stats = getStats(path);
-            if (stats && stats.isDirectory()) {
-                path = getFilePath({
-                    filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-                    root: options.root,
-                    defaultDocument: options.index ?? "index.html"
-                });
-                if (!path) return next();
-                path = addCurrentDirPrefix(path);
-                stats = getStats(path);
-            }
-            if (!stats) {
-                await options.onNotFound?.(path, c);
-                return next();
-            }
-            await options.onFound?.(path, c);
-            const mimeType = getMimeType(path);
-            c.header("Content-Type", mimeType || "application/octet-stream");
-            if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
-                const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding)=>encoding.trim()));
-                for (const encoding of ENCODINGS_ORDERED_KEYS){
-                    if (!acceptEncodingSet.has(encoding)) continue;
-                    const precompressedStats = getStats(path + ENCODINGS[encoding]);
-                    if (precompressedStats) {
-                        c.header("Content-Encoding", encoding);
-                        c.header("Vary", "Accept-Encoding", {
-                            append: true
-                        });
-                        stats = precompressedStats;
-                        path += ENCODINGS[encoding];
-                        break;
-                    }
-                }
-            }
-            const size = stats.size;
-            if ("HEAD" == c.req.method || "OPTIONS" == c.req.method) {
-                c.header("Content-Length", size.toString());
-                c.status(200);
-                return c.body(null);
-            }
-            const range = c.req.header("range") || "";
-            if (!range) {
-                c.header("Content-Length", size.toString());
-                return c.body(createStreamBody((0, external_fs_namespaceObject.createReadStream)(path)), 200);
-            }
-            c.header("Accept-Ranges", "bytes");
-            c.header("Date", stats.birthtime.toUTCString());
-            const parts = range.replace(/bytes=/, "").split("-", 2);
-            const start = parts[0] ? parseInt(parts[0], 10) : 0;
-            let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
-            if (size < end - start + 1) end = size - 1;
-            const chunksize = end - start + 1;
-            const stream = (0, external_fs_namespaceObject.createReadStream)(path, {
-                start,
-                end
-            });
-            c.header("Content-Length", chunksize.toString());
-            c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-            return c.body(createStreamBody(stream), 206);
-        };
-    var parseBody = async (request, options = /* @__PURE__ */ Object.create(null))=>{
-        const { all = false, dot = false } = options;
-        const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-        const contentType = headers.get("Content-Type");
-        if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
-            all,
-            dot
-        });
-        return {};
-    };
-    async function parseFormData(request, options) {
-        const formData = await request.formData();
-        if (formData) return convertFormDataToBodyData(formData, options);
-        return {};
-    }
-    function convertFormDataToBodyData(formData, options) {
-        const form = /* @__PURE__ */ Object.create(null);
-        formData.forEach((value, key)=>{
-            const shouldParseAllValues = options.all || key.endsWith("[]");
-            if (shouldParseAllValues) handleParsingAllValues(form, key, value);
-            else form[key] = value;
-        });
-        if (options.dot) Object.entries(form).forEach(([key, value])=>{
-            const shouldParseDotValues = key.includes(".");
-            if (shouldParseDotValues) {
-                handleParsingNestedValues(form, key, value);
-                delete form[key];
-            }
-        });
-        return form;
-    }
-    var handleParsingAllValues = (form, key, value)=>{
-        if (void 0 !== form[key]) if (Array.isArray(form[key])) form[key].push(value);
-        else form[key] = [
-            form[key],
-            value
-        ];
-        else form[key] = value;
-    };
-    var handleParsingNestedValues = (form, key, value)=>{
-        let nestedForm = form;
-        const keys = key.split(".");
-        keys.forEach((key2, index)=>{
-            if (index === keys.length - 1) nestedForm[key2] = value;
-            else {
-                if (!nestedForm[key2] || "object" != typeof nestedForm[key2] || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-                nestedForm = nestedForm[key2];
-            }
-        });
-    };
-    var splitPath = (path)=>{
-        const paths = path.split("/");
-        if ("" === paths[0]) paths.shift();
-        return paths;
-    };
-    var splitRoutingPath = (routePath)=>{
-        const { groups, path } = extractGroupsFromPath(routePath);
-        const paths = splitPath(path);
-        return replaceGroupMarks(paths, groups);
-    };
-    var extractGroupsFromPath = (path)=>{
-        const groups = [];
-        path = path.replace(/\{[^}]+\}/g, (match, index)=>{
-            const mark = `@${index}`;
-            groups.push([
-                mark,
-                match
-            ]);
-            return mark;
-        });
-        return {
-            groups,
-            path
-        };
-    };
-    var replaceGroupMarks = (paths, groups)=>{
-        for(let i = groups.length - 1; i >= 0; i--){
-            const [mark] = groups[i];
-            for(let j = paths.length - 1; j >= 0; j--)if (paths[j].includes(mark)) {
-                paths[j] = paths[j].replace(mark, groups[i][1]);
-                break;
-            }
-        }
-        return paths;
-    };
-    var patternCache = {};
-    var getPattern = (label)=>{
-        if ("*" === label) return "*";
-        const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-        if (match) {
-            if (!patternCache[label]) if (match[2]) patternCache[label] = [
-                label,
-                match[1],
-                new RegExp("^" + match[2] + "$")
-            ];
-            else patternCache[label] = [
-                label,
-                match[1],
-                true
-            ];
-            return patternCache[label];
-        }
-        return null;
-    };
-    var tryDecodeURI = (str)=>{
-        try {
-            return decodeURI(str);
-        } catch  {
-            return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match)=>{
-                try {
-                    return decodeURI(match);
-                } catch  {
-                    return match;
-                }
-            });
-        }
-    };
-    var getPath = (request)=>{
-        const url = request.url;
-        const start = url.indexOf("/", 8);
-        let i = start;
-        for(; i < url.length; i++){
-            const charCode = url.charCodeAt(i);
-            if (37 === charCode) {
-                const queryIndex = url.indexOf("?", i);
-                const path = url.slice(start, -1 === queryIndex ? void 0 : queryIndex);
-                return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
-            }
-            if (63 === charCode) break;
-        }
-        return url.slice(start, i);
-    };
-    var getPathNoStrict = (request)=>{
-        const result = getPath(request);
-        return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
-    };
-    var mergePath = (...paths)=>{
-        let p = "";
-        let endsWithSlash = false;
-        for (let path of paths){
-            if ("/" === p[p.length - 1]) {
-                p = p.slice(0, -1);
-                endsWithSlash = true;
-            }
-            if ("/" !== path[0]) path = `/${path}`;
-            if ("/" === path && endsWithSlash) p = `${p}/`;
-            else if ("/" !== path) p = `${p}${path}`;
-            if ("/" === path && "" === p) p = "/";
-        }
-        return p;
-    };
-    var checkOptionalParameter = (path)=>{
-        if (!path.match(/\:.+\?$/)) return null;
-        const segments = path.split("/");
-        const results = [];
-        let basePath = "";
-        segments.forEach((segment)=>{
-            if ("" === segment || /\:/.test(segment)) {
-                if (/\:/.test(segment)) if (/\?/.test(segment)) {
-                    if (0 === results.length && "" === basePath) results.push("/");
-                    else results.push(basePath);
-                    const optionalSegment = segment.replace("?", "");
-                    basePath += "/" + optionalSegment;
-                    results.push(basePath);
-                } else basePath += "/" + segment;
-            } else basePath += "/" + segment;
-        });
-        return results.filter((v, i, a)=>a.indexOf(v) === i);
-    };
-    var _decodeURI = (value)=>{
-        if (!/[%+]/.test(value)) return value;
-        if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
-        return /%/.test(value) ? decodeURIComponent_(value) : value;
-    };
-    var _getQueryParam = (url, key, multiple)=>{
-        let encoded;
-        if (!multiple && key && !/[%+]/.test(key)) {
-            let keyIndex2 = url.indexOf(`?${key}`, 8);
-            if (-1 === keyIndex2) keyIndex2 = url.indexOf(`&${key}`, 8);
-            while(-1 !== keyIndex2){
-                const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-                if (61 === trailingKeyCode) {
-                    const valueIndex = keyIndex2 + key.length + 2;
-                    const endIndex = url.indexOf("&", valueIndex);
-                    return _decodeURI(url.slice(valueIndex, -1 === endIndex ? void 0 : endIndex));
-                }
-                if (38 == trailingKeyCode || isNaN(trailingKeyCode)) return "";
-                keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-            }
-            encoded = /[%+]/.test(url);
-            if (!encoded) return;
-        }
-        const results = {};
-        encoded ??= /[%+]/.test(url);
-        let keyIndex = url.indexOf("?", 8);
-        while(-1 !== keyIndex){
-            const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-            let valueIndex = url.indexOf("=", keyIndex);
-            if (valueIndex > nextKeyIndex && -1 !== nextKeyIndex) valueIndex = -1;
-            let name = url.slice(keyIndex + 1, -1 === valueIndex ? -1 === nextKeyIndex ? void 0 : nextKeyIndex : valueIndex);
-            if (encoded) name = _decodeURI(name);
-            keyIndex = nextKeyIndex;
-            if ("" === name) continue;
-            let value;
-            if (-1 === valueIndex) value = "";
-            else {
-                value = url.slice(valueIndex + 1, -1 === nextKeyIndex ? void 0 : nextKeyIndex);
-                if (encoded) value = _decodeURI(value);
-            }
-            if (multiple) {
-                if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
-                results[name].push(value);
-            } else results[name] ??= value;
-        }
-        return key ? results[key] : results;
-    };
-    var getQueryParam = _getQueryParam;
-    var getQueryParams = (url, key)=>_getQueryParam(url, key, true);
-    var decodeURIComponent_ = decodeURIComponent;
-    var HonoRequest = class {
-        raw;
-        #validatedData;
-        #matchResult;
-        routeIndex = 0;
-        path;
-        bodyCache = {};
-        constructor(request, path = "/", matchResult = [
-            []
-        ]){
-            this.raw = request;
-            this.path = path;
-            this.#matchResult = matchResult;
-            this.#validatedData = {};
-        }
-        param(key) {
-            return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
-        }
-        getDecodedParam(key) {
-            const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-            const param = this.getParamValue(paramKey);
-            return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
-        }
-        getAllDecodedParams() {
-            const decoded = {};
-            const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-            for (const key of keys){
-                const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-                if (value && "string" == typeof value) decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
-            }
-            return decoded;
-        }
-        getParamValue(paramKey) {
-            return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-        }
-        query(key) {
-            return getQueryParam(this.url, key);
-        }
-        queries(key) {
-            return getQueryParams(this.url, key);
-        }
-        header(name) {
-            if (name) return this.raw.headers.get(name.toLowerCase()) ?? void 0;
-            const headerData = {};
-            this.raw.headers.forEach((value, key)=>{
-                headerData[key] = value;
-            });
-            return headerData;
-        }
-        async parseBody(options) {
-            return this.bodyCache.parsedBody ??= await parseBody(this, options);
-        }
-        cachedBody = (key)=>{
-            const { bodyCache, raw } = this;
-            const cachedBody = bodyCache[key];
-            if (cachedBody) return cachedBody;
-            const anyCachedKey = Object.keys(bodyCache)[0];
-            if (anyCachedKey) return bodyCache[anyCachedKey].then((body)=>{
-                if ("json" === anyCachedKey) body = JSON.stringify(body);
-                return new Response(body)[key]();
-            });
-            return bodyCache[key] = raw[key]();
-        };
-        json() {
-            return this.cachedBody("json");
-        }
-        text() {
-            return this.cachedBody("text");
-        }
-        arrayBuffer() {
-            return this.cachedBody("arrayBuffer");
-        }
-        blob() {
-            return this.cachedBody("blob");
-        }
-        formData() {
-            return this.cachedBody("formData");
-        }
-        addValidatedData(target, data) {
-            this.#validatedData[target] = data;
-        }
-        valid(target) {
-            return this.#validatedData[target];
-        }
-        get url() {
-            return this.raw.url;
-        }
-        get method() {
-            return this.raw.method;
-        }
-        get matchedRoutes() {
-            return this.#matchResult[0].map(([[, route]])=>route);
-        }
-        get routePath() {
-            return this.#matchResult[0].map(([[, route]])=>route)[this.routeIndex].path;
-        }
-    };
-    var HtmlEscapedCallbackPhase = {
-        Stringify: 1,
-        BeforeStream: 2,
-        Stream: 3
-    };
-    var html_raw = (value, callbacks)=>{
-        const escapedString = new String(value);
-        escapedString.isEscaped = true;
-        escapedString.callbacks = callbacks;
-        return escapedString;
-    };
-    var resolveCallback = async (str, phase, preserveCallbacks, context, buffer)=>{
-        if ("object" == typeof str && !(str instanceof String)) {
-            if (!(str instanceof Promise)) str = str.toString();
-            if (str instanceof Promise) str = await str;
-        }
-        const callbacks = str.callbacks;
-        if (!callbacks?.length) return Promise.resolve(str);
-        if (buffer) buffer[0] += str;
-        else buffer = [
-            str
-        ];
-        const resStr = Promise.all(callbacks.map((c)=>c({
-                phase,
-                buffer,
-                context
-            }))).then((res)=>Promise.all(res.filter(Boolean).map((str2)=>resolveCallback(str2, phase, false, context, buffer))).then(()=>buffer[0]));
-        if (preserveCallbacks) return html_raw(await resStr, callbacks);
-        return resStr;
-    };
-    var TEXT_PLAIN = "text/plain; charset=UTF-8";
-    var setHeaders = (headers, map = {})=>{
-        Object.entries(map).forEach(([key, value])=>headers.set(key, value));
-        return headers;
-    };
-    var Context = class {
-        #rawRequest;
-        #req;
-        env = {};
-        #var;
-        finalized = false;
-        error;
-        #status = 200;
-        #executionCtx;
-        #headers;
-        #preparedHeaders;
-        #res;
-        #isFresh = true;
-        #layout;
-        #renderer;
-        #notFoundHandler;
-        #matchResult;
-        #path;
-        constructor(req, options){
-            this.#rawRequest = req;
-            if (options) {
-                this.#executionCtx = options.executionCtx;
-                this.env = options.env;
-                this.#notFoundHandler = options.notFoundHandler;
-                this.#path = options.path;
-                this.#matchResult = options.matchResult;
-            }
-        }
-        get req() {
-            this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-            return this.#req;
-        }
-        get event() {
-            if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
-            throw Error("This context has no FetchEvent");
-        }
-        get executionCtx() {
-            if (this.#executionCtx) return this.#executionCtx;
-            throw Error("This context has no ExecutionContext");
-        }
-        get res() {
-            this.#isFresh = false;
-            return this.#res ||= new Response("404 Not Found", {
-                status: 404
-            });
-        }
-        set res(_res) {
-            this.#isFresh = false;
-            if (this.#res && _res) try {
-                for (const [k, v] of this.#res.headers.entries())if ("content-type" !== k) if ("set-cookie" === k) {
-                    const cookies = this.#res.headers.getSetCookie();
-                    _res.headers.delete("set-cookie");
-                    for (const cookie of cookies)_res.headers.append("set-cookie", cookie);
-                } else _res.headers.set(k, v);
-            } catch (e) {
-                if (e instanceof TypeError && e.message.includes("immutable")) {
-                    this.res = new Response(_res.body, {
-                        headers: _res.headers,
-                        status: _res.status
-                    });
-                    return;
-                }
-                throw e;
-            }
-            this.#res = _res;
-            this.finalized = true;
-        }
-        render = (...args)=>{
-            this.#renderer ??= (content)=>this.html(content);
-            return this.#renderer(...args);
-        };
-        setLayout = (layout)=>this.#layout = layout;
-        getLayout = ()=>this.#layout;
-        setRenderer = (renderer)=>{
-            this.#renderer = renderer;
-        };
-        header = (name, value, options)=>{
-            if (void 0 === value) {
-                if (this.#headers) this.#headers.delete(name);
-                else if (this.#preparedHeaders) delete this.#preparedHeaders[name.toLocaleLowerCase()];
-                if (this.finalized) this.res.headers.delete(name);
-                return;
-            }
-            if (options?.append) {
-                if (!this.#headers) {
-                    this.#isFresh = false;
-                    this.#headers = new Headers(this.#preparedHeaders);
-                    this.#preparedHeaders = {};
-                }
-                this.#headers.append(name, value);
-            } else if (this.#headers) this.#headers.set(name, value);
-            else {
-                this.#preparedHeaders ??= {};
-                this.#preparedHeaders[name.toLowerCase()] = value;
-            }
-            if (this.finalized) if (options?.append) this.res.headers.append(name, value);
-            else this.res.headers.set(name, value);
-        };
-        status = (status)=>{
-            this.#isFresh = false;
-            this.#status = status;
-        };
-        set = (key, value)=>{
-            this.#var ??= /* @__PURE__ */ new Map();
-            this.#var.set(key, value);
-        };
-        get = (key)=>this.#var ? this.#var.get(key) : void 0;
-        get var() {
-            if (!this.#var) return {};
-            return Object.fromEntries(this.#var);
-        }
-        newResponse = (data, arg, headers)=>{
-            if (this.#isFresh && !headers && !arg && 200 === this.#status) return new Response(data, {
-                headers: this.#preparedHeaders
-            });
-            if (arg && "number" != typeof arg) {
-                const header = new Headers(arg.headers);
-                if (this.#headers) this.#headers.forEach((v, k)=>{
-                    if ("set-cookie" === k) header.append(k, v);
-                    else header.set(k, v);
-                });
-                const headers2 = setHeaders(header, this.#preparedHeaders);
-                return new Response(data, {
-                    headers: headers2,
-                    status: arg.status ?? this.#status
-                });
-            }
-            const status = "number" == typeof arg ? arg : this.#status;
-            this.#preparedHeaders ??= {};
-            this.#headers ??= new Headers();
-            setHeaders(this.#headers, this.#preparedHeaders);
-            if (this.#res) {
-                this.#res.headers.forEach((v, k)=>{
-                    if ("set-cookie" === k) this.#headers?.append(k, v);
-                    else this.#headers?.set(k, v);
-                });
-                setHeaders(this.#headers, this.#preparedHeaders);
-            }
-            headers ??= {};
-            for (const [k, v] of Object.entries(headers))if ("string" == typeof v) this.#headers.set(k, v);
-            else {
-                this.#headers.delete(k);
-                for (const v2 of v)this.#headers.append(k, v2);
-            }
-            return new Response(data, {
-                status,
-                headers: this.#headers
-            });
-        };
-        body = (data, arg, headers)=>"number" == typeof arg ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
-        text = (text, arg, headers)=>{
-            if (!this.#preparedHeaders) {
-                if (this.#isFresh && !headers && !arg) return new Response(text);
-                this.#preparedHeaders = {};
-            }
-            this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-            return "number" == typeof arg ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
-        };
-        json = (object, arg, headers)=>{
-            const body = JSON.stringify(object);
-            this.#preparedHeaders ??= {};
-            this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
-            return "number" == typeof arg ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
-        };
-        html = (html, arg, headers)=>{
-            this.#preparedHeaders ??= {};
-            this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
-            if ("object" == typeof html) return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2)=>"number" == typeof arg ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg));
-            return "number" == typeof arg ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
-        };
-        redirect = (location, status)=>{
-            this.#headers ??= new Headers();
-            this.#headers.set("Location", location);
-            return this.newResponse(null, status ?? 302);
-        };
-        notFound = ()=>{
-            this.#notFoundHandler ??= ()=>new Response();
-            return this.#notFoundHandler(this);
-        };
-    };
-    var compose = (middleware, onError, onNotFound)=>(context, next)=>{
-            let index = -1;
-            return dispatch(0);
-            async function dispatch(i) {
-                if (i <= index) throw new Error("next() called multiple times");
-                index = i;
-                let res;
-                let isError = false;
-                let handler;
-                if (middleware[i]) {
-                    handler = middleware[i][0][0];
-                    if (context instanceof Context) context.req.routeIndex = i;
-                } else handler = i === middleware.length && next || void 0;
-                if (handler) try {
-                    res = await handler(context, ()=>dispatch(i + 1));
-                } catch (err) {
-                    if (err instanceof Error && context instanceof Context && onError) {
-                        context.error = err;
-                        res = await onError(err, context);
-                        isError = true;
-                    } else throw err;
-                }
-                else if (context instanceof Context && false === context.finalized && onNotFound) res = await onNotFound(context);
-                if (res && (false === context.finalized || isError)) context.res = res;
-                return context;
-            }
-        };
-    var METHOD_NAME_ALL = "ALL";
-    var METHOD_NAME_ALL_LOWERCASE = "all";
-    var METHODS = [
-        "get",
-        "post",
-        "put",
-        "delete",
-        "options",
-        "patch"
-    ];
-    var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-    var UnsupportedPathError = class extends Error {
-    };
-    var COMPOSED_HANDLER = Symbol("composedHandler");
-    var notFoundHandler = (c)=>c.text("404 Not Found", 404);
-    var errorHandler = (err, c)=>{
-        if ("getResponse" in err) return err.getResponse();
-        console.error(err);
-        return c.text("Internal Server Error", 500);
-    };
-    var Hono = class {
-        get;
-        post;
-        put;
-        delete;
-        options;
-        patch;
-        all;
-        on;
-        use;
-        router;
-        getPath;
-        _basePath = "/";
-        #path = "/";
-        routes = [];
-        constructor(options = {}){
-            const allMethods = [
-                ...METHODS,
-                METHOD_NAME_ALL_LOWERCASE
-            ];
-            allMethods.forEach((method)=>{
-                this[method] = (args1, ...args)=>{
-                    if ("string" == typeof args1) this.#path = args1;
-                    else this.addRoute(method, this.#path, args1);
-                    args.forEach((handler)=>{
-                        if ("string" != typeof handler) this.addRoute(method, this.#path, handler);
-                    });
-                    return this;
-                };
-            });
-            this.on = (method, path, ...handlers)=>{
-                for (const p of [
-                    path
-                ].flat()){
-                    this.#path = p;
-                    for (const m of [
-                        method
-                    ].flat())handlers.map((handler)=>{
-                        this.addRoute(m.toUpperCase(), this.#path, handler);
-                    });
-                }
-                return this;
-            };
-            this.use = (arg1, ...handlers)=>{
-                if ("string" == typeof arg1) this.#path = arg1;
-                else {
-                    this.#path = "*";
-                    handlers.unshift(arg1);
-                }
-                handlers.forEach((handler)=>{
-                    this.addRoute(METHOD_NAME_ALL, this.#path, handler);
-                });
-                return this;
-            };
-            const strict = options.strict ?? true;
-            delete options.strict;
-            Object.assign(this, options);
-            this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
-        }
-        clone() {
-            const clone = new Hono({
-                router: this.router,
-                getPath: this.getPath
-            });
-            clone.routes = this.routes;
-            return clone;
-        }
-        notFoundHandler = notFoundHandler;
-        errorHandler = errorHandler;
-        route(path, app) {
-            const subApp = this.basePath(path);
-            app.routes.map((r)=>{
-                let handler;
-                if (app.errorHandler === errorHandler) handler = r.handler;
-                else {
-                    handler = async (c, next)=>(await compose([], app.errorHandler)(c, ()=>r.handler(c, next))).res;
-                    handler[COMPOSED_HANDLER] = r.handler;
-                }
-                subApp.addRoute(r.method, r.path, handler);
-            });
-            return this;
-        }
-        basePath(path) {
-            const subApp = this.clone();
-            subApp._basePath = mergePath(this._basePath, path);
-            return subApp;
-        }
-        onError = (handler)=>{
-            this.errorHandler = handler;
-            return this;
-        };
-        notFound = (handler)=>{
-            this.notFoundHandler = handler;
-            return this;
-        };
-        mount(path, applicationHandler, options) {
-            let replaceRequest;
-            let optionHandler;
-            if (options) if ("function" == typeof options) optionHandler = options;
-            else {
-                optionHandler = options.optionHandler;
-                replaceRequest = options.replaceRequest;
-            }
-            const getOptions = optionHandler ? (c)=>{
-                const options2 = optionHandler(c);
-                return Array.isArray(options2) ? options2 : [
-                    options2
-                ];
-            } : (c)=>{
-                let executionContext;
-                try {
-                    executionContext = c.executionCtx;
-                } catch  {}
-                return [
-                    c.env,
-                    executionContext
-                ];
-            };
-            replaceRequest ||= (()=>{
-                const mergedPath = mergePath(this._basePath, path);
-                const pathPrefixLength = "/" === mergedPath ? 0 : mergedPath.length;
-                return (request)=>{
-                    const url = new URL(request.url);
-                    url.pathname = url.pathname.slice(pathPrefixLength) || "/";
-                    return new Request(url, request);
-                };
-            })();
-            const handler = async (c, next)=>{
-                const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-                if (res) return res;
-                await next();
-            };
-            this.addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
-            return this;
-        }
-        addRoute(method, path, handler) {
-            method = method.toUpperCase();
-            path = mergePath(this._basePath, path);
-            const r = {
-                path,
-                method,
-                handler
-            };
-            this.router.add(method, path, [
-                handler,
-                r
-            ]);
-            this.routes.push(r);
-        }
-        matchRoute(method, path) {
-            return this.router.match(method, path);
-        }
-        handleError(err, c) {
-            if (err instanceof Error) return this.errorHandler(err, c);
-            throw err;
-        }
-        dispatch(request, executionCtx, env, method) {
-            if ("HEAD" === method) return (async ()=>new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
-            const path = this.getPath(request, {
-                env
-            });
-            const matchResult = this.matchRoute(method, path);
-            const c = new Context(request, {
-                path,
-                matchResult,
-                env,
-                executionCtx,
-                notFoundHandler: this.notFoundHandler
-            });
-            if (1 === matchResult[0].length) {
-                let res;
-                try {
-                    res = matchResult[0][0][0][0](c, async ()=>{
-                        c.res = await this.notFoundHandler(c);
-                    });
-                } catch (err) {
-                    return this.handleError(err, c);
-                }
-                return res instanceof Promise ? res.then((resolved)=>resolved || (c.finalized ? c.res : this.notFoundHandler(c))).catch((err)=>this.handleError(err, c)) : res ?? this.notFoundHandler(c);
-            }
-            const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
-            return (async ()=>{
-                try {
-                    const context = await composed(c);
-                    if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
-                    return context.res;
-                } catch (err) {
-                    return this.handleError(err, c);
-                }
-            })();
-        }
-        fetch = (request, ...rest)=>this.dispatch(request, rest[1], rest[0], request.method);
-        request = (input, requestInit, Env, executionCtx)=>{
-            if (input instanceof Request) {
-                if (void 0 !== requestInit) input = new Request(input, requestInit);
-                return this.fetch(input, Env, executionCtx);
-            }
-            input = input.toString();
-            const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-            const req = new Request(path, requestInit);
-            return this.fetch(req, Env, executionCtx);
-        };
-        fire = ()=>{
-            addEventListener("fetch", (event)=>{
-                event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
-            });
-        };
-    };
-    var LABEL_REG_EXP_STR = "[^/]+";
-    var ONLY_WILDCARD_REG_EXP_STR = ".*";
-    var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-    var PATH_ERROR = Symbol();
-    var regExpMetaChars = new Set(".\\+*[^]$()");
-    function compareKey(a, b) {
-        if (1 === a.length) return 1 === b.length ? a < b ? -1 : 1 : -1;
-        if (1 === b.length) return 1;
-        if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) return 1;
-        if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) return -1;
-        if (a === LABEL_REG_EXP_STR) return 1;
-        if (b === LABEL_REG_EXP_STR) return -1;
-        return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-    }
-    var Node = class {
-        index;
-        varIndex;
-        children = /* @__PURE__ */ Object.create(null);
-        insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-            if (0 === tokens.length) {
-                if (void 0 !== this.index) throw PATH_ERROR;
-                if (pathErrorCheckOnly) return;
-                this.index = index;
-                return;
-            }
-            const [token, ...restTokens] = tokens;
-            const pattern = "*" === token ? 0 === restTokens.length ? [
-                "",
-                "",
-                ONLY_WILDCARD_REG_EXP_STR
-            ] : [
-                "",
-                "",
-                LABEL_REG_EXP_STR
-            ] : "/*" === token ? [
-                "",
-                "",
-                TAIL_WILDCARD_REG_EXP_STR
-            ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-            let node;
-            if (pattern) {
-                const name = pattern[1];
-                let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-                if (name && pattern[2]) {
-                    regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-                    if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
-                }
-                node = this.children[regexpStr];
-                if (!node) {
-                    if (Object.keys(this.children).some((k)=>k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
-                    if (pathErrorCheckOnly) return;
-                    node = this.children[regexpStr] = new Node();
-                    if ("" !== name) node.varIndex = context.varIndex++;
-                }
-                if (!pathErrorCheckOnly && "" !== name) paramMap.push([
-                    name,
-                    node.varIndex
-                ]);
-            } else {
-                node = this.children[token];
-                if (!node) {
-                    if (Object.keys(this.children).some((k)=>k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
-                    if (pathErrorCheckOnly) return;
-                    node = this.children[token] = new Node();
-                }
-            }
-            node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-        }
-        buildRegExpStr() {
-            const childKeys = Object.keys(this.children).sort(compareKey);
-            const strList = childKeys.map((k)=>{
-                const c = this.children[k];
-                return ("number" == typeof c.varIndex ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-            });
-            if ("number" == typeof this.index) strList.unshift(`#${this.index}`);
-            if (0 === strList.length) return "";
-            if (1 === strList.length) return strList[0];
-            return "(?:" + strList.join("|") + ")";
-        }
-    };
-    var Trie = class {
-        context = {
-            varIndex: 0
-        };
-        root = new Node();
-        insert(path, index, pathErrorCheckOnly) {
-            const paramAssoc = [];
-            const groups = [];
-            for(let i = 0;;){
-                let replaced = false;
-                path = path.replace(/\{[^}]+\}/g, (m)=>{
-                    const mark = `@\\${i}`;
-                    groups[i] = [
-                        mark,
-                        m
-                    ];
-                    i++;
-                    replaced = true;
-                    return mark;
-                });
-                if (!replaced) break;
-            }
-            const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-            for(let i = groups.length - 1; i >= 0; i--){
-                const [mark] = groups[i];
-                for(let j = tokens.length - 1; j >= 0; j--)if (-1 !== tokens[j].indexOf(mark)) {
-                    tokens[j] = tokens[j].replace(mark, groups[i][1]);
-                    break;
-                }
-            }
-            this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
-            return paramAssoc;
-        }
-        buildRegExp() {
-            let regexp = this.root.buildRegExpStr();
-            if ("" === regexp) return [
-                /^$/,
-                [],
-                []
-            ];
-            let captureIndex = 0;
-            const indexReplacementMap = [];
-            const paramReplacementMap = [];
-            regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex)=>{
-                if (void 0 !== handlerIndex) {
-                    indexReplacementMap[++captureIndex] = Number(handlerIndex);
-                    return "$()";
-                }
-                if (void 0 !== paramIndex) paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-                return "";
-            });
-            return [
-                new RegExp(`^${regexp}`),
-                indexReplacementMap,
-                paramReplacementMap
-            ];
-        }
-    };
-    var emptyParam = [];
-    var nullMatcher = [
-        /^$/,
-        [],
-        /* @__PURE__ */ Object.create(null)
-    ];
-    var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-    function buildWildcardRegExp(path) {
-        return wildcardRegExpCache[path] ??= new RegExp("*" === path ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar)=>metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
-    }
-    function clearWildcardRegExpCache() {
-        wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-    }
-    function buildMatcherFromPreprocessedRoutes(routes) {
-        const trie = new Trie();
-        const handlerData = [];
-        if (0 === routes.length) return nullMatcher;
-        const routesWithStaticPathFlag = routes.map((route)=>[
-                !/\*|\/:/.test(route[0]),
-                ...route
-            ]).sort(([isStaticA, pathA], [isStaticB, pathB])=>isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
-        const staticMap = /* @__PURE__ */ Object.create(null);
-        for(let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++){
-            const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-            if (pathErrorCheckOnly) staticMap[path] = [
-                handlers.map(([h])=>[
-                        h,
-                        /* @__PURE__ */ Object.create(null)
-                    ]),
-                emptyParam
-            ];
-            else j++;
-            let paramAssoc;
-            try {
-                paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-            } catch (e) {
-                throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-            }
-            if (!pathErrorCheckOnly) handlerData[j] = handlers.map(([h, paramCount])=>{
-                const paramIndexMap = /* @__PURE__ */ Object.create(null);
-                paramCount -= 1;
-                for(; paramCount >= 0; paramCount--){
-                    const [key, value] = paramAssoc[paramCount];
-                    paramIndexMap[key] = value;
-                }
-                return [
-                    h,
-                    paramIndexMap
-                ];
-            });
-        }
-        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-        for(let i = 0, len = handlerData.length; i < len; i++)for(let j = 0, len2 = handlerData[i].length; j < len2; j++){
-            const map = handlerData[i][j]?.[1];
-            if (!map) continue;
-            const keys = Object.keys(map);
-            for(let k = 0, len3 = keys.length; k < len3; k++)map[keys[k]] = paramReplacementMap[map[keys[k]]];
-        }
-        const handlerMap = [];
-        for(const i in indexReplacementMap)handlerMap[i] = handlerData[indexReplacementMap[i]];
-        return [
-            regexp,
-            handlerMap,
-            staticMap
-        ];
-    }
-    function findMiddleware(middleware, path) {
-        if (!middleware) return;
-        for (const k of Object.keys(middleware).sort((a, b)=>b.length - a.length))if (buildWildcardRegExp(k).test(path)) return [
-            ...middleware[k]
-        ];
-    }
-    var RegExpRouter = class {
-        name = "RegExpRouter";
-        middleware;
-        routes;
-        constructor(){
-            this.middleware = {
-                [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
-            };
-            this.routes = {
-                [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
-            };
-        }
-        add(method, path, handler) {
-            const { middleware, routes } = this;
-            if (!middleware || !routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-            if (!middleware[method]) [
-                middleware,
-                routes
-            ].forEach((handlerMap)=>{
-                handlerMap[method] = /* @__PURE__ */ Object.create(null);
-                Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p)=>{
-                    handlerMap[method][p] = [
-                        ...handlerMap[METHOD_NAME_ALL][p]
-                    ];
-                });
-            });
-            if ("/*" === path) path = "*";
-            const paramCount = (path.match(/\/:/g) || []).length;
-            if (/\*$/.test(path)) {
-                const re = buildWildcardRegExp(path);
-                if (method === METHOD_NAME_ALL) Object.keys(middleware).forEach((m)=>{
-                    middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-                });
-                else middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-                Object.keys(middleware).forEach((m)=>{
-                    if (method === METHOD_NAME_ALL || method === m) Object.keys(middleware[m]).forEach((p)=>{
-                        re.test(p) && middleware[m][p].push([
-                            handler,
-                            paramCount
-                        ]);
-                    });
-                });
-                Object.keys(routes).forEach((m)=>{
-                    if (method === METHOD_NAME_ALL || method === m) Object.keys(routes[m]).forEach((p)=>re.test(p) && routes[m][p].push([
-                            handler,
-                            paramCount
-                        ]));
-                });
-                return;
-            }
-            const paths = checkOptionalParameter(path) || [
-                path
-            ];
-            for(let i = 0, len = paths.length; i < len; i++){
-                const path2 = paths[i];
-                Object.keys(routes).forEach((m)=>{
-                    if (method === METHOD_NAME_ALL || method === m) {
-                        routes[m][path2] ||= [
-                            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-                        ];
-                        routes[m][path2].push([
-                            handler,
-                            paramCount - len + i + 1
-                        ]);
-                    }
-                });
-            }
-        }
-        match(method, path) {
-            clearWildcardRegExpCache();
-            const matchers = this.buildAllMatchers();
-            this.match = (method2, path2)=>{
-                const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-                const staticMatch = matcher[2][path2];
-                if (staticMatch) return staticMatch;
-                const match = path2.match(matcher[0]);
-                if (!match) return [
-                    [],
-                    emptyParam
-                ];
-                const index = match.indexOf("", 1);
-                return [
-                    matcher[1][index],
-                    match
-                ];
-            };
-            return this.match(method, path);
-        }
-        buildAllMatchers() {
-            const matchers = /* @__PURE__ */ Object.create(null);
-            [
-                ...Object.keys(this.routes),
-                ...Object.keys(this.middleware)
-            ].forEach((method)=>{
-                matchers[method] ||= this.buildMatcher(method);
-            });
-            this.middleware = this.routes = void 0;
-            return matchers;
-        }
-        buildMatcher(method) {
-            const routes = [];
-            let hasOwnRoute = method === METHOD_NAME_ALL;
-            [
-                this.middleware,
-                this.routes
-            ].forEach((r)=>{
-                const ownRoute = r[method] ? Object.keys(r[method]).map((path)=>[
-                        path,
-                        r[method][path]
-                    ]) : [];
-                if (0 !== ownRoute.length) {
-                    hasOwnRoute ||= true;
-                    routes.push(...ownRoute);
-                } else if (method !== METHOD_NAME_ALL) routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path)=>[
-                        path,
-                        r[METHOD_NAME_ALL][path]
-                    ]));
-            });
-            if (!hasOwnRoute) return null;
-            return buildMatcherFromPreprocessedRoutes(routes);
-        }
-    };
-    var SmartRouter = class {
-        name = "SmartRouter";
-        routers = [];
-        routes = [];
-        constructor(init){
-            Object.assign(this, init);
-        }
-        add(method, path, handler) {
-            if (!this.routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-            this.routes.push([
-                method,
-                path,
-                handler
-            ]);
-        }
-        match(method, path) {
-            if (!this.routes) throw new Error("Fatal error");
-            const { routers, routes } = this;
-            const len = routers.length;
-            let i = 0;
-            let res;
-            for(; i < len; i++){
-                const router = routers[i];
-                try {
-                    routes.forEach((args)=>{
-                        router.add(...args);
-                    });
-                    res = router.match(method, path);
-                } catch (e) {
-                    if (e instanceof UnsupportedPathError) continue;
-                    throw e;
-                }
-                this.match = router.match.bind(router);
-                this.routers = [
-                    router
-                ];
-                this.routes = void 0;
-                break;
-            }
-            if (i === len) throw new Error("Fatal error");
-            this.name = `SmartRouter + ${this.activeRouter.name}`;
-            return res;
-        }
-        get activeRouter() {
-            if (this.routes || 1 !== this.routers.length) throw new Error("No active router has been determined yet.");
-            return this.routers[0];
-        }
-    };
-    var node_Node = class {
-        methods;
-        children;
-        patterns;
-        order = 0;
-        name;
-        params = /* @__PURE__ */ Object.create(null);
-        constructor(method, handler, children){
-            this.children = children || /* @__PURE__ */ Object.create(null);
-            this.methods = [];
-            this.name = "";
-            if (method && handler) {
-                const m = /* @__PURE__ */ Object.create(null);
-                m[method] = {
-                    handler,
-                    possibleKeys: [],
-                    score: 0,
-                    name: this.name
-                };
-                this.methods = [
-                    m
-                ];
-            }
-            this.patterns = [];
-        }
-        insert(method, path, handler) {
-            this.name = `${method} ${path}`;
-            this.order = ++this.order;
-            let curNode = this;
-            const parts = splitRoutingPath(path);
-            const possibleKeys = [];
-            for(let i = 0, len = parts.length; i < len; i++){
-                const p = parts[i];
-                if (Object.keys(curNode.children).includes(p)) {
-                    curNode = curNode.children[p];
-                    const pattern2 = getPattern(p);
-                    if (pattern2) possibleKeys.push(pattern2[1]);
-                    continue;
-                }
-                curNode.children[p] = new node_Node();
-                const pattern = getPattern(p);
-                if (pattern) {
-                    curNode.patterns.push(pattern);
-                    possibleKeys.push(pattern[1]);
-                }
-                curNode = curNode.children[p];
-            }
-            if (!curNode.methods.length) curNode.methods = [];
-            const m = /* @__PURE__ */ Object.create(null);
-            const handlerSet = {
-                handler,
-                possibleKeys: possibleKeys.filter((v, i, a)=>a.indexOf(v) === i),
-                name: this.name,
-                score: this.order
-            };
-            m[method] = handlerSet;
-            curNode.methods.push(m);
-            return curNode;
-        }
-        gHSets(node, method, nodeParams, params) {
-            const handlerSets = [];
-            for(let i = 0, len = node.methods.length; i < len; i++){
-                const m = node.methods[i];
-                const handlerSet = m[method] || m[METHOD_NAME_ALL];
-                const processedSet = /* @__PURE__ */ Object.create(null);
-                if (void 0 !== handlerSet) {
-                    handlerSet.params = /* @__PURE__ */ Object.create(null);
-                    handlerSet.possibleKeys.forEach((key)=>{
-                        const processed = processedSet[handlerSet.name];
-                        handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
-                        processedSet[handlerSet.name] = true;
-                    });
-                    handlerSets.push(handlerSet);
-                }
-            }
-            return handlerSets;
-        }
-        search(method, path) {
-            const handlerSets = [];
-            this.params = /* @__PURE__ */ Object.create(null);
-            const curNode = this;
-            let curNodes = [
-                curNode
-            ];
-            const parts = splitPath(path);
-            for(let i = 0, len = parts.length; i < len; i++){
-                const part = parts[i];
-                const isLast = i === len - 1;
-                const tempNodes = [];
-                for(let j = 0, len2 = curNodes.length; j < len2; j++){
-                    const node = curNodes[j];
-                    const nextNode = node.children[part];
-                    if (nextNode) {
-                        nextNode.params = node.params;
-                        if (true === isLast) {
-                            if (nextNode.children["*"]) handlerSets.push(...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null)));
-                            handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
-                        } else tempNodes.push(nextNode);
-                    }
-                    for(let k = 0, len3 = node.patterns.length; k < len3; k++){
-                        const pattern = node.patterns[k];
-                        const params = {
-                            ...node.params
-                        };
-                        if ("*" === pattern) {
-                            const astNode = node.children["*"];
-                            if (astNode) {
-                                handlerSets.push(...this.gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
-                                tempNodes.push(astNode);
-                            }
-                            continue;
-                        }
-                        if ("" === part) continue;
-                        const [key, name, matcher] = pattern;
-                        const child = node.children[key];
-                        const restPathString = parts.slice(i).join("/");
-                        if (matcher instanceof RegExp && matcher.test(restPathString)) {
-                            params[name] = restPathString;
-                            handlerSets.push(...this.gHSets(child, method, node.params, params));
-                            continue;
-                        }
-                        if (true === matcher || matcher instanceof RegExp && matcher.test(part)) {
-                            if ("string" == typeof key) {
-                                params[name] = part;
-                                if (true === isLast) {
-                                    handlerSets.push(...this.gHSets(child, method, params, node.params));
-                                    if (child.children["*"]) handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
-                                } else {
-                                    child.params = params;
-                                    tempNodes.push(child);
-                                }
-                            }
-                        }
-                    }
-                }
-                curNodes = tempNodes;
-            }
-            const results = handlerSets.sort((a, b)=>a.score - b.score);
-            return [
-                results.map(({ handler, params })=>[
-                        handler,
-                        params
-                    ])
-            ];
-        }
-    };
-    var TrieRouter = class {
-        name = "TrieRouter";
-        node;
-        constructor(){
-            this.node = new node_Node();
-        }
-        add(method, path, handler) {
-            const results = checkOptionalParameter(path);
-            if (results) {
-                for (const p of results)this.node.insert(method, p, handler);
-                return;
-            }
-            this.node.insert(method, path, handler);
-        }
-        match(method, path) {
-            return this.node.search(method, path);
-        }
-    };
-    var hono_Hono = class extends Hono {
-        constructor(options = {}){
-            super(options);
-            this.router = options.router ?? new SmartRouter({
-                routers: [
-                    new RegExpRouter(),
-                    new TrieRouter()
-                ]
-            });
-        }
-    };
-    var _validateReport = __webpack_require__("../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.8.3/node_modules/typia/lib/internal/_validateReport.js");
-    var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-    var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-    var parse = (cookie, name)=>{
-        const pairs = cookie.trim().split(";");
-        return pairs.reduce((parsedCookie, pairStr)=>{
-            pairStr = pairStr.trim();
-            const valueStartPos = pairStr.indexOf("=");
-            if (-1 === valueStartPos) return parsedCookie;
-            const cookieName = pairStr.substring(0, valueStartPos).trim();
-            if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) return parsedCookie;
-            let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-            if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) cookieValue = cookieValue.slice(1, -1);
-            if (validCookieValueRegEx.test(cookieValue)) parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
-            return parsedCookie;
-        }, {});
-    };
-    var getCookie = (c, key, prefix)=>{
-        const cookie = c.req.raw.headers.get("Cookie");
-        if ("string" == typeof key) {
-            if (!cookie) return;
-            let finalKey = key;
-            if ("secure" === prefix) finalKey = "__Secure-" + key;
-            else if ("host" === prefix) finalKey = "__Host-" + key;
-            const obj2 = parse(cookie, finalKey);
-            return obj2[finalKey];
-        }
-        if (!cookie) return {};
-        const obj = parse(cookie);
-        return obj;
-    };
-    var HTTPException = class extends Error {
-        res;
-        status;
-        constructor(status = 500, options){
-            super(options?.message, {
-                cause: options?.cause
-            });
-            this.res = options?.res;
-            this.status = status;
-        }
-        getResponse() {
-            if (this.res) {
-                const newResponse = new Response(this.res.body, {
-                    status: this.status,
-                    headers: this.res.headers
-                });
-                return newResponse;
-            }
-            return new Response(this.message, {
-                status: this.status
-            });
-        }
-    };
-    var bufferToFormData = (arrayBuffer, contentType)=>{
-        const response = new Response(arrayBuffer, {
-            headers: {
-                "Content-Type": contentType
-            }
-        });
-        return response.formData();
-    };
-    var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-    var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
-    var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-    var validator = (target, validationFunc)=>async (c, next)=>{
-            let value = {};
-            const contentType = c.req.header("Content-Type");
-            switch(target){
-                case "json":
-                    if (!contentType || !jsonRegex.test(contentType)) break;
-                    try {
-                        value = await c.req.json();
-                    } catch  {
-                        const message = "Malformed JSON in request body";
-                        throw new HTTPException(400, {
-                            message
-                        });
-                    }
-                    break;
-                case "form":
-                    {
-                        if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) break;
-                        let formData;
-                        if (c.req.bodyCache.formData) formData = await c.req.bodyCache.formData;
-                        else try {
-                            const arrayBuffer = await c.req.arrayBuffer();
-                            formData = await bufferToFormData(arrayBuffer, contentType);
-                            c.req.bodyCache.formData = formData;
-                        } catch (e) {
-                            let message = "Malformed FormData request.";
-                            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-                            throw new HTTPException(400, {
-                                message
-                            });
-                        }
-                        const form = {};
-                        formData.forEach((value2, key)=>{
-                            if (key.endsWith("[]")) (form[key] ??= []).push(value2);
-                            else if (Array.isArray(form[key])) form[key].push(value2);
-                            else if (key in form) form[key] = [
-                                form[key],
-                                value2
-                            ];
-                            else form[key] = value2;
-                        });
-                        value = form;
-                        break;
-                    }
-                case "query":
-                    value = Object.fromEntries(Object.entries(c.req.queries()).map(([k, v])=>1 === v.length ? [
-                            k,
-                            v[0]
-                        ] : [
-                            k,
-                            v
-                        ]));
-                    break;
-                case "param":
-                    value = c.req.param();
-                    break;
-                case "header":
-                    value = c.req.header();
-                    break;
-                case "cookie":
-                    value = getCookie(c);
-                    break;
-            }
-            const res = await validationFunc(value, c);
-            if (res instanceof Response) return res;
-            c.req.addValidatedData(target, res);
-            await next();
-        };
-    const typiaValidator = (target, validate, hook)=>validator(target, async (value, c)=>{
-            const result = validate(value);
-            if (hook) {
-                const hookResult = await hook({
-                    ...result,
-                    data: value
-                }, c);
-                if (hookResult) {
-                    if (hookResult instanceof Response || hookResult instanceof Promise) return hookResult;
-                    if ('response' in hookResult) return hookResult.response;
-                }
-            }
-            if (!result.success) return c.json({
-                success: false,
-                error: result.errors
-            }, 400);
-            return result.data;
-        });
-    const plugin_core_namespaceObject = require("@hot-updater/plugin-core");
-    const queryBundlesSchema = (()=>{
-        const _io0 = (input)=>(void 0 === input.channel || "string" == typeof input.channel) && (void 0 === input.platform || "ios" === input.platform || "android" === input.platform) && (void 0 === input.limit || "string" == typeof input.limit) && (void 0 === input.offset || "string" == typeof input.offset);
-        const _vo0 = (input, _path, _exceptionable = true)=>[
-                void 0 === input.channel || "string" == typeof input.channel || _report(_exceptionable, {
-                    path: _path + ".channel",
-                    expected: "(string | undefined)",
-                    value: input.channel
-                }),
-                void 0 === input.platform || "ios" === input.platform || "android" === input.platform || _report(_exceptionable, {
-                    path: _path + ".platform",
-                    expected: "(\"android\" | \"ios\" | undefined)",
-                    value: input.platform
-                }),
-                void 0 === input.limit || "string" == typeof input.limit || _report(_exceptionable, {
-                    path: _path + ".limit",
-                    expected: "(string | undefined)",
-                    value: input.limit
-                }),
-                void 0 === input.offset || "string" == typeof input.offset || _report(_exceptionable, {
-                    path: _path + ".offset",
-                    expected: "(string | undefined)",
-                    value: input.offset
-                })
-            ].every((flag)=>flag);
-        const __is = (input)=>"object" == typeof input && null !== input && false === Array.isArray(input) && _io0(input);
-        let errors;
-        let _report;
-        return (input)=>{
-            if (false === __is(input)) {
-                errors = [];
-                _report = _validateReport._validateReport(errors);
-                ((input, _path, _exceptionable = true)=>("object" == typeof input && null !== input && false === Array.isArray(input) || _report(true, {
-                        path: _path + "",
-                        expected: "__type",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "__type",
-                        value: input
-                    }))(input, "$input", true);
-                const success = 0 === errors.length;
-                return success ? {
-                    success,
-                    data: input
-                } : {
-                    success,
-                    errors,
-                    data: input
-                };
-            }
-            return {
-                success: true,
-                data: input
-            };
-        };
-    })();
-    const paramBundleIdSchema = (()=>{
-        const _io0 = (input)=>"string" == typeof input.bundleId;
-        const _vo0 = (input, _path, _exceptionable = true)=>[
-                "string" == typeof input.bundleId || _report(_exceptionable, {
-                    path: _path + ".bundleId",
-                    expected: "string",
-                    value: input.bundleId
-                })
-            ].every((flag)=>flag);
-        const __is = (input)=>"object" == typeof input && null !== input && _io0(input);
-        let errors;
-        let _report;
-        return (input)=>{
-            if (false === __is(input)) {
-                errors = [];
-                _report = _validateReport._validateReport(errors);
-                ((input, _path, _exceptionable = true)=>("object" == typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "__type",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "__type",
-                        value: input
-                    }))(input, "$input", true);
-                const success = 0 === errors.length;
-                return success ? {
-                    success,
-                    data: input
-                } : {
-                    success,
-                    errors,
-                    data: input
-                };
-            }
-            return {
-                success: true,
-                data: input
-            };
-        };
-    })();
-    const updateBundleSchema = (()=>{
-        const _io0 = (input)=>(void 0 === input.id || "string" == typeof input.id) && (void 0 === input.platform || "ios" === input.platform || "android" === input.platform) && (void 0 === input.targetAppVersion || "string" == typeof input.targetAppVersion) && (void 0 === input.shouldForceUpdate || "boolean" == typeof input.shouldForceUpdate) && (void 0 === input.enabled || "boolean" == typeof input.enabled) && (void 0 === input.fileHash || "string" == typeof input.fileHash) && (null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" == typeof input.gitCommitHash) && (null === input.message || void 0 === input.message || "string" == typeof input.message) && (void 0 === input.channel || "string" == typeof input.channel);
-        const _vo0 = (input, _path, _exceptionable = true)=>[
-                void 0 === input.id || "string" == typeof input.id || _report(_exceptionable, {
-                    path: _path + ".id",
-                    expected: "(string | undefined)",
-                    value: input.id
-                }),
-                void 0 === input.platform || "ios" === input.platform || "android" === input.platform || _report(_exceptionable, {
-                    path: _path + ".platform",
-                    expected: "(\"android\" | \"ios\" | undefined)",
-                    value: input.platform
-                }),
-                void 0 === input.targetAppVersion || "string" == typeof input.targetAppVersion || _report(_exceptionable, {
-                    path: _path + ".targetAppVersion",
-                    expected: "(string | undefined)",
-                    value: input.targetAppVersion
-                }),
-                void 0 === input.shouldForceUpdate || "boolean" == typeof input.shouldForceUpdate || _report(_exceptionable, {
-                    path: _path + ".shouldForceUpdate",
-                    expected: "(boolean | undefined)",
-                    value: input.shouldForceUpdate
-                }),
-                void 0 === input.enabled || "boolean" == typeof input.enabled || _report(_exceptionable, {
-                    path: _path + ".enabled",
-                    expected: "(boolean | undefined)",
-                    value: input.enabled
-                }),
-                void 0 === input.fileHash || "string" == typeof input.fileHash || _report(_exceptionable, {
-                    path: _path + ".fileHash",
-                    expected: "(string | undefined)",
-                    value: input.fileHash
-                }),
-                null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" == typeof input.gitCommitHash || _report(_exceptionable, {
-                    path: _path + ".gitCommitHash",
-                    expected: "(null | string | undefined)",
-                    value: input.gitCommitHash
-                }),
-                null === input.message || void 0 === input.message || "string" == typeof input.message || _report(_exceptionable, {
-                    path: _path + ".message",
-                    expected: "(null | string | undefined)",
-                    value: input.message
-                }),
-                void 0 === input.channel || "string" == typeof input.channel || _report(_exceptionable, {
-                    path: _path + ".channel",
-                    expected: "(string | undefined)",
-                    value: input.channel
-                })
-            ].every((flag)=>flag);
-        const __is = (input)=>"object" == typeof input && null !== input && false === Array.isArray(input) && _io0(input);
-        let errors;
-        let _report;
-        return (input)=>{
-            if (false === __is(input)) {
-                errors = [];
-                _report = _validateReport._validateReport(errors);
-                ((input, _path, _exceptionable = true)=>("object" == typeof input && null !== input && false === Array.isArray(input) || _report(true, {
-                        path: _path + "",
-                        expected: "Partial<Bundle>",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "Partial<Bundle>",
-                        value: input
-                    }))(input, "$input", true);
-                const success = 0 === errors.length;
-                return success ? {
-                    success,
-                    data: input
-                } : {
-                    success,
-                    errors,
-                    data: input
-                };
-            }
-            return {
-                success: true,
-                data: input
-            };
-        };
-    })();
-    let configPromise = null;
-    const prepareConfig = async ()=>{
-        if (!configPromise) configPromise = (async ()=>{
-            try {
-                const config = await (0, plugin_core_namespaceObject.loadConfig)(null);
-                const databasePlugin = await config?.database({
-                    cwd: (0, plugin_core_namespaceObject.getCwd)()
-                }) ?? null;
-                if (!databasePlugin) throw new Error("Database plugin initialization failed");
-                return {
-                    config,
-                    databasePlugin
-                };
-            } catch (error) {
-                console.error("Error during configuration initialization:", error);
-                throw error;
-            }
-        })();
-        return configPromise;
-    };
-    const rpc = new hono_Hono().get("/config", async (c)=>{
-        try {
-            const { config } = await prepareConfig();
-            return c.json({
-                console: config.console
-            });
-        } catch (error) {
-            console.error("Error during config retrieval:", error);
-            throw error;
-        }
-    }).get("/channels", async (c)=>{
-        try {
-            const { databasePlugin } = await prepareConfig();
-            const channels = await databasePlugin.getChannels();
-            return c.json(channels ?? []);
-        } catch (error) {
-            console.error("Error during channel retrieval:", error);
-            throw error;
-        }
-    }).get("/config-loaded", (c)=>{
-        try {
-            const isLoaded = !!configPromise;
-            return c.json({
-                configLoaded: isLoaded
-            });
-        } catch (error) {
-            console.error("Error during config loaded retrieval:", error);
-            throw error;
-        }
-    }).get("/bundles", typiaValidator("query", queryBundlesSchema), async (c)=>{
-        try {
-            const query = c.req.valid("query");
-            const { databasePlugin } = await prepareConfig();
-            const bundles = await databasePlugin.getBundles({
-                where: {
-                    channel: query.channel ?? void 0,
-                    platform: query.platform ?? void 0
-                },
-                limit: query.limit ? Number(query.limit) : void 0,
-                offset: query.offset ? Number(query.offset) : void 0
-            });
-            return c.json(bundles ?? []);
-        } catch (error) {
-            console.error("Error during bundle retrieval:", error);
-            throw error;
-        }
-    }).get("/bundles/:bundleId", typiaValidator("param", paramBundleIdSchema), async (c)=>{
-        try {
-            const { bundleId } = c.req.valid("param");
-            const { databasePlugin } = await prepareConfig();
-            const bundle = await databasePlugin.getBundleById(bundleId);
-            return c.json(bundle ?? null);
-        } catch (error) {
-            console.error("Error during bundle retrieval:", error);
-            throw error;
-        }
-    }).patch("/bundles/:bundleId", typiaValidator("json", updateBundleSchema), async (c)=>{
-        try {
-            const bundleId = c.req.param("bundleId");
-            const partialBundle = c.req.valid("json");
-            if (!bundleId) return c.json({
-                error: "Target bundle ID is required"
-            }, 400);
-            const { databasePlugin } = await prepareConfig();
-            await databasePlugin.updateBundle(bundleId, partialBundle);
-            await databasePlugin.commitBundle();
-            return c.json({
-                success: true
-            });
-        } catch (error) {
-            console.error("Error during bundle update:", error);
-            if (error && "object" == typeof error && "message" in error) return c.json({
-                error: error.message
-            }, 500);
-            return c.json({
-                error: "Unknown error"
-            }, 500);
-        }
-    });
-    const src_server_dirname = external_path_default().dirname((0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
-    const relativePathToScript = external_path_default().relative(process.cwd(), src_server_dirname);
-    const src_server_app = new hono_Hono().get("/ping", (c)=>c.text("pong")).route("/rpc", rpc).use("/assets/*", serveStatic({
-        root: relativePathToScript
-    })).get("*", serveStatic({
-        root: relativePathToScript,
-        path: "index.html"
-    }));
-    const src_server = src_server_app;
+const updateBundleSchema = (() => {
+	const _io0 = (input) => (void 0 === input.id || "string" === typeof input.id) && (void 0 === input.platform || "ios" === input.platform || "android" === input.platform) && (void 0 === input.shouldForceUpdate || "boolean" === typeof input.shouldForceUpdate) && (void 0 === input.enabled || "boolean" === typeof input.enabled) && (void 0 === input.fileHash || "string" === typeof input.fileHash) && (void 0 === input.storageUri || "string" === typeof input.storageUri) && (null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" === typeof input.gitCommitHash) && (null === input.message || void 0 === input.message || "string" === typeof input.message) && (void 0 === input.channel || "string" === typeof input.channel) && (null === input.targetAppVersion || void 0 === input.targetAppVersion || "string" === typeof input.targetAppVersion) && (null === input.fingerprintHash || void 0 === input.fingerprintHash || "string" === typeof input.fingerprintHash) && (void 0 === input.metadata || "object" === typeof input.metadata && null !== input.metadata && false === Array.isArray(input.metadata) && _io1(input.metadata));
+	const _io1 = (input) => void 0 === input.app_version || "string" === typeof input.app_version;
+	const _vo0 = (input, _path, _exceptionable = true) => [
+		void 0 === input.id || "string" === typeof input.id || _report(_exceptionable, {
+			path: _path + ".id",
+			expected: "(string | undefined)",
+			value: input.id
+		}),
+		void 0 === input.platform || "ios" === input.platform || "android" === input.platform || _report(_exceptionable, {
+			path: _path + ".platform",
+			expected: "(\"android\" | \"ios\" | undefined)",
+			value: input.platform
+		}),
+		void 0 === input.shouldForceUpdate || "boolean" === typeof input.shouldForceUpdate || _report(_exceptionable, {
+			path: _path + ".shouldForceUpdate",
+			expected: "(boolean | undefined)",
+			value: input.shouldForceUpdate
+		}),
+		void 0 === input.enabled || "boolean" === typeof input.enabled || _report(_exceptionable, {
+			path: _path + ".enabled",
+			expected: "(boolean | undefined)",
+			value: input.enabled
+		}),
+		void 0 === input.fileHash || "string" === typeof input.fileHash || _report(_exceptionable, {
+			path: _path + ".fileHash",
+			expected: "(string | undefined)",
+			value: input.fileHash
+		}),
+		void 0 === input.storageUri || "string" === typeof input.storageUri || _report(_exceptionable, {
+			path: _path + ".storageUri",
+			expected: "(string | undefined)",
+			value: input.storageUri
+		}),
+		null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" === typeof input.gitCommitHash || _report(_exceptionable, {
+			path: _path + ".gitCommitHash",
+			expected: "(null | string | undefined)",
+			value: input.gitCommitHash
+		}),
+		null === input.message || void 0 === input.message || "string" === typeof input.message || _report(_exceptionable, {
+			path: _path + ".message",
+			expected: "(null | string | undefined)",
+			value: input.message
+		}),
+		void 0 === input.channel || "string" === typeof input.channel || _report(_exceptionable, {
+			path: _path + ".channel",
+			expected: "(string | undefined)",
+			value: input.channel
+		}),
+		null === input.targetAppVersion || void 0 === input.targetAppVersion || "string" === typeof input.targetAppVersion || _report(_exceptionable, {
+			path: _path + ".targetAppVersion",
+			expected: "(null | string | undefined)",
+			value: input.targetAppVersion
+		}),
+		null === input.fingerprintHash || void 0 === input.fingerprintHash || "string" === typeof input.fingerprintHash || _report(_exceptionable, {
+			path: _path + ".fingerprintHash",
+			expected: "(null | string | undefined)",
+			value: input.fingerprintHash
+		}),
+		void 0 === input.metadata || ("object" === typeof input.metadata && null !== input.metadata && false === Array.isArray(input.metadata) || _report(_exceptionable, {
+			path: _path + ".metadata",
+			expected: "(BundleMetadata | undefined)",
+			value: input.metadata
+		})) && _vo1(input.metadata, _path + ".metadata", _exceptionable) || _report(_exceptionable, {
+			path: _path + ".metadata",
+			expected: "(BundleMetadata | undefined)",
+			value: input.metadata
+		})
+	].every((flag) => flag);
+	const _vo1 = (input, _path, _exceptionable = true) => [void 0 === input.app_version || "string" === typeof input.app_version || _report(_exceptionable, {
+		path: _path + ".app_version",
+		expected: "(string | undefined)",
+		value: input.app_version
+	})].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+	let errors;
+	let _report;
+	return (input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = import__validateReport._validateReport(errors);
+			((input$1, _path, _exceptionable = true) => ("object" === typeof input$1 && null !== input$1 && false === Array.isArray(input$1) || _report(true, {
+				path: _path + "",
+				expected: "Partial<Bundle>",
+				value: input$1
+			})) && _vo0(input$1, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "Partial<Bundle>",
+				value: input$1
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	};
 })();
-exports["default"] = __webpack_exports__["default"];
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "default"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
+let configPromise = null;
+const prepareConfig = async () => {
+	if (!configPromise) configPromise = (async () => {
+		try {
+			const config = await (0, __hot_updater_plugin_core.loadConfig)(null);
+			const databasePlugin = await config?.database({ cwd: (0, __hot_updater_plugin_core.getCwd)() }) ?? null;
+			if (!databasePlugin) throw new Error("Database plugin initialization failed");
+			return {
+				config,
+				databasePlugin
+			};
+		} catch (error) {
+			console.error("Error during configuration initialization:", error);
+			throw error;
+		}
+	})();
+	return configPromise;
+};
+const rpc = new Hono().get("/config", async (c) => {
+	try {
+		const { config } = await prepareConfig();
+		return c.json({ console: config.console });
+	} catch (error) {
+		console.error("Error during config retrieval:", error);
+		throw error;
+	}
+}).get("/channels", async (c) => {
+	try {
+		const { databasePlugin } = await prepareConfig();
+		const channels = await databasePlugin.getChannels();
+		return c.json(channels ?? []);
+	} catch (error) {
+		console.error("Error during channel retrieval:", error);
+		throw error;
+	}
+}).get("/config-loaded", (c) => {
+	try {
+		const isLoaded = !!configPromise;
+		return c.json({ configLoaded: isLoaded });
+	} catch (error) {
+		console.error("Error during config loaded retrieval:", error);
+		throw error;
+	}
+}).get("/bundles", typiaValidator("query", queryBundlesSchema), async (c) => {
+	try {
+		const query = c.req.valid("query");
+		const { databasePlugin } = await prepareConfig();
+		const bundles = await databasePlugin.getBundles({
+			where: {
+				channel: query.channel ?? void 0,
+				platform: query.platform ?? void 0
+			},
+			limit: query.limit ? Number(query.limit) : void 0,
+			offset: query.offset ? Number(query.offset) : void 0
+		});
+		return c.json(bundles ?? []);
+	} catch (error) {
+		console.error("Error during bundle retrieval:", error);
+		throw error;
+	}
+}).get("/bundles/:bundleId", typiaValidator("param", paramBundleIdSchema), async (c) => {
+	try {
+		const { bundleId } = c.req.valid("param");
+		const { databasePlugin } = await prepareConfig();
+		const bundle = await databasePlugin.getBundleById(bundleId);
+		return c.json(bundle ?? null);
+	} catch (error) {
+		console.error("Error during bundle retrieval:", error);
+		throw error;
+	}
+}).patch("/bundles/:bundleId", typiaValidator("json", updateBundleSchema), async (c) => {
+	try {
+		const bundleId = c.req.param("bundleId");
+		const partialBundle = c.req.valid("json");
+		if (!bundleId) return c.json({ error: "Target bundle ID is required" }, 400);
+		const { databasePlugin } = await prepareConfig();
+		await databasePlugin.updateBundle(bundleId, partialBundle);
+		await databasePlugin.commitBundle();
+		return c.json({ success: true });
+	} catch (error) {
+		console.error("Error during bundle update:", error);
+		if (error && typeof error === "object" && "message" in error) return c.json({ error: error.message }, 500);
+		return c.json({ error: "Unknown error" }, 500);
+	}
 });
+
+//#endregion
+//#region src-server/index.ts
+const __dirname$1 = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const relativePathToScript = path.default.relative(process.cwd(), __dirname$1);
+const app = new Hono().get("/ping", (c) => c.text("pong")).route("/rpc", rpc).use("/assets/*", serveStatic({ root: relativePathToScript })).get("*", serveStatic({
+	root: relativePathToScript,
+	path: "index.html"
+}));
+var src_server_default = app;
+
+//#endregion
+module.exports = src_server_default;