@hot-updater/console 0.17.0 → 0.18.0

package/dist/index.js

@@ -1,2008 +1,2003 @@
-import __rslib_shim_module__ from 'module';
-/*#__PURE__*/ import.meta.url;
-import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
-import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
-import * as __WEBPACK_EXTERNAL_MODULE__hot_updater_plugin_core_40c1c502__ from "@hot-updater/plugin-core";
-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, exports) {
-        exports._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;
-            };
-        };
-        exports._validateReport = _validateReport;
-    }
+import path from "path";
+import { fileURLToPath } from "url";
+import { createReadStream, lstatSync } from "fs";
+import { getCwd, loadConfig } from "@hot-updater/plugin-core";
+
+//#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 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 __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
+//#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$1 = getFilePathWithoutDefaultDocument({
+		root: options.root,
+		filename
+	});
+	return path$1;
 };
-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 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$1 = root ? root + "/" + filename : filename;
+	path$1 = path$1.replace(/^\.?\//, "");
+	if (root[0] !== "/" && path$1[0] === "/") return;
+	return path$1;
 };
-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;
+
+//#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"
+	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"
+	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 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$1) => {
+	return `./${path$1}`;
 };
-var addCurrentDirPrefix = (path)=>`./${path}`;
-var getStats = (path)=>{
-    let stats;
-    try {
-        stats = (0, __WEBPACK_EXTERNAL_MODULE_fs__.lstatSync)(path);
-    } catch  {}
-    return stats;
+var getStats = (path$1) => {
+	let stats;
+	try {
+		stats = lstatSync(path$1);
+	} 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, __WEBPACK_EXTERNAL_MODULE_fs__.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, __WEBPACK_EXTERNAL_MODULE_fs__.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 {};
+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$1 = getFilePathWithoutDefaultDocument({
+			filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+			root: options.root
+		});
+		if (path$1) path$1 = addCurrentDirPrefix(path$1);
+		else return next();
+		let stats = getStats(path$1);
+		if (stats && stats.isDirectory()) {
+			path$1 = getFilePath({
+				filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+				root: options.root,
+				defaultDocument: options.index ?? "index.html"
+			});
+			if (path$1) path$1 = addCurrentDirPrefix(path$1);
+			else return next();
+			stats = getStats(path$1);
+		}
+		if (!stats) {
+			await options.onNotFound?.(path$1, c);
+			return next();
+		}
+		await options.onFound?.(path$1, c);
+		const mimeType = getMimeType(path$1);
+		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$1 + ENCODINGS[encoding]);
+				if (precompressedStats) {
+					c.header("Content-Encoding", encoding);
+					c.header("Vary", "Accept-Encoding", { append: true });
+					stats = precompressedStats;
+					path$1 = path$1 + 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(createReadStream(path$1)), 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 = createReadStream(path$1, {
+			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 {};
+	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;
+	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 (void 0 !== form[key]) if (Array.isArray(form[key])) form[key].push(value);
-    else form[key] = [
-        form[key],
-        value
-    ];
-    else form[key] = value;
+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] || "object" != typeof nestedForm[key2] || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-            nestedForm = nestedForm[key2];
-        }
-    });
+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];
+		}
+	});
 };
-var splitPath = (path)=>{
-    const paths = path.split("/");
-    if ("" === paths[0]) paths.shift();
-    return paths;
+
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path$1) => {
+	const paths = path$1.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 splitRoutingPath = (routePath) => {
+	const { groups, path: path$1 } = extractGroupsFromPath(routePath);
+	const paths = splitPath(path$1);
+	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 extractGroupsFromPath = (path$1) => {
+	const groups = [];
+	path$1 = path$1.replace(/\{[^}]+\}/g, (match, index) => {
+		const mark = `@${index}`;
+		groups.push([mark, match]);
+		return mark;
+	});
+	return {
+		groups,
+		path: path$1
+	};
 };
-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 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 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 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 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 (charCode === 37) {
+			const queryIndex = url.indexOf("?", i);
+			const path$1 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+			return tryDecodeURI(path$1.includes("%25") ? path$1.replace(/%25/g, "%2525") : path$1);
+		} else if (charCode === 63) 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 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 mergePath = (...paths) => {
+	let p = "";
+	let endsWithSlash = false;
+	for (let path$1 of paths) {
+		if (p[p.length - 1] === "/") {
+			p = p.slice(0, -1);
+			endsWithSlash = true;
+		}
+		if (path$1[0] !== "/") path$1 = `/${path$1}`;
+		if (path$1 === "/" && endsWithSlash) p = `${p}/`;
+		else if (path$1 !== "/") p = `${p}${path$1}`;
+		if (path$1 === "/" && 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 checkOptionalParameter = (path$1) => {
+	if (!path$1.match(/\:.+\?$/)) return null;
+	const segments = path$1.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 (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
-    return /%/.test(value) ? decodeURIComponent_(value) : value;
+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, 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 = (url, key, multiple) => {
+	let encoded;
+	if (!multiple && key && !/[%+]/.test(key)) {
+		let keyIndex2 = url.indexOf(`?${key}`, 8);
+		if (keyIndex2 === -1) keyIndex2 = url.indexOf(`&${key}`, 8);
+		while (keyIndex2 !== -1) {
+			const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+			if (trailingKeyCode === 61) {
+				const valueIndex = keyIndex2 + key.length + 2;
+				const endIndex = url.indexOf("&", valueIndex);
+				return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+			} else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) return "";
+			keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+		}
+		encoded = /[%+]/.test(url);
+		if (!encoded) return void 0;
+	}
+	const results = {};
+	encoded ??= /[%+]/.test(url);
+	let keyIndex = url.indexOf("?", 8);
+	while (keyIndex !== -1) {
+		const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+		let valueIndex = url.indexOf("=", keyIndex);
+		if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) valueIndex = -1;
+		let name = url.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.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, key)=>_getQueryParam(url, key, true);
+var getQueryParams = (url, key) => {
+	return _getQueryParam(url, 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 = "/", 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;
-    }
+	raw;
+	#validatedData;
+	#matchResult;
+	routeIndex = 0;
+	path;
+	bodyCache = {};
+	constructor(request, path$1 = "/", matchResult = [[]]) {
+		this.raw = request;
+		this.path = path$1;
+		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
+	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 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 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 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);
-    };
+	#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;
+		}
+	};
 };
-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;
-        }
-    };
+
+//#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"
+	"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 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)=>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 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 = 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 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$1, ...handlers) => {
+			for (const p of [path$1].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$1, app$1) {
+		const subApp = this.basePath(path$1);
+		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$1) {
+		const subApp = this.clone();
+		subApp._basePath = mergePath(this._basePath, path$1);
+		return subApp;
+	}
+	onError = (handler) => {
+		this.errorHandler = handler;
+		return this;
+	};
+	notFound = (handler) => {
+		this.notFoundHandler = handler;
+		return this;
+	};
+	mount(path$1, 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$1);
+			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$1, "*"), handler);
+		return this;
+	}
+	addRoute(method, path$1, handler) {
+		method = method.toUpperCase();
+		path$1 = mergePath(this._basePath, path$1);
+		const r = {
+			path: path$1,
+			method,
+			handler
+		};
+		this.router.add(method, path$1, [handler, r]);
+		this.routes.push(r);
+	}
+	matchRoute(method, path$1) {
+		return this.router.match(method, path$1);
+	}
+	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$1 = this.getPath(request, { env });
+		const matchResult = this.matchRoute(method, path$1);
+		const c = new Context(request, {
+			path: path$1,
+			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$1 = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
+		const req = new Request(path$1, 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 (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;
+	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 = 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 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();
-    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
-        ];
-    }
+	context = { varIndex: 0 };
+	root = new Node$1();
+	insert(path$1, index, pathErrorCheckOnly) {
+		const paramAssoc = [];
+		const groups = [];
+		for (let i = 0;;) {
+			let replaced = false;
+			path$1 = path$1.replace(/\{[^}]+\}/g, (m) => {
+				const mark = `@\\${i}`;
+				groups[i] = [mark, m];
+				i++;
+				replaced = true;
+				return mark;
+			});
+			if (!replaced) break;
+		}
+		const tokens = path$1.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)
+	/^$/,
+	[],
+	/* @__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 buildWildcardRegExp(path$1) {
+	return wildcardRegExpCache[path$1] ??= new RegExp(path$1 === "*" ? "" : `^${path$1.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
 }
 function clearWildcardRegExpCache() {
-    wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+	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
-    ];
+	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$1, handlers] = routesWithStaticPathFlag[i];
+		if (pathErrorCheckOnly) staticMap[path$1] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+		else j++;
+		let paramAssoc;
+		try {
+			paramAssoc = trie.insert(path$1, j, pathErrorCheckOnly);
+		} catch (e) {
+			throw e === PATH_ERROR ? new UnsupportedPathError(path$1) : 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) {
-    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]
-    ];
+function findMiddleware(middleware, path$1) {
+	if (!middleware) return void 0;
+	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path$1)) 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, 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);
-    }
+	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$1, 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$1 === "/*") path$1 = "*";
+		const paramCount = (path$1.match(/\/:/g) || []).length;
+		if (/\*$/.test(path$1)) {
+			const re = buildWildcardRegExp(path$1);
+			if (method === METHOD_NAME_ALL) Object.keys(middleware).forEach((m) => {
+				middleware[m][path$1] ||= findMiddleware(middleware[m], path$1) || findMiddleware(middleware[METHOD_NAME_ALL], path$1) || [];
+			});
+			else middleware[method][path$1] ||= findMiddleware(middleware[method], path$1) || findMiddleware(middleware[METHOD_NAME_ALL], path$1) || [];
+			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$1) || [path$1];
+		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$1) {
+		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$1);
+	}
+	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$1) => [path$1, r[method][path$1]]) : [];
+			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$1) => [path$1, r[METHOD_NAME_ALL][path$1]]));
+		});
+		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, 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];
-    }
+	name = "SmartRouter";
+	routers = [];
+	routes = [];
+	constructor(init) {
+		Object.assign(this, init);
+	}
+	add(method, path$1, handler) {
+		if (!this.routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		this.routes.push([
+			method,
+			path$1,
+			handler
+		]);
+	}
+	match(method, path$1) {
+		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$1);
+			} 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];
+	}
 };
-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
-                ])
-        ];
-    }
+
+//#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$1, handler) {
+		this.name = `${method} ${path$1}`;
+		this.order = ++this.order;
+		let curNode = this;
+		const parts = splitRoutingPath(path$1);
+		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$1) {
+		const handlerSets = [];
+		this.params = /* @__PURE__ */ Object.create(null);
+		const curNode = this;
+		let curNodes = [curNode];
+		const parts = splitPath(path$1);
+		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_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);
-    }
+	name = "TrieRouter";
+	node;
+	constructor() {
+		this.node = new Node();
+	}
+	add(method, path$1, handler) {
+		const results = checkOptionalParameter(path$1);
+		if (results) {
+			for (const p of results) this.node.insert(method, p, handler);
+			return;
+		}
+		this.node.insert(method, path$1, handler);
+	}
+	match(method, path$1) {
+		return this.node.search(method, path$1);
+	}
 };
-var hono_Hono = class extends Hono {
-    constructor(options = {}){
-        super(options);
-        this.router = options.router ?? new SmartRouter({
-            routers: [
-                new RegExpRouter(),
-                new TrieRouter()
-            ]
-        });
-    }
+
+//#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()] });
+	}
 };
-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");
+
+//#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$1) => {
+			if (array.length === 0) return true;
+			const last = array[array.length - 1].path;
+			return path$1.length > last.length || last.substring(0, path$1.length) !== path$1;
+		};
+		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 (-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 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;
+	}, {});
 };
-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;
+
+//#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
-        });
-    }
+	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();
+
+//#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)=>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 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
-        };
-    };
+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
+		};
+	};
 })();
-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 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
+		};
+	};
 })();
-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
-        };
-    };
+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
+		};
+	};
 })();
 let configPromise = null;
-const prepareConfig = async ()=>{
-    if (!configPromise) configPromise = (async ()=>{
-        try {
-            const config = await (0, __WEBPACK_EXTERNAL_MODULE__hot_updater_plugin_core_40c1c502__.loadConfig)(null);
-            const databasePlugin = await config?.database({
-                cwd: (0, __WEBPACK_EXTERNAL_MODULE__hot_updater_plugin_core_40c1c502__.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 prepareConfig = async () => {
+	if (!configPromise) configPromise = (async () => {
+		try {
+			const config = await loadConfig(null);
+			const databasePlugin = await config?.database({ cwd: 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 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);
+	}
 });
-const src_server_dirname = __WEBPACK_EXTERNAL_MODULE_path__["default"].dirname((0, __WEBPACK_EXTERNAL_MODULE_url__.fileURLToPath)(import.meta.url));
-const relativePathToScript = __WEBPACK_EXTERNAL_MODULE_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"
+
+//#endregion
+//#region src-server/index.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const relativePathToScript = path.relative(process.cwd(), __dirname);
+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"
 }));
-const src_server = src_server_app;
-export { src_server as default };
+var src_server_default = app;
+
+//#endregion
+export { src_server_default as default };