@hot-updater/console 0.12.6 → 0.12.7

package/dist/index.cjs

@@ -2,7 +2,838 @@
 const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 }();
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/@hono+typia-validator@0.1.0_hono@4.6.3_typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3_/node_modules/@hono/typia-validator/dist/cjs/index.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        exports1.typiaValidator = void 0;
+        const validator_1 = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/index.js");
+        const typiaValidator = (target, validate, hook)=>(0, validator_1.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;
+            });
+        exports1.typiaValidator = typiaValidator;
+    },
+    "../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3/node_modules/typia/lib/internal/_validateReport.js": function(__unused_webpack_module, exports1) {
+        exports1._validateReport = void 0;
+        const _validateReport = (array)=>{
+            const reportable = (path)=>{
+                if (0 === array.length) return true;
+                const last = array[array.length - 1].path;
+                return path.length > last.length || last.substring(0, path.length) !== path;
+            };
+            return (exceptable, error)=>{
+                if (exceptable && reportable(error.path)) array.push(error);
+                return false;
+            };
+        };
+        exports1._validateReport = _validateReport;
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/helper/cookie/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var cookie_exports = {};
+        __export(cookie_exports, {
+            deleteCookie: ()=>deleteCookie,
+            getCookie: ()=>getCookie,
+            getSignedCookie: ()=>getSignedCookie,
+            setCookie: ()=>setCookie,
+            setSignedCookie: ()=>setSignedCookie
+        });
+        module.exports = __toCommonJS(cookie_exports);
+        var import_cookie = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/cookie.js");
+        const 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 = (0, import_cookie.parse)(cookie, finalKey);
+                return obj2[finalKey];
+            }
+            if (!cookie) return {};
+            const obj = (0, import_cookie.parse)(cookie);
+            return obj;
+        };
+        const getSignedCookie = async (c, secret, 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 = await (0, import_cookie.parseSigned)(cookie, secret, finalKey);
+                return obj2[finalKey];
+            }
+            if (!cookie) return {};
+            const obj = await (0, import_cookie.parseSigned)(cookie, secret);
+            return obj;
+        };
+        const setCookie = (c, name, value, opt)=>{
+            let cookie;
+            cookie = opt?.prefix === "secure" ? (0, import_cookie.serialize)("__Secure-" + name, value, {
+                path: "/",
+                ...opt,
+                secure: true
+            }) : opt?.prefix === "host" ? (0, import_cookie.serialize)("__Host-" + name, value, {
+                ...opt,
+                path: "/",
+                secure: true,
+                domain: void 0
+            }) : (0, import_cookie.serialize)(name, value, {
+                path: "/",
+                ...opt
+            });
+            c.header("set-cookie", cookie, {
+                append: true
+            });
+        };
+        const setSignedCookie = async (c, name, value, secret, opt)=>{
+            let cookie;
+            cookie = opt?.prefix === "secure" ? await (0, import_cookie.serializeSigned)("__Secure-" + name, value, secret, {
+                path: "/",
+                ...opt,
+                secure: true
+            }) : opt?.prefix === "host" ? await (0, import_cookie.serializeSigned)("__Host-" + name, value, secret, {
+                ...opt,
+                path: "/",
+                secure: true,
+                domain: void 0
+            }) : await (0, import_cookie.serializeSigned)(name, value, secret, {
+                path: "/",
+                ...opt
+            });
+            c.header("set-cookie", cookie, {
+                append: true
+            });
+        };
+        const deleteCookie = (c, name, opt)=>{
+            const deletedCookie = getCookie(c, name);
+            setCookie(c, name, "", {
+                ...opt,
+                maxAge: 0
+            });
+            return deletedCookie;
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/http-exception.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var http_exception_exports = {};
+        __export(http_exception_exports, {
+            HTTPException: ()=>HTTPException
+        });
+        module.exports = __toCommonJS(http_exception_exports);
+        class HTTPException 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
+                });
+            }
+        }
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/buffer.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var buffer_exports = {};
+        __export(buffer_exports, {
+            bufferToFormData: ()=>bufferToFormData,
+            bufferToString: ()=>bufferToString,
+            equal: ()=>equal,
+            timingSafeEqual: ()=>timingSafeEqual
+        });
+        module.exports = __toCommonJS(buffer_exports);
+        var import_crypto = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/crypto.js");
+        const equal = (a, b)=>{
+            if (a === b) return true;
+            if (a.byteLength !== b.byteLength) return false;
+            const va = new DataView(a);
+            const vb = new DataView(b);
+            let i = va.byteLength;
+            while(i--)if (va.getUint8(i) !== vb.getUint8(i)) return false;
+            return true;
+        };
+        const timingSafeEqual = async (a, b, hashFunction)=>{
+            if (!hashFunction) hashFunction = import_crypto.sha256;
+            const [sa, sb] = await Promise.all([
+                hashFunction(a),
+                hashFunction(b)
+            ]);
+            if (!sa || !sb) return false;
+            return sa === sb && a === b;
+        };
+        const bufferToString = (buffer)=>{
+            if (buffer instanceof ArrayBuffer) {
+                const enc = new TextDecoder("utf-8");
+                return enc.decode(buffer);
+            }
+            return buffer;
+        };
+        const bufferToFormData = (arrayBuffer, contentType)=>{
+            const response = new Response(arrayBuffer, {
+                headers: {
+                    "Content-Type": contentType
+                }
+            });
+            return response.formData();
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/cookie.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var cookie_exports = {};
+        __export(cookie_exports, {
+            parse: ()=>parse,
+            parseSigned: ()=>parseSigned,
+            serialize: ()=>serialize,
+            serializeSigned: ()=>serializeSigned
+        });
+        module.exports = __toCommonJS(cookie_exports);
+        var import_url = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/url.js");
+        const algorithm = {
+            name: "HMAC",
+            hash: "SHA-256"
+        };
+        const getCryptoKey = async (secret)=>{
+            const secretBuf = "string" == typeof secret ? new TextEncoder().encode(secret) : secret;
+            return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, [
+                "sign",
+                "verify"
+            ]);
+        };
+        const makeSignature = async (value, secret)=>{
+            const key = await getCryptoKey(secret);
+            const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+            return btoa(String.fromCharCode(...new Uint8Array(signature)));
+        };
+        const verifySignature = async (base64Signature, value, secret)=>{
+            try {
+                const signatureBinStr = atob(base64Signature);
+                const signature = new Uint8Array(signatureBinStr.length);
+                for(let i = 0, len = signatureBinStr.length; i < len; i++)signature[i] = signatureBinStr.charCodeAt(i);
+                return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+            } catch  {
+                return false;
+            }
+        };
+        const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+        const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+        const 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] = (0, import_url.decodeURIComponent_)(cookieValue);
+                return parsedCookie;
+            }, {});
+        };
+        const parseSigned = async (cookie, secret, name)=>{
+            const parsedCookie = {};
+            const secretKey = await getCryptoKey(secret);
+            for (const [key, value] of Object.entries(parse(cookie, name))){
+                const signatureStartPos = value.lastIndexOf(".");
+                if (signatureStartPos < 1) continue;
+                const signedValue = value.substring(0, signatureStartPos);
+                const signature = value.substring(signatureStartPos + 1);
+                if (44 !== signature.length || !signature.endsWith("=")) continue;
+                const isVerified = await verifySignature(signature, signedValue, secretKey);
+                parsedCookie[key] = isVerified ? signedValue : false;
+            }
+            return parsedCookie;
+        };
+        const _serialize = (name, value, opt = {})=>{
+            let cookie = `${name}=${value}`;
+            if (name.startsWith("__Secure-") && !opt.secure) throw new Error("__Secure- Cookie must have Secure attributes");
+            if (name.startsWith("__Host-")) {
+                if (!opt.secure) throw new Error("__Host- Cookie must have Secure attributes");
+                if ("/" !== opt.path) throw new Error('__Host- Cookie must have Path attributes with "/"');
+                if (opt.domain) throw new Error("__Host- Cookie must not have Domain attributes");
+            }
+            if (opt && "number" == typeof opt.maxAge && opt.maxAge >= 0) {
+                if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+                cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+            }
+            if (opt.domain && "host" !== opt.prefix) cookie += `; Domain=${opt.domain}`;
+            if (opt.path) cookie += `; Path=${opt.path}`;
+            if (opt.expires) {
+                if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+                cookie += `; Expires=${opt.expires.toUTCString()}`;
+            }
+            if (opt.httpOnly) cookie += "; HttpOnly";
+            if (opt.secure) cookie += "; Secure";
+            if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+            if (opt.partitioned) {
+                if (!opt.secure) throw new Error("Partitioned Cookie must have Secure attributes");
+                cookie += "; Partitioned";
+            }
+            return cookie;
+        };
+        const serialize = (name, value, opt)=>{
+            value = encodeURIComponent(value);
+            return _serialize(name, value, opt);
+        };
+        const serializeSigned = async (name, value, secret, opt = {})=>{
+            const signature = await makeSignature(value, secret);
+            value = `${value}.${signature}`;
+            value = encodeURIComponent(value);
+            return _serialize(name, value, opt);
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/crypto.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var crypto_exports = {};
+        __export(crypto_exports, {
+            createHash: ()=>createHash,
+            md5: ()=>md5,
+            sha1: ()=>sha1,
+            sha256: ()=>sha256
+        });
+        module.exports = __toCommonJS(crypto_exports);
+        const sha256 = async (data)=>{
+            const algorithm = {
+                name: "SHA-256",
+                alias: "sha256"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const sha1 = async (data)=>{
+            const algorithm = {
+                name: "SHA-1",
+                alias: "sha1"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const md5 = async (data)=>{
+            const algorithm = {
+                name: "MD5",
+                alias: "md5"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const createHash = async (data, algorithm)=>{
+            let sourceBuffer;
+            if (data instanceof ReadableStream) {
+                let body = "";
+                const reader = data.getReader();
+                await reader?.read().then(async (chuck)=>{
+                    const value = await createHash(chuck.value || "", algorithm);
+                    body += value;
+                });
+                return body;
+            }
+            if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) sourceBuffer = data;
+            else {
+                if ("object" == typeof data) data = JSON.stringify(data);
+                sourceBuffer = new TextEncoder().encode(String(data));
+            }
+            if (crypto && crypto.subtle) {
+                const buffer = await crypto.subtle.digest({
+                    name: algorithm.name
+                }, sourceBuffer);
+                const hash = Array.prototype.map.call(new Uint8Array(buffer), (x)=>("00" + x.toString(16)).slice(-2)).join("");
+                return hash;
+            }
+            return null;
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/url.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var url_exports = {};
+        __export(url_exports, {
+            checkOptionalParameter: ()=>checkOptionalParameter,
+            decodeURIComponent_: ()=>decodeURIComponent_,
+            getPath: ()=>getPath,
+            getPathNoStrict: ()=>getPathNoStrict,
+            getPattern: ()=>getPattern,
+            getQueryParam: ()=>getQueryParam,
+            getQueryParams: ()=>getQueryParams,
+            getQueryStrings: ()=>getQueryStrings,
+            mergePath: ()=>mergePath,
+            splitPath: ()=>splitPath,
+            splitRoutingPath: ()=>splitRoutingPath
+        });
+        module.exports = __toCommonJS(url_exports);
+        const splitPath = (path)=>{
+            const paths = path.split("/");
+            if ("" === paths[0]) paths.shift();
+            return paths;
+        };
+        const splitRoutingPath = (routePath)=>{
+            const { groups, path } = extractGroupsFromPath(routePath);
+            const paths = splitPath(path);
+            return replaceGroupMarks(paths, groups);
+        };
+        const extractGroupsFromPath = (path)=>{
+            const groups = [];
+            path = path.replace(/\{[^}]+\}/g, (match, index)=>{
+                const mark = `@${index}`;
+                groups.push([
+                    mark,
+                    match
+                ]);
+                return mark;
+            });
+            return {
+                groups,
+                path
+            };
+        };
+        const 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;
+        };
+        const patternCache = {};
+        const 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;
+        };
+        const tryDecodeURI = (str)=>{
+            try {
+                return decodeURI(str);
+            } catch  {
+                return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match)=>{
+                    try {
+                        return decodeURI(match);
+                    } catch  {
+                        return match;
+                    }
+                });
+            }
+        };
+        const 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);
+        };
+        const getQueryStrings = (url)=>{
+            const queryIndex = url.indexOf("?", 8);
+            return -1 === queryIndex ? "" : "?" + url.slice(queryIndex + 1);
+        };
+        const getPathNoStrict = (request)=>{
+            const result = getPath(request);
+            return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
+        };
+        const 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;
+        };
+        const 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);
+        };
+        const _decodeURI = (value)=>{
+            if (!/[%+]/.test(value)) return value;
+            if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
+            return /%/.test(value) ? decodeURIComponent_(value) : value;
+        };
+        const _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;
+        };
+        const getQueryParam = _getQueryParam;
+        const getQueryParams = (url, key)=>_getQueryParam(url, key, true);
+        const decodeURIComponent_ = decodeURIComponent;
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var validator_exports = {};
+        __export(validator_exports, {
+            validator: ()=>import_validator.validator
+        });
+        module.exports = __toCommonJS(validator_exports);
+        var import_validator = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/validator.js");
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/validator.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var validator_exports = {};
+        __export(validator_exports, {
+            validator: ()=>validator
+        });
+        module.exports = __toCommonJS(validator_exports);
+        var import_cookie = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/helper/cookie/index.js");
+        var import_http_exception = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/http-exception.js");
+        var import_buffer = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/buffer.js");
+        const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+        const multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
+        const urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+        const 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 import_http_exception.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 (0, import_buffer.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 import_http_exception.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 = (0, import_cookie.getCookie)(c);
+                        break;
+                }
+                const res = await validationFunc(value, c);
+                if (res instanceof Response) return res;
+                c.req.addValidatedData(target, res);
+                await next();
+            };
+    }
+};
+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;
+}
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -34,2062 +865,1752 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    default: ()=>src_server_rslib_entry_
-});
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const external_url_namespaceObject = require("url");
-var getFilePath = (options)=>{
-    let filename = options.filename;
-    const defaultDocument = options.defaultDocument || "index.html";
-    if (filename.endsWith("/")) filename = filename.concat(defaultDocument);
-    else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) filename = filename.concat("/" + defaultDocument);
-    const path = getFilePathWithoutDefaultDocument({
-        root: options.root,
-        filename
-    });
-    return path;
-};
-var getFilePathWithoutDefaultDocument = (options)=>{
-    let root = options.root || "";
-    let filename = options.filename;
-    if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) return;
-    filename = filename.replace(/^\.?[\/\\]/, "");
-    filename = filename.replace(/\\/, "/");
-    root = root.replace(/\/$/, "");
-    let path = root ? root + "/" + filename : filename;
-    path = path.replace(/^\.?\//, "");
-    if ("/" !== root[0] && "/" === path[0]) return;
-    return path;
-};
-var getMimeType = (filename, mimes = baseMimes)=>{
-    const regexp = /\.([a-zA-Z0-9]+?)$/;
-    const match = filename.match(regexp);
-    if (!match) return;
-    let mimeType = mimes[match[1]];
-    if (mimeType && mimeType.startsWith("text") || "application/json" === mimeType) mimeType += "; charset=utf-8";
-    return mimeType;
-};
-var baseMimes = {
-    aac: "audio/aac",
-    avi: "video/x-msvideo",
-    avif: "image/avif",
-    av1: "video/av1",
-    bin: "application/octet-stream",
-    bmp: "image/bmp",
-    css: "text/css",
-    csv: "text/csv",
-    eot: "application/vnd.ms-fontobject",
-    epub: "application/epub+zip",
-    gif: "image/gif",
-    gz: "application/gzip",
-    htm: "text/html",
-    html: "text/html",
-    ico: "image/x-icon",
-    ics: "text/calendar",
-    jpeg: "image/jpeg",
-    jpg: "image/jpeg",
-    js: "text/javascript",
-    json: "application/json",
-    jsonld: "application/ld+json",
-    map: "application/json",
-    mid: "audio/x-midi",
-    midi: "audio/x-midi",
-    mjs: "text/javascript",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    mpeg: "video/mpeg",
-    oga: "audio/ogg",
-    ogv: "video/ogg",
-    ogx: "application/ogg",
-    opus: "audio/opus",
-    otf: "font/otf",
-    pdf: "application/pdf",
-    png: "image/png",
-    rtf: "application/rtf",
-    svg: "image/svg+xml",
-    tif: "image/tiff",
-    tiff: "image/tiff",
-    ts: "video/mp2t",
-    ttf: "font/ttf",
-    txt: "text/plain",
-    wasm: "application/wasm",
-    webm: "video/webm",
-    weba: "audio/webm",
-    webp: "image/webp",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    xhtml: "application/xhtml+xml",
-    xml: "application/xml",
-    zip: "application/zip",
-    "3gp": "video/3gpp",
-    "3g2": "video/3gpp2",
-    gltf: "model/gltf+json",
-    glb: "model/gltf-binary"
-};
-const external_fs_namespaceObject = require("fs");
-var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
-var ENCODINGS = {
-    br: ".br",
-    zstd: ".zst",
-    gzip: ".gz"
-};
-var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream)=>{
-    const body = new ReadableStream({
-        start (controller) {
-            stream.on("data", (chunk)=>{
-                controller.enqueue(chunk);
-            });
-            stream.on("end", ()=>{
-                controller.close();
-            });
-        },
-        cancel () {
-            stream.destroy();
-        }
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>src_server_rslib_entry_
     });
-    return body;
-};
-var addCurrentDirPrefix = (path)=>`./${path}`;
-var getStats = (path)=>{
-    let stats;
-    try {
-        stats = (0, external_fs_namespaceObject.lstatSync)(path);
-    } catch  {}
-    return stats;
-};
-var serveStatic = (options = {
-    root: ""
-})=>async (c, next)=>{
-        if (c.finalized) return next();
-        let filename;
-        try {
-            filename = options.path ?? decodeURIComponent(c.req.path);
-        } catch  {
-            await options.onNotFound?.(c.req.path, c);
-            return next();
-        }
-        let path = getFilePathWithoutDefaultDocument({
-            filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-            root: options.root
+    const external_path_namespaceObject = require("path");
+    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+    const external_url_namespaceObject = require("url");
+    var getFilePath = (options)=>{
+        let filename = options.filename;
+        const defaultDocument = options.defaultDocument || "index.html";
+        if (filename.endsWith("/")) filename = filename.concat(defaultDocument);
+        else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) filename = filename.concat("/" + defaultDocument);
+        const path = getFilePathWithoutDefaultDocument({
+            root: options.root,
+            filename
+        });
+        return path;
+    };
+    var getFilePathWithoutDefaultDocument = (options)=>{
+        let root = options.root || "";
+        let filename = options.filename;
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) return;
+        filename = filename.replace(/^\.?[\/\\]/, "");
+        filename = filename.replace(/\\/, "/");
+        root = root.replace(/\/$/, "");
+        let path = root ? root + "/" + filename : filename;
+        path = path.replace(/^\.?\//, "");
+        if ("/" !== root[0] && "/" === path[0]) return;
+        return path;
+    };
+    var getMimeType = (filename, mimes = baseMimes)=>{
+        const regexp = /\.([a-zA-Z0-9]+?)$/;
+        const match = filename.match(regexp);
+        if (!match) return;
+        let mimeType = mimes[match[1]];
+        if (mimeType && mimeType.startsWith("text") || "application/json" === mimeType) mimeType += "; charset=utf-8";
+        return mimeType;
+    };
+    var baseMimes = {
+        aac: "audio/aac",
+        avi: "video/x-msvideo",
+        avif: "image/avif",
+        av1: "video/av1",
+        bin: "application/octet-stream",
+        bmp: "image/bmp",
+        css: "text/css",
+        csv: "text/csv",
+        eot: "application/vnd.ms-fontobject",
+        epub: "application/epub+zip",
+        gif: "image/gif",
+        gz: "application/gzip",
+        htm: "text/html",
+        html: "text/html",
+        ico: "image/x-icon",
+        ics: "text/calendar",
+        jpeg: "image/jpeg",
+        jpg: "image/jpeg",
+        js: "text/javascript",
+        json: "application/json",
+        jsonld: "application/ld+json",
+        map: "application/json",
+        mid: "audio/x-midi",
+        midi: "audio/x-midi",
+        mjs: "text/javascript",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        mpeg: "video/mpeg",
+        oga: "audio/ogg",
+        ogv: "video/ogg",
+        ogx: "application/ogg",
+        opus: "audio/opus",
+        otf: "font/otf",
+        pdf: "application/pdf",
+        png: "image/png",
+        rtf: "application/rtf",
+        svg: "image/svg+xml",
+        tif: "image/tiff",
+        tiff: "image/tiff",
+        ts: "video/mp2t",
+        ttf: "font/ttf",
+        txt: "text/plain",
+        wasm: "application/wasm",
+        webm: "video/webm",
+        weba: "audio/webm",
+        webp: "image/webp",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        xhtml: "application/xhtml+xml",
+        xml: "application/xml",
+        zip: "application/zip",
+        "3gp": "video/3gpp",
+        "3g2": "video/3gpp2",
+        gltf: "model/gltf+json",
+        glb: "model/gltf-binary"
+    };
+    const external_fs_namespaceObject = require("fs");
+    var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+    var ENCODINGS = {
+        br: ".br",
+        zstd: ".zst",
+        gzip: ".gz"
+    };
+    var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+    var createStreamBody = (stream)=>{
+        const body = new ReadableStream({
+            start (controller) {
+                stream.on("data", (chunk)=>{
+                    controller.enqueue(chunk);
+                });
+                stream.on("end", ()=>{
+                    controller.close();
+                });
+            },
+            cancel () {
+                stream.destroy();
+            }
         });
-        if (!path) return next();
-        path = addCurrentDirPrefix(path);
-        let stats = getStats(path);
-        if (stats && stats.isDirectory()) {
-            path = getFilePath({
+        return body;
+    };
+    var addCurrentDirPrefix = (path)=>`./${path}`;
+    var getStats = (path)=>{
+        let stats;
+        try {
+            stats = (0, external_fs_namespaceObject.lstatSync)(path);
+        } catch  {}
+        return stats;
+    };
+    var serveStatic = (options = {
+        root: ""
+    })=>async (c, next)=>{
+            if (c.finalized) return next();
+            let filename;
+            try {
+                filename = options.path ?? decodeURIComponent(c.req.path);
+            } catch  {
+                await options.onNotFound?.(c.req.path, c);
+                return next();
+            }
+            let path = getFilePathWithoutDefaultDocument({
                 filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-                root: options.root,
-                defaultDocument: options.index ?? "index.html"
+                root: options.root
             });
             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;
+            let stats = getStats(path);
+            if (stats && stats.isDirectory()) {
+                path = getFilePath({
+                    filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+                    root: options.root,
+                    defaultDocument: options.index ?? "index.html"
+                });
+                if (!path) return next();
+                path = addCurrentDirPrefix(path);
+                stats = getStats(path);
+            }
+            if (!stats) {
+                await options.onNotFound?.(path, c);
+                return next();
+            }
+            await options.onFound?.(path, c);
+            const mimeType = getMimeType(path);
+            c.header("Content-Type", mimeType || "application/octet-stream");
+            if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+                const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding)=>encoding.trim()));
+                for (const encoding of ENCODINGS_ORDERED_KEYS){
+                    if (!acceptEncodingSet.has(encoding)) continue;
+                    const precompressedStats = getStats(path + ENCODINGS[encoding]);
+                    if (precompressedStats) {
+                        c.header("Content-Encoding", encoding);
+                        c.header("Vary", "Accept-Encoding", {
+                            append: true
+                        });
+                        stats = precompressedStats;
+                        path += ENCODINGS[encoding];
+                        break;
+                    }
                 }
             }
-        }
-        const size = stats.size;
-        if ("HEAD" == c.req.method || "OPTIONS" == c.req.method) {
-            c.header("Content-Length", size.toString());
-            c.status(200);
-            return c.body(null);
-        }
-        const range = c.req.header("range") || "";
-        if (!range) {
-            c.header("Content-Length", size.toString());
-            return c.body(createStreamBody((0, external_fs_namespaceObject.createReadStream)(path)), 200);
-        }
-        c.header("Accept-Ranges", "bytes");
-        c.header("Date", stats.birthtime.toUTCString());
-        const parts = range.replace(/bytes=/, "").split("-", 2);
-        const start = parts[0] ? parseInt(parts[0], 10) : 0;
-        let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
-        if (size < end - start + 1) end = size - 1;
-        const chunksize = end - start + 1;
-        const stream = (0, external_fs_namespaceObject.createReadStream)(path, {
-            start,
-            end
+            const size = stats.size;
+            if ("HEAD" == c.req.method || "OPTIONS" == c.req.method) {
+                c.header("Content-Length", size.toString());
+                c.status(200);
+                return c.body(null);
+            }
+            const range = c.req.header("range") || "";
+            if (!range) {
+                c.header("Content-Length", size.toString());
+                return c.body(createStreamBody((0, external_fs_namespaceObject.createReadStream)(path)), 200);
+            }
+            c.header("Accept-Ranges", "bytes");
+            c.header("Date", stats.birthtime.toUTCString());
+            const parts = range.replace(/bytes=/, "").split("-", 2);
+            const start = parts[0] ? parseInt(parts[0], 10) : 0;
+            let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+            if (size < end - start + 1) end = size - 1;
+            const chunksize = end - start + 1;
+            const stream = (0, external_fs_namespaceObject.createReadStream)(path, {
+                start,
+                end
+            });
+            c.header("Content-Length", chunksize.toString());
+            c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+            return c.body(createStreamBody(stream), 206);
+        };
+    var parseBody = async (request, options = /* @__PURE__ */ Object.create(null))=>{
+        const { all = false, dot = false } = options;
+        const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+        const contentType = headers.get("Content-Type");
+        if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
+            all,
+            dot
         });
-        c.header("Content-Length", chunksize.toString());
-        c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-        return c.body(createStreamBody(stream), 206);
+        return {};
     };
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null))=>{
-    const { all = false, dot = false } = options;
-    const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-    const contentType = headers.get("Content-Type");
-    if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
-        all,
-        dot
-    });
-    return {};
-};
-async function parseFormData(request, options) {
-    const formData = await request.formData();
-    if (formData) return convertFormDataToBodyData(formData, options);
-    return {};
-}
-function convertFormDataToBodyData(formData, options) {
-    const form = /* @__PURE__ */ Object.create(null);
-    formData.forEach((value, key)=>{
-        const shouldParseAllValues = options.all || key.endsWith("[]");
-        if (shouldParseAllValues) handleParsingAllValues(form, key, value);
-        else form[key] = value;
-    });
-    if (options.dot) Object.entries(form).forEach(([key, value])=>{
-        const shouldParseDotValues = key.includes(".");
-        if (shouldParseDotValues) {
-            handleParsingNestedValues(form, key, value);
-            delete form[key];
-        }
-    });
-    return form;
-}
-var handleParsingAllValues = (form, key, value)=>{
-    if (void 0 !== form[key]) {
-        if (Array.isArray(form[key])) form[key].push(value);
-        else form[key] = [
-            form[key],
-            value
-        ];
-    } else form[key] = value;
-};
-var handleParsingNestedValues = (form, key, value)=>{
-    let nestedForm = form;
-    const keys = key.split(".");
-    keys.forEach((key2, index)=>{
-        if (index === keys.length - 1) nestedForm[key2] = value;
-        else {
-            if (!nestedForm[key2] || "object" != typeof nestedForm[key2] || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-            nestedForm = nestedForm[key2];
-        }
-    });
-};
-var splitPath = (path)=>{
-    const paths = path.split("/");
-    if ("" === paths[0]) paths.shift();
-    return paths;
-};
-var splitRoutingPath = (routePath)=>{
-    const { groups, path } = extractGroupsFromPath(routePath);
-    const paths = splitPath(path);
-    return replaceGroupMarks(paths, groups);
-};
-var extractGroupsFromPath = (path)=>{
-    const groups = [];
-    path = path.replace(/\{[^}]+\}/g, (match, index)=>{
-        const mark = `@${index}`;
-        groups.push([
-            mark,
-            match
-        ]);
-        return mark;
-    });
-    return {
-        groups,
-        path
-    };
-};
-var replaceGroupMarks = (paths, groups)=>{
-    for(let i = groups.length - 1; i >= 0; i--){
-        const [mark] = groups[i];
-        for(let j = paths.length - 1; j >= 0; j--)if (paths[j].includes(mark)) {
-            paths[j] = paths[j].replace(mark, groups[i][1]);
-            break;
-        }
-    }
-    return paths;
-};
-var patternCache = {};
-var getPattern = (label)=>{
-    if ("*" === label) return "*";
-    const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    if (match) {
-        if (!patternCache[label]) {
-            if (match[2]) patternCache[label] = [
-                label,
-                match[1],
-                new RegExp("^" + match[2] + "$")
-            ];
-            else patternCache[label] = [
-                label,
-                match[1],
-                true
-            ];
-        }
-        return patternCache[label];
-    }
-    return null;
-};
-var tryDecodeURI = (str)=>{
-    try {
-        return decodeURI(str);
-    } catch  {
-        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match)=>{
-            try {
-                return decodeURI(match);
-            } catch  {
-                return match;
+    async function parseFormData(request, options) {
+        const formData = await request.formData();
+        if (formData) return convertFormDataToBodyData(formData, options);
+        return {};
+    }
+    function convertFormDataToBodyData(formData, options) {
+        const form = /* @__PURE__ */ Object.create(null);
+        formData.forEach((value, key)=>{
+            const shouldParseAllValues = options.all || key.endsWith("[]");
+            if (shouldParseAllValues) handleParsingAllValues(form, key, value);
+            else form[key] = value;
+        });
+        if (options.dot) Object.entries(form).forEach(([key, value])=>{
+            const shouldParseDotValues = key.includes(".");
+            if (shouldParseDotValues) {
+                handleParsingNestedValues(form, key, value);
+                delete form[key];
             }
         });
-    }
-};
-var getPath = (request)=>{
-    const url = request.url;
-    const start = url.indexOf("/", 8);
-    let i = start;
-    for(; i < url.length; i++){
-        const charCode = url.charCodeAt(i);
-        if (37 === charCode) {
-            const queryIndex = url.indexOf("?", i);
-            const path = url.slice(start, -1 === queryIndex ? void 0 : queryIndex);
-            return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
-        }
-        if (63 === charCode) break;
-    }
-    return url.slice(start, i);
-};
-var getPathNoStrict = (request)=>{
-    const result = getPath(request);
-    return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
-};
-var mergePath = (...paths)=>{
-    let p = "";
-    let endsWithSlash = false;
-    for (let path of paths){
-        if ("/" === p[p.length - 1]) {
-            p = p.slice(0, -1);
-            endsWithSlash = true;
-        }
-        if ("/" !== path[0]) path = `/${path}`;
-        if ("/" === path && endsWithSlash) p = `${p}/`;
-        else if ("/" !== path) p = `${p}${path}`;
-        if ("/" === path && "" === p) p = "/";
-    }
-    return p;
-};
-var checkOptionalParameter = (path)=>{
-    if (!path.match(/\:.+\?$/)) return null;
-    const segments = path.split("/");
-    const results = [];
-    let basePath = "";
-    segments.forEach((segment)=>{
-        if ("" === segment || /\:/.test(segment)) {
-            if (/\:/.test(segment)) {
-                if (/\?/.test(segment)) {
-                    if (0 === results.length && "" === basePath) results.push("/");
-                    else results.push(basePath);
-                    const optionalSegment = segment.replace("?", "");
-                    basePath += "/" + optionalSegment;
-                    results.push(basePath);
-                } else basePath += "/" + segment;
+        return form;
+    }
+    var handleParsingAllValues = (form, key, value)=>{
+        if (void 0 !== form[key]) {
+            if (Array.isArray(form[key])) form[key].push(value);
+            else form[key] = [
+                form[key],
+                value
+            ];
+        } else form[key] = value;
+    };
+    var handleParsingNestedValues = (form, key, value)=>{
+        let nestedForm = form;
+        const keys = key.split(".");
+        keys.forEach((key2, index)=>{
+            if (index === keys.length - 1) nestedForm[key2] = value;
+            else {
+                if (!nestedForm[key2] || "object" != typeof nestedForm[key2] || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+                nestedForm = nestedForm[key2];
             }
-        } else basePath += "/" + segment;
-    });
-    return results.filter((v, i, a)=>a.indexOf(v) === i);
-};
-var _decodeURI = (value)=>{
-    if (!/[%+]/.test(value)) return value;
-    if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
-    return /%/.test(value) ? decodeURIComponent_(value) : value;
-};
-var _getQueryParam = (url, key, multiple)=>{
-    let encoded;
-    if (!multiple && key && !/[%+]/.test(key)) {
-        let keyIndex2 = url.indexOf(`?${key}`, 8);
-        if (-1 === keyIndex2) keyIndex2 = url.indexOf(`&${key}`, 8);
-        while(-1 !== keyIndex2){
-            const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-            if (61 === trailingKeyCode) {
-                const valueIndex = keyIndex2 + key.length + 2;
-                const endIndex = url.indexOf("&", valueIndex);
-                return _decodeURI(url.slice(valueIndex, -1 === endIndex ? void 0 : endIndex));
-            }
-            if (38 == trailingKeyCode || isNaN(trailingKeyCode)) return "";
-            keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-        }
-        encoded = /[%+]/.test(url);
-        if (!encoded) return;
-    }
-    const results = {};
-    encoded ??= /[%+]/.test(url);
-    let keyIndex = url.indexOf("?", 8);
-    while(-1 !== keyIndex){
-        const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-        let valueIndex = url.indexOf("=", keyIndex);
-        if (valueIndex > nextKeyIndex && -1 !== nextKeyIndex) valueIndex = -1;
-        let name = url.slice(keyIndex + 1, -1 === valueIndex ? -1 === nextKeyIndex ? void 0 : nextKeyIndex : valueIndex);
-        if (encoded) name = _decodeURI(name);
-        keyIndex = nextKeyIndex;
-        if ("" === name) continue;
-        let value;
-        if (-1 === valueIndex) value = "";
-        else {
-            value = url.slice(valueIndex + 1, -1 === nextKeyIndex ? void 0 : nextKeyIndex);
-            if (encoded) value = _decodeURI(value);
-        }
-        if (multiple) {
-            if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
-            results[name].push(value);
-        } else results[name] ??= value;
-    }
-    return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key)=>_getQueryParam(url, key, true);
-var decodeURIComponent_ = decodeURIComponent;
-var HonoRequest = class {
-    raw;
-    #validatedData;
-    #matchResult;
-    routeIndex = 0;
-    path;
-    bodyCache = {};
-    constructor(request, path = "/", matchResult = [
-        []
-    ]){
-        this.raw = request;
-        this.path = path;
-        this.#matchResult = matchResult;
-        this.#validatedData = {};
-    }
-    param(key) {
-        return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
-    }
-    getDecodedParam(key) {
-        const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-        const param = this.getParamValue(paramKey);
-        return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
-    }
-    getAllDecodedParams() {
-        const decoded = {};
-        const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-        for (const key of keys){
-            const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-            if (value && "string" == typeof value) decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
-        }
-        return decoded;
-    }
-    getParamValue(paramKey) {
-        return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-    }
-    query(key) {
-        return getQueryParam(this.url, key);
-    }
-    queries(key) {
-        return getQueryParams(this.url, key);
-    }
-    header(name) {
-        if (name) return this.raw.headers.get(name.toLowerCase()) ?? void 0;
-        const headerData = {};
-        this.raw.headers.forEach((value, key)=>{
-            headerData[key] = value;
         });
-        return headerData;
-    }
-    async parseBody(options) {
-        return this.bodyCache.parsedBody ??= await parseBody(this, options);
-    }
-    cachedBody = (key)=>{
-        const { bodyCache, raw } = this;
-        const cachedBody = bodyCache[key];
-        if (cachedBody) return cachedBody;
-        const anyCachedKey = Object.keys(bodyCache)[0];
-        if (anyCachedKey) return bodyCache[anyCachedKey].then((body)=>{
-            if ("json" === anyCachedKey) body = JSON.stringify(body);
-            return new Response(body)[key]();
+    };
+    var splitPath = (path)=>{
+        const paths = path.split("/");
+        if ("" === paths[0]) paths.shift();
+        return paths;
+    };
+    var splitRoutingPath = (routePath)=>{
+        const { groups, path } = extractGroupsFromPath(routePath);
+        const paths = splitPath(path);
+        return replaceGroupMarks(paths, groups);
+    };
+    var extractGroupsFromPath = (path)=>{
+        const groups = [];
+        path = path.replace(/\{[^}]+\}/g, (match, index)=>{
+            const mark = `@${index}`;
+            groups.push([
+                mark,
+                match
+            ]);
+            return mark;
         });
-        return bodyCache[key] = raw[key]();
+        return {
+            groups,
+            path
+        };
     };
-    json() {
-        return this.cachedBody("json");
-    }
-    text() {
-        return this.cachedBody("text");
-    }
-    arrayBuffer() {
-        return this.cachedBody("arrayBuffer");
-    }
-    blob() {
-        return this.cachedBody("blob");
-    }
-    formData() {
-        return this.cachedBody("formData");
-    }
-    addValidatedData(target, data) {
-        this.#validatedData[target] = data;
-    }
-    valid(target) {
-        return this.#validatedData[target];
-    }
-    get url() {
-        return this.raw.url;
-    }
-    get method() {
-        return this.raw.method;
-    }
-    get matchedRoutes() {
-        return this.#matchResult[0].map(([[, route]])=>route);
-    }
-    get routePath() {
-        return this.#matchResult[0].map(([[, route]])=>route)[this.routeIndex].path;
-    }
-};
-var HtmlEscapedCallbackPhase = {
-    Stringify: 1,
-    BeforeStream: 2,
-    Stream: 3
-};
-var html_raw = (value, callbacks)=>{
-    const escapedString = new String(value);
-    escapedString.isEscaped = true;
-    escapedString.callbacks = callbacks;
-    return escapedString;
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer)=>{
-    if ("object" == typeof str && !(str instanceof String)) {
-        if (!(str instanceof Promise)) str = str.toString();
-        if (str instanceof Promise) str = await str;
-    }
-    const callbacks = str.callbacks;
-    if (!callbacks?.length) return Promise.resolve(str);
-    if (buffer) buffer[0] += str;
-    else buffer = [
-        str
-    ];
-    const resStr = Promise.all(callbacks.map((c)=>c({
-            phase,
-            buffer,
-            context
-        }))).then((res)=>Promise.all(res.filter(Boolean).map((str2)=>resolveCallback(str2, phase, false, context, buffer))).then(()=>buffer[0]));
-    if (preserveCallbacks) return html_raw(await resStr, callbacks);
-    return resStr;
-};
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setHeaders = (headers, map = {})=>{
-    Object.entries(map).forEach(([key, value])=>headers.set(key, value));
-    return headers;
-};
-var Context = class {
-    #rawRequest;
-    #req;
-    env = {};
-    #var;
-    finalized = false;
-    error;
-    #status = 200;
-    #executionCtx;
-    #headers;
-    #preparedHeaders;
-    #res;
-    #isFresh = true;
-    #layout;
-    #renderer;
-    #notFoundHandler;
-    #matchResult;
-    #path;
-    constructor(req, options){
-        this.#rawRequest = req;
-        if (options) {
-            this.#executionCtx = options.executionCtx;
-            this.env = options.env;
-            this.#notFoundHandler = options.notFoundHandler;
-            this.#path = options.path;
-            this.#matchResult = options.matchResult;
+    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;
+            }
         }
-    }
-    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;
+        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
+                ];
             }
-            throw e;
+            return patternCache[label];
         }
-        this.#res = _res;
-        this.finalized = true;
-    }
-    render = (...args)=>{
-        this.#renderer ??= (content)=>this.html(content);
-        return this.#renderer(...args);
+        return null;
     };
-    setLayout = (layout)=>this.#layout = layout;
-    getLayout = ()=>this.#layout;
-    setRenderer = (renderer)=>{
-        this.#renderer = renderer;
+    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;
+                }
+            });
+        }
     };
-    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 = {};
+    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);
             }
-            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);
+            if (63 === charCode) break;
         }
+        return url.slice(start, i);
     };
-    status = (status)=>{
-        this.#isFresh = false;
-        this.#status = status;
+    var getPathNoStrict = (request)=>{
+        const result = getPath(request);
+        return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
     };
-    set = (key, value)=>{
-        this.#var ??= /* @__PURE__ */ new Map();
-        this.#var.set(key, value);
+    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;
     };
-    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
+    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;
         });
-        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
+        return results.filter((v, i, a)=>a.indexOf(v) === i);
+    };
+    var _decodeURI = (value)=>{
+        if (!/[%+]/.test(value)) return value;
+        if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
+        return /%/.test(value) ? decodeURIComponent_(value) : value;
+    };
+    var _getQueryParam = (url, key, multiple)=>{
+        let encoded;
+        if (!multiple && key && !/[%+]/.test(key)) {
+            let keyIndex2 = url.indexOf(`?${key}`, 8);
+            if (-1 === keyIndex2) keyIndex2 = url.indexOf(`&${key}`, 8);
+            while(-1 !== keyIndex2){
+                const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+                if (61 === trailingKeyCode) {
+                    const valueIndex = keyIndex2 + key.length + 2;
+                    const endIndex = url.indexOf("&", valueIndex);
+                    return _decodeURI(url.slice(valueIndex, -1 === endIndex ? void 0 : endIndex));
+                }
+                if (38 == trailingKeyCode || isNaN(trailingKeyCode)) return "";
+                keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+            }
+            encoded = /[%+]/.test(url);
+            if (!encoded) return;
+        }
+        const results = {};
+        encoded ??= /[%+]/.test(url);
+        let keyIndex = url.indexOf("?", 8);
+        while(-1 !== keyIndex){
+            const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+            let valueIndex = url.indexOf("=", keyIndex);
+            if (valueIndex > nextKeyIndex && -1 !== nextKeyIndex) valueIndex = -1;
+            let name = url.slice(keyIndex + 1, -1 === valueIndex ? -1 === nextKeyIndex ? void 0 : nextKeyIndex : valueIndex);
+            if (encoded) name = _decodeURI(name);
+            keyIndex = nextKeyIndex;
+            if ("" === name) continue;
+            let value;
+            if (-1 === valueIndex) value = "";
+            else {
+                value = url.slice(valueIndex + 1, -1 === nextKeyIndex ? void 0 : nextKeyIndex);
+                if (encoded) value = _decodeURI(value);
+            }
+            if (multiple) {
+                if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
+                results[name].push(value);
+            } else results[name] ??= value;
+        }
+        return key ? results[key] : results;
+    };
+    var getQueryParam = _getQueryParam;
+    var getQueryParams = (url, key)=>_getQueryParam(url, key, true);
+    var decodeURIComponent_ = decodeURIComponent;
+    var HonoRequest = class {
+        raw;
+        #validatedData;
+        #matchResult;
+        routeIndex = 0;
+        path;
+        bodyCache = {};
+        constructor(request, path = "/", matchResult = [
+            []
+        ]){
+            this.raw = request;
+            this.path = path;
+            this.#matchResult = matchResult;
+            this.#validatedData = {};
+        }
+        param(key) {
+            return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+        }
+        getDecodedParam(key) {
+            const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+            const param = this.getParamValue(paramKey);
+            return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
+        }
+        getAllDecodedParams() {
+            const decoded = {};
+            const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+            for (const key of keys){
+                const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+                if (value && "string" == typeof value) decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
+            }
+            return decoded;
+        }
+        getParamValue(paramKey) {
+            return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+        }
+        query(key) {
+            return getQueryParam(this.url, key);
+        }
+        queries(key) {
+            return getQueryParams(this.url, key);
+        }
+        header(name) {
+            if (name) return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+            const headerData = {};
+            this.raw.headers.forEach((value, key)=>{
+                headerData[key] = value;
             });
+            return headerData;
         }
-        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);
+        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]();
             });
-            setHeaders(this.#headers, this.#preparedHeaders);
+            return bodyCache[key] = raw[key]();
+        };
+        json() {
+            return this.cachedBody("json");
         }
-        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);
+        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;
         }
-        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);
+    var HtmlEscapedCallbackPhase = {
+        Stringify: 1,
+        BeforeStream: 2,
+        Stream: 3
     };
-    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);
+    var html_raw = (value, callbacks)=>{
+        const escapedString = new String(value);
+        escapedString.isEscaped = true;
+        escapedString.callbacks = callbacks;
+        return escapedString;
     };
-    redirect = (location, status)=>{
-        this.#headers ??= new Headers();
-        this.#headers.set("Location", location);
-        return this.newResponse(null, status ?? 302);
+    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;
     };
-    notFound = ()=>{
-        this.#notFoundHandler ??= ()=>new Response();
-        return this.#notFoundHandler(this);
+    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 compose = (middleware, onError, onNotFound)=>(context, next)=>{
-        let index = -1;
-        return dispatch(0);
-        async function dispatch(i) {
-            if (i <= index) throw new Error("next() called multiple times");
-            index = i;
-            let res;
-            let isError = false;
-            let handler;
-            if (middleware[i]) {
-                handler = middleware[i][0][0];
-                if (context instanceof Context) context.req.routeIndex = i;
-            } else handler = i === middleware.length && next || void 0;
-            if (handler) try {
-                res = await handler(context, ()=>dispatch(i + 1));
-            } catch (err) {
-                if (err instanceof Error && context instanceof Context && onError) {
-                    context.error = err;
-                    res = await onError(err, context);
-                    isError = true;
-                } else throw err;
-            }
-            else if (context instanceof Context && false === context.finalized && onNotFound) res = await onNotFound(context);
-            if (res && (false === context.finalized || isError)) context.res = res;
-            return context;
+    var 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;
+            }
         }
-    };
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = [
-    "get",
-    "post",
-    "put",
-    "delete",
-    "options",
-    "patch"
-];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-var COMPOSED_HANDLER = Symbol("composedHandler");
-var notFoundHandler = (c)=>c.text("404 Not Found", 404);
-var errorHandler = (err, c)=>{
-    if ("getResponse" in err) return err.getResponse();
-    console.error(err);
-    return c.text("Internal Server Error", 500);
-};
-var Hono = class {
-    get;
-    post;
-    put;
-    delete;
-    options;
-    patch;
-    all;
-    on;
-    use;
-    router;
-    getPath;
-    _basePath = "/";
-    #path = "/";
-    routes = [];
-    constructor(options = {}){
-        const allMethods = [
-            ...METHODS,
-            METHOD_NAME_ALL_LOWERCASE
-        ];
-        allMethods.forEach((method)=>{
-            this[method] = (args1, ...args)=>{
-                if ("string" == typeof args1) this.#path = args1;
-                else this.addRoute(method, this.#path, args1);
-                args.forEach((handler)=>{
-                    if ("string" != typeof handler) this.addRoute(method, this.#path, handler);
-                });
-                return this;
-            };
-        });
-        this.on = (method, path, ...handlers)=>{
-            for (const p of [
-                path
-            ].flat()){
-                this.#path = p;
-                for (const m of [
-                    method
-                ].flat())handlers.map((handler)=>{
-                    this.addRoute(m.toUpperCase(), this.#path, handler);
-                });
+        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;
             }
-            return this;
+            this.#res = _res;
+            this.finalized = true;
+        }
+        render = (...args)=>{
+            this.#renderer ??= (content)=>this.html(content);
+            return this.#renderer(...args);
         };
-        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;
+        setLayout = (layout)=>this.#layout = layout;
+        getLayout = ()=>this.#layout;
+        setRenderer = (renderer)=>{
+            this.#renderer = renderer;
         };
-        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;
+        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;
             }
-            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;
+            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 {
-                optionHandler = options.optionHandler;
-                replaceRequest = options.replaceRequest;
+                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);
             }
-        }
-        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);
+        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
                 });
-            } 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);
+            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);
             }
-        })();
-    }
-    fetch = (request, ...rest)=>this.dispatch(request, rest[1], rest[0], request.method);
-    request = (input, requestInit, Env, executionCtx)=>{
-        if (input instanceof Request) {
-            if (void 0 !== requestInit) input = new Request(input, requestInit);
-            return this.fetch(input, Env, executionCtx);
-        }
-        input = input.toString();
-        const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-        const req = new Request(path, requestInit);
-        return this.fetch(req, Env, executionCtx);
-    };
-    fire = ()=>{
-        addEventListener("fetch", (event)=>{
-            event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
-        });
-    };
-};
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = Symbol();
-var regExpMetaChars = new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-    if (1 === a.length) return 1 === b.length ? a < b ? -1 : 1 : -1;
-    if (1 === b.length) return 1;
-    if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) return 1;
-    if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) return -1;
-    if (a === LABEL_REG_EXP_STR) return 1;
-    if (b === LABEL_REG_EXP_STR) return -1;
-    return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-}
-var Node = class {
-    index;
-    varIndex;
-    children = /* @__PURE__ */ Object.create(null);
-    insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-        if (0 === tokens.length) {
-            if (void 0 !== this.index) throw PATH_ERROR;
-            if (pathErrorCheckOnly) return;
-            this.index = index;
-            return;
-        }
-        const [token, ...restTokens] = tokens;
-        const pattern = "*" === token ? 0 === restTokens.length ? [
-            "",
-            "",
-            ONLY_WILDCARD_REG_EXP_STR
-        ] : [
-            "",
-            "",
-            LABEL_REG_EXP_STR
-        ] : "/*" === token ? [
-            "",
-            "",
-            TAIL_WILDCARD_REG_EXP_STR
-        ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-        let node;
-        if (pattern) {
-            const name = pattern[1];
-            let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-            if (name && pattern[2]) {
-                regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-                if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
-            }
-            node = this.children[regexpStr];
-            if (!node) {
-                if (Object.keys(this.children).some((k)=>k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
-                if (pathErrorCheckOnly) return;
-                node = this.children[regexpStr] = new Node();
-                if ("" !== name) node.varIndex = context.varIndex++;
+            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);
             }
-            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();
+            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 = {};
             }
-        }
-        node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-    }
-    buildRegExpStr() {
-        const childKeys = Object.keys(this.children).sort(compareKey);
-        const strList = childKeys.map((k)=>{
-            const c = this.children[k];
-            return ("number" == typeof c.varIndex ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-        });
-        if ("number" == typeof this.index) strList.unshift(`#${this.index}`);
-        if (0 === strList.length) return "";
-        if (1 === strList.length) return strList[0];
-        return "(?:" + strList.join("|") + ")";
-    }
-};
-var Trie = class {
-    context = {
-        varIndex: 0
+            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);
+        };
     };
-    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;
+    var compose = (middleware, onError, onNotFound)=>(context, next)=>{
+            let index = -1;
+            return dispatch(0);
+            async function dispatch(i) {
+                if (i <= index) throw new Error("next() called multiple times");
+                index = i;
+                let res;
+                let isError = false;
+                let handler;
+                if (middleware[i]) {
+                    handler = middleware[i][0][0];
+                    if (context instanceof Context) context.req.routeIndex = i;
+                } else handler = i === middleware.length && next || void 0;
+                if (handler) try {
+                    res = await handler(context, ()=>dispatch(i + 1));
+                } catch (err) {
+                    if (err instanceof Error && context instanceof Context && onError) {
+                        context.error = err;
+                        res = await onError(err, context);
+                        isError = true;
+                    } else throw err;
+                }
+                else if (context instanceof Context && false === context.finalized && onNotFound) res = await onNotFound(context);
+                if (res && (false === context.finalized || isError)) context.res = res;
+                return context;
             }
+        };
+    var METHOD_NAME_ALL = "ALL";
+    var METHOD_NAME_ALL_LOWERCASE = "all";
+    var METHODS = [
+        "get",
+        "post",
+        "put",
+        "delete",
+        "options",
+        "patch"
+    ];
+    var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+    var UnsupportedPathError = class extends Error {
+    };
+    var COMPOSED_HANDLER = Symbol("composedHandler");
+    var notFoundHandler = (c)=>c.text("404 Not Found", 404);
+    var errorHandler = (err, c)=>{
+        if ("getResponse" in err) return err.getResponse();
+        console.error(err);
+        return c.text("Internal Server Error", 500);
+    };
+    var Hono = class {
+        get;
+        post;
+        put;
+        delete;
+        options;
+        patch;
+        all;
+        on;
+        use;
+        router;
+        getPath;
+        _basePath = "/";
+        #path = "/";
+        routes = [];
+        constructor(options = {}){
+            const allMethods = [
+                ...METHODS,
+                METHOD_NAME_ALL_LOWERCASE
+            ];
+            allMethods.forEach((method)=>{
+                this[method] = (args1, ...args)=>{
+                    if ("string" == typeof args1) this.#path = args1;
+                    else this.addRoute(method, this.#path, args1);
+                    args.forEach((handler)=>{
+                        if ("string" != typeof handler) this.addRoute(method, this.#path, handler);
+                    });
+                    return this;
+                };
+            });
+            this.on = (method, path, ...handlers)=>{
+                for (const p of [
+                    path
+                ].flat()){
+                    this.#path = p;
+                    for (const m of [
+                        method
+                    ].flat())handlers.map((handler)=>{
+                        this.addRoute(m.toUpperCase(), this.#path, handler);
+                    });
+                }
+                return this;
+            };
+            this.use = (arg1, ...handlers)=>{
+                if ("string" == typeof arg1) this.#path = arg1;
+                else {
+                    this.#path = "*";
+                    handlers.unshift(arg1);
+                }
+                handlers.forEach((handler)=>{
+                    this.addRoute(METHOD_NAME_ALL, this.#path, handler);
+                });
+                return this;
+            };
+            const strict = options.strict ?? true;
+            delete options.strict;
+            Object.assign(this, options);
+            this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
         }
-        this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
-        return paramAssoc;
-    }
-    buildRegExp() {
-        let regexp = this.root.buildRegExpStr();
-        if ("" === regexp) return [
-            /^$/,
-            [],
-            []
-        ];
-        let captureIndex = 0;
-        const indexReplacementMap = [];
-        const paramReplacementMap = [];
-        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex)=>{
-            if (void 0 !== handlerIndex) {
-                indexReplacementMap[++captureIndex] = Number(handlerIndex);
-                return "$()";
-            }
-            if (void 0 !== paramIndex) paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-            return "";
-        });
-        return [
-            new RegExp(`^${regexp}`),
-            indexReplacementMap,
-            paramReplacementMap
-        ];
-    }
-};
-var emptyParam = [];
-var nullMatcher = [
-    /^$/,
-    [],
-    /* @__PURE__ */ Object.create(null)
-];
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path) {
-    return wildcardRegExpCache[path] ??= new RegExp("*" === path ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar)=>metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
-}
-function clearWildcardRegExpCache() {
-    wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
-function buildMatcherFromPreprocessedRoutes(routes) {
-    const trie = new Trie();
-    const handlerData = [];
-    if (0 === routes.length) return nullMatcher;
-    const routesWithStaticPathFlag = routes.map((route)=>[
-            !/\*|\/:/.test(route[0]),
-            ...route
-        ]).sort(([isStaticA, pathA], [isStaticB, pathB])=>isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
-    const staticMap = /* @__PURE__ */ Object.create(null);
-    for(let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++){
-        const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-        if (pathErrorCheckOnly) staticMap[path] = [
-            handlers.map(([h])=>[
-                    h,
-                    /* @__PURE__ */ Object.create(null)
-                ]),
-            emptyParam
-        ];
-        else j++;
-        let paramAssoc;
-        try {
-            paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-        } catch (e) {
-            throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-        }
-        if (!pathErrorCheckOnly) handlerData[j] = handlers.map(([h, paramCount])=>{
-            const paramIndexMap = /* @__PURE__ */ Object.create(null);
-            paramCount -= 1;
-            for(; paramCount >= 0; paramCount--){
-                const [key, value] = paramAssoc[paramCount];
-                paramIndexMap[key] = value;
-            }
-            return [
-                h,
-                paramIndexMap
-            ];
-        });
-    }
-    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-    for(let i = 0, len = handlerData.length; i < len; i++)for(let j = 0, len2 = handlerData[i].length; j < len2; j++){
-        const map = handlerData[i][j]?.[1];
-        if (!map) continue;
-        const keys = Object.keys(map);
-        for(let k = 0, len3 = keys.length; k < len3; k++)map[keys[k]] = paramReplacementMap[map[keys[k]]];
-    }
-    const handlerMap = [];
-    for(const i in indexReplacementMap)handlerMap[i] = handlerData[indexReplacementMap[i]];
-    return [
-        regexp,
-        handlerMap,
-        staticMap
-    ];
-}
-function findMiddleware(middleware, path) {
-    if (!middleware) return;
-    for (const k of Object.keys(middleware).sort((a, b)=>b.length - a.length))if (buildWildcardRegExp(k).test(path)) return [
-        ...middleware[k]
-    ];
-}
-var RegExpRouter = class {
-    name = "RegExpRouter";
-    middleware;
-    routes;
-    constructor(){
-        this.middleware = {
-            [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
+        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;
         };
-        this.routes = {
-            [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
+        notFound = (handler)=>{
+            this.notFoundHandler = handler;
+            return this;
         };
-    }
-    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]
+        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
             });
-        });
-        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) || [];
+            const matchResult = this.matchRoute(method, path);
+            const c = new Context(request, {
+                path,
+                matchResult,
+                env,
+                executionCtx,
+                notFoundHandler: this.notFoundHandler
             });
-            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
-                    ]);
-                });
+            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));
             });
-            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
-                    ]));
+        };
+    };
+    var LABEL_REG_EXP_STR = "[^/]+";
+    var ONLY_WILDCARD_REG_EXP_STR = ".*";
+    var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+    var PATH_ERROR = Symbol();
+    var regExpMetaChars = new Set(".\\+*[^]$()");
+    function compareKey(a, b) {
+        if (1 === a.length) return 1 === b.length ? a < b ? -1 : 1 : -1;
+        if (1 === b.length) return 1;
+        if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) return 1;
+        if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) return -1;
+        if (a === LABEL_REG_EXP_STR) return 1;
+        if (b === LABEL_REG_EXP_STR) return -1;
+        return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+    }
+    var Node = class {
+        index;
+        varIndex;
+        children = /* @__PURE__ */ Object.create(null);
+        insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+            if (0 === tokens.length) {
+                if (void 0 !== this.index) throw PATH_ERROR;
+                if (pathErrorCheckOnly) return;
+                this.index = index;
+                return;
+            }
+            const [token, ...restTokens] = tokens;
+            const pattern = "*" === token ? 0 === restTokens.length ? [
+                "",
+                "",
+                ONLY_WILDCARD_REG_EXP_STR
+            ] : [
+                "",
+                "",
+                LABEL_REG_EXP_STR
+            ] : "/*" === token ? [
+                "",
+                "",
+                TAIL_WILDCARD_REG_EXP_STR
+            ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+            let node;
+            if (pattern) {
+                const name = pattern[1];
+                let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+                if (name && pattern[2]) {
+                    regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+                    if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
+                }
+                node = this.children[regexpStr];
+                if (!node) {
+                    if (Object.keys(this.children).some((k)=>k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
+                    if (pathErrorCheckOnly) return;
+                    node = this.children[regexpStr] = new Node();
+                    if ("" !== name) node.varIndex = context.varIndex++;
+                }
+                if (!pathErrorCheckOnly && "" !== name) paramMap.push([
+                    name,
+                    node.varIndex
+                ]);
+            } else {
+                node = this.children[token];
+                if (!node) {
+                    if (Object.keys(this.children).some((k)=>k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
+                    if (pathErrorCheckOnly) return;
+                    node = this.children[token] = new Node();
+                }
+            }
+            node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+        }
+        buildRegExpStr() {
+            const childKeys = Object.keys(this.children).sort(compareKey);
+            const strList = childKeys.map((k)=>{
+                const c = this.children[k];
+                return ("number" == typeof c.varIndex ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
             });
-            return;
+            if ("number" == typeof this.index) strList.unshift(`#${this.index}`);
+            if (0 === strList.length) return "";
+            if (1 === strList.length) return strList[0];
+            return "(?:" + strList.join("|") + ")";
         }
-        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) || []
+    };
+    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
                     ];
-                    routes[m][path2].push([
-                        handler,
-                        paramCount - len + i + 1
-                    ]);
+                    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;
         }
-    }
-    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 [
+        buildRegExp() {
+            let regexp = this.root.buildRegExpStr();
+            if ("" === regexp) return [
+                /^$/,
                 [],
-                emptyParam
+                []
             ];
-            const index = match.indexOf("", 1);
+            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 [
-                matcher[1][index],
-                match
+                new RegExp(`^${regexp}`),
+                indexReplacementMap,
+                paramReplacementMap
             ];
-        };
-        return this.match(method, path);
-    }
-    buildAllMatchers() {
-        const matchers = /* @__PURE__ */ Object.create(null);
-        [
-            ...Object.keys(this.routes),
-            ...Object.keys(this.middleware)
-        ].forEach((method)=>{
-            matchers[method] ||= this.buildMatcher(method);
-        });
-        this.middleware = this.routes = void 0;
-        return matchers;
-    }
-    buildMatcher(method) {
-        const routes = [];
-        let hasOwnRoute = method === METHOD_NAME_ALL;
-        [
-            this.middleware,
-            this.routes
-        ].forEach((r)=>{
-            const ownRoute = r[method] ? Object.keys(r[method]).map((path)=>[
-                    path,
-                    r[method][path]
-                ]) : [];
-            if (0 !== ownRoute.length) {
-                hasOwnRoute ||= true;
-                routes.push(...ownRoute);
-            } else if (method !== METHOD_NAME_ALL) routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path)=>[
-                    path,
-                    r[METHOD_NAME_ALL][path]
-                ]));
-        });
-        if (!hasOwnRoute) return null;
-        return buildMatcherFromPreprocessedRoutes(routes);
-    }
-};
-var SmartRouter = class {
-    name = "SmartRouter";
-    routers = [];
-    routes = [];
-    constructor(init){
-        Object.assign(this, init);
-    }
-    add(method, path, handler) {
-        if (!this.routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-        this.routes.push([
-            method,
-            path,
-            handler
-        ]);
-    }
-    match(method, path) {
-        if (!this.routes) throw new Error("Fatal error");
-        const { routers, routes } = this;
-        const len = routers.length;
-        let i = 0;
-        let res;
-        for(; i < len; i++){
-            const router = routers[i];
+        }
+    };
+    var emptyParam = [];
+    var nullMatcher = [
+        /^$/,
+        [],
+        /* @__PURE__ */ Object.create(null)
+    ];
+    var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+    function buildWildcardRegExp(path) {
+        return wildcardRegExpCache[path] ??= new RegExp("*" === path ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar)=>metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
+    }
+    function clearWildcardRegExpCache() {
+        wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+    }
+    function buildMatcherFromPreprocessedRoutes(routes) {
+        const trie = new Trie();
+        const handlerData = [];
+        if (0 === routes.length) return nullMatcher;
+        const routesWithStaticPathFlag = routes.map((route)=>[
+                !/\*|\/:/.test(route[0]),
+                ...route
+            ]).sort(([isStaticA, pathA], [isStaticB, pathB])=>isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
+        const staticMap = /* @__PURE__ */ Object.create(null);
+        for(let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++){
+            const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
+            if (pathErrorCheckOnly) staticMap[path] = [
+                handlers.map(([h])=>[
+                        h,
+                        /* @__PURE__ */ Object.create(null)
+                    ]),
+                emptyParam
+            ];
+            else j++;
+            let paramAssoc;
             try {
-                routes.forEach((args)=>{
-                    router.add(...args);
-                });
-                res = router.match(method, path);
+                paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
             } catch (e) {
-                if (e instanceof UnsupportedPathError) continue;
-                throw e;
+                throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
             }
-            this.match = router.match.bind(router);
-            this.routers = [
-                router
-            ];
-            this.routes = void 0;
-            break;
+            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]]];
         }
-        if (i === len) throw new Error("Fatal error");
-        this.name = `SmartRouter + ${this.activeRouter.name}`;
-        return res;
+        const handlerMap = [];
+        for(const i in indexReplacementMap)handlerMap[i] = handlerData[indexReplacementMap[i]];
+        return [
+            regexp,
+            handlerMap,
+            staticMap
+        ];
     }
-    get activeRouter() {
-        if (this.routes || 1 !== this.routers.length) throw new Error("No active router has been determined yet.");
-        return this.routers[0];
+    function findMiddleware(middleware, path) {
+        if (!middleware) return;
+        for (const k of Object.keys(middleware).sort((a, b)=>b.length - a.length))if (buildWildcardRegExp(k).test(path)) return [
+            ...middleware[k]
+        ];
     }
-};
-var 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
+    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)
             };
-            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;
+        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]
+                    ];
                 });
-                handlerSets.push(handlerSet);
+            });
+            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;
             }
-        }
-        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);
-                            }
-                        }
+            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
+                        ]);
                     }
-                }
+                });
             }
-            curNodes = tempNodes;
         }
-        const results = handlerSets.sort((a, b)=>a.score - b.score);
-        return [
-            results.map(({ handler, params })=>[
-                    handler,
-                    params
-                ])
-        ];
-    }
-};
-var TrieRouter = class {
-    name = "TrieRouter";
-    node;
-    constructor(){
-        this.node = new node_Node();
-    }
-    add(method, path, handler) {
-        const results = checkOptionalParameter(path);
-        if (results) {
-            for (const p of results)this.node.insert(method, p, handler);
-            return;
+        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);
         }
-        this.node.insert(method, path, handler);
-    }
-    match(method, path) {
-        return this.node.search(method, path);
-    }
-};
-var hono_Hono = class extends Hono {
-    constructor(options = {}){
-        super(options);
-        this.router = options.router ?? new SmartRouter({
-            routers: [
-                new RegExpRouter(),
-                new TrieRouter()
-            ]
-        });
-    }
-};
-var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-var parse = (cookie, name)=>{
-    const pairs = cookie.trim().split(";");
-    return pairs.reduce((parsedCookie, pairStr)=>{
-        pairStr = pairStr.trim();
-        const valueStartPos = pairStr.indexOf("=");
-        if (-1 === valueStartPos) return parsedCookie;
-        const cookieName = pairStr.substring(0, valueStartPos).trim();
-        if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) return parsedCookie;
-        let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-        if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) cookieValue = cookieValue.slice(1, -1);
-        if (validCookieValueRegEx.test(cookieValue)) parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
-        return parsedCookie;
-    }, {});
-};
-var getCookie = (c, key, prefix)=>{
-    const cookie = c.req.raw.headers.get("Cookie");
-    if ("string" == typeof key) {
-        if (!cookie) return;
-        let finalKey = key;
-        if ("secure" === prefix) finalKey = "__Secure-" + key;
-        else if ("host" === prefix) finalKey = "__Host-" + key;
-        const obj2 = parse(cookie, finalKey);
-        return obj2[finalKey];
-    }
-    if (!cookie) return {};
-    const obj = parse(cookie);
-    return obj;
-};
-var HTTPException = class extends Error {
-    res;
-    status;
-    constructor(status = 500, options){
-        super(options?.message, {
-            cause: options?.cause
-        });
-        this.res = options?.res;
-        this.status = status;
-    }
-    getResponse() {
-        if (this.res) {
-            const newResponse = new Response(this.res.body, {
-                status: this.status,
-                headers: this.res.headers
+        buildAllMatchers() {
+            const matchers = /* @__PURE__ */ Object.create(null);
+            [
+                ...Object.keys(this.routes),
+                ...Object.keys(this.middleware)
+            ].forEach((method)=>{
+                matchers[method] ||= this.buildMatcher(method);
             });
-            return newResponse;
+            this.middleware = this.routes = void 0;
+            return matchers;
         }
-        return new Response(this.message, {
-            status: this.status
-        });
-    }
-};
-var bufferToFormData = (arrayBuffer, contentType)=>{
-    const response = new Response(arrayBuffer, {
-        headers: {
-            "Content-Type": contentType
+        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);
         }
-    });
-    return response.formData();
-};
-var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
-var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-var validator = (target, validationFunc)=>async (c, next)=>{
-        let value = {};
-        const contentType = c.req.header("Content-Type");
-        switch(target){
-            case "json":
-                if (!contentType || !jsonRegex.test(contentType)) break;
+    };
+    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 {
-                    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;
+                    routes.forEach((args)=>{
+                        router.add(...args);
                     });
-                    value = form;
-                    break;
+                    res = router.match(method, path);
+                } catch (e) {
+                    if (e instanceof UnsupportedPathError) continue;
+                    throw e;
                 }
-            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);
+                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;
         }
-        const res = await validationFunc(value, c);
-        if (res instanceof Response) return res;
-        c.req.addValidatedData(target, res);
-        await next();
-    };
-var store;
-function getGlobalConfig(config2) {
-    return {
-        lang: config2?.lang ?? store?.lang,
-        message: config2?.message,
-        abortEarly: config2?.abortEarly ?? store?.abortEarly,
-        abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
-    };
-}
-var store2;
-function getGlobalMessage(lang) {
-    return store2?.get(lang);
-}
-var store3;
-function getSchemaMessage(lang) {
-    return store3?.get(lang);
-}
-var store4;
-function getSpecificMessage(reference, lang) {
-    return store4?.get(reference)?.get(lang);
-}
-function _stringify(input) {
-    const type = typeof input;
-    if ("string" === type) return `"${input}"`;
-    if ("number" === type || "bigint" === type || "boolean" === type) return `${input}`;
-    if ("object" === type || "function" === type) return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-    return type;
-}
-function _addIssue(context, label, dataset, config2, other) {
-    const input = other && "input" in other ? other.input : dataset.value;
-    const expected = other?.expected ?? context.expects ?? null;
-    const received = other?.received ?? _stringify(input);
-    const issue = {
-        kind: context.kind,
-        type: context.type,
-        input,
-        expected,
-        received,
-        message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-        requirement: context.requirement,
-        path: other?.path,
-        issues: other?.issues,
-        lang: config2.lang,
-        abortEarly: config2.abortEarly,
-        abortPipeEarly: config2.abortPipeEarly
-    };
-    const isSchema = "schema" === context.kind;
-    const message = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
-    if (message) issue.message = "function" == typeof message ? message(issue) : message;
-    if (isSchema) dataset.typed = false;
-    if (dataset.issues) dataset.issues.push(issue);
-    else dataset.issues = [
-        issue
-    ];
-}
-function _joinExpects(values, separator) {
-    const list = [
-        ...new Set(values)
-    ];
-    if (list.length > 1) return `(${list.join(` ${separator} `)})`;
-    return list[0] ?? "never";
-}
-function getDefault(schema, dataset, config2) {
-    return "function" == typeof schema.default ? schema.default(dataset, config2) : schema.default;
-}
-function dist_boolean(message) {
-    return {
-        kind: "schema",
-        type: "boolean",
-        reference: dist_boolean,
-        expects: "boolean",
-        async: false,
-        message,
-        _run (dataset, config2) {
-            if ("boolean" == typeof dataset.value) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
+        get activeRouter() {
+            if (this.routes || 1 !== this.routers.length) throw new Error("No active router has been determined yet.");
+            return this.routers[0];
         }
     };
-}
-function literal(literal_, message) {
-    return {
-        kind: "schema",
-        type: "literal",
-        reference: literal,
-        expects: _stringify(literal_),
-        async: false,
-        literal: literal_,
-        message,
-        _run (dataset, config2) {
-            if (dataset.value === this.literal) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
+    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 = [];
         }
-    };
-}
-function nullable(wrapped, ...args) {
-    const schema = {
-        kind: "schema",
-        type: "nullable",
-        reference: nullable,
-        expects: `(${wrapped.expects} | null)`,
-        async: false,
-        wrapped,
-        _run (dataset, config2) {
-            if (null === dataset.value) {
-                if ("default" in this) dataset.value = getDefault(this, dataset, config2);
-                if (null === dataset.value) {
-                    dataset.typed = true;
-                    return dataset;
+        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];
             }
-            return this.wrapped._run(dataset, config2);
+            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;
         }
-    };
-    if (0 in args) schema.default = args[0];
-    return schema;
-}
-function dist_object(entries, message) {
-    return {
-        kind: "schema",
-        type: "object",
-        reference: dist_object,
-        expects: "Object",
-        async: false,
-        entries,
-        message,
-        _run (dataset, config2) {
-            const input = dataset.value;
-            if (input && "object" == typeof input) {
-                dataset.typed = true;
-                dataset.value = {};
-                for(const key in this.entries){
-                    const value2 = input[key];
-                    const valueDataset = this.entries[key]._run({
-                        typed: false,
-                        value: value2
-                    }, config2);
-                    if (valueDataset.issues) {
-                        const pathItem = {
-                            type: "object",
-                            origin: "value",
-                            input,
-                            key,
-                            value: value2
+        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
                         };
-                        for (const issue of valueDataset.issues){
-                            if (issue.path) issue.path.unshift(pathItem);
-                            else issue.path = [
-                                pathItem
-                            ];
-                            dataset.issues?.push(issue);
+                        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 (!dataset.issues) dataset.issues = valueDataset.issues;
-                        if (config2.abortEarly) {
-                            dataset.typed = false;
-                            break;
+                        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);
+                                }
+                            }
                         }
                     }
-                    if (!valueDataset.typed) dataset.typed = false;
-                    if (void 0 !== valueDataset.value || key in input) dataset.value[key] = valueDataset.value;
                 }
-            } else _addIssue(this, "type", dataset, config2);
-            return dataset;
+                curNodes = tempNodes;
+            }
+            const results = handlerSets.sort((a, b)=>a.score - b.score);
+            return [
+                results.map(({ handler, params })=>[
+                        handler,
+                        params
+                    ])
+            ];
         }
     };
-}
-function optional(wrapped, ...args) {
-    const schema = {
-        kind: "schema",
-        type: "optional",
-        reference: optional,
-        expects: `(${wrapped.expects} | undefined)`,
-        async: false,
-        wrapped,
-        _run (dataset, config2) {
-            if (void 0 === dataset.value) {
-                if ("default" in this) dataset.value = getDefault(this, dataset, config2);
-                if (void 0 === dataset.value) {
-                    dataset.typed = true;
-                    return dataset;
-                }
+    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;
             }
-            return this.wrapped._run(dataset, config2);
+            this.node.insert(method, path, handler);
+        }
+        match(method, path) {
+            return this.node.search(method, path);
         }
     };
-    if (0 in args) schema.default = args[0];
-    return schema;
-}
-function string(message) {
-    return {
-        kind: "schema",
-        type: "string",
-        reference: string,
-        expects: "string",
-        async: false,
-        message,
-        _run (dataset, config2) {
-            if ("string" == typeof dataset.value) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
+    var hono_Hono = class extends Hono {
+        constructor(options = {}){
+            super(options);
+            this.router = options.router ?? new SmartRouter({
+                routers: [
+                    new RegExpRouter(),
+                    new TrieRouter()
+                ]
+            });
         }
     };
-}
-function _subIssues(datasets) {
-    let issues;
-    if (datasets) for (const dataset of datasets)if (issues) issues.push(...dataset.issues);
-    else issues = dataset.issues;
-    return issues;
-}
-function union(options, message) {
-    return {
-        kind: "schema",
-        type: "union",
-        reference: union,
-        expects: _joinExpects(options.map((option)=>option.expects), "|"),
-        async: false,
-        options,
-        message,
-        _run (dataset, config2) {
-            let validDataset;
-            let typedDatasets;
-            let untypedDatasets;
-            for (const schema of this.options){
-                const optionDataset = schema._run({
-                    typed: false,
-                    value: dataset.value
-                }, config2);
-                if (optionDataset.typed) {
-                    if (optionDataset.issues) {
-                        if (typedDatasets) typedDatasets.push(optionDataset);
-                        else typedDatasets = [
-                            optionDataset
-                        ];
-                    } else {
-                        validDataset = optionDataset;
-                        break;
-                    }
-                } else if (untypedDatasets) untypedDatasets.push(optionDataset);
-                else untypedDatasets = [
-                    optionDataset
-                ];
+    var _validateReport = __webpack_require__("../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3/node_modules/typia/lib/internal/_validateReport.js");
+    var cjs = __webpack_require__("../../node_modules/.pnpm/@hono+typia-validator@0.1.0_hono@4.6.3_typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3_/node_modules/@hono/typia-validator/dist/cjs/index.js");
+    const plugin_core_namespaceObject = require("@hot-updater/plugin-core");
+    const bundleIdValidator = (()=>{
+        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
+                };
             }
-            if (validDataset) return validDataset;
-            if (typedDatasets) {
-                if (1 === typedDatasets.length) return typedDatasets[0];
-                _addIssue(this, "type", dataset, config2, {
-                    issues: _subIssues(typedDatasets)
-                });
-                dataset.typed = true;
-            } else {
-                if (untypedDatasets?.length === 1) return untypedDatasets[0];
-                _addIssue(this, "type", dataset, config2, {
-                    issues: _subIssues(untypedDatasets)
-                });
+            return {
+                success: true,
+                data: input
+            };
+        };
+    })();
+    const updateBundleValidator = (()=>{
+        const _io0 = (input)=>"string" == typeof input.targetBundleId && "object" == typeof input.bundle && null !== input.bundle && false === Array.isArray(input.bundle) && _io1(input.bundle);
+        const _io1 = (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.fileUrl || "string" == typeof input.fileUrl) && (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);
+        const _vo0 = (input, _path, _exceptionable = true)=>[
+                "string" == typeof input.targetBundleId || _report(_exceptionable, {
+                    path: _path + ".targetBundleId",
+                    expected: "string",
+                    value: input.targetBundleId
+                }),
+                ("object" == typeof input.bundle && null !== input.bundle && false === Array.isArray(input.bundle) || _report(_exceptionable, {
+                    path: _path + ".bundle",
+                    expected: "Partial<Bundle>",
+                    value: input.bundle
+                })) && _vo1(input.bundle, _path + ".bundle", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".bundle",
+                    expected: "Partial<Bundle>",
+                    value: input.bundle
+                })
+            ].every((flag)=>flag);
+        const _vo1 = (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.fileUrl || "string" == typeof input.fileUrl || _report(_exceptionable, {
+                    path: _path + ".fileUrl",
+                    expected: "(string | undefined)",
+                    value: input.fileUrl
+                }),
+                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
+                })
+            ].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 dataset;
+            return {
+                success: true,
+                data: input
+            };
+        };
+    })();
+    let rpc_config = null;
+    let rpc_databasePlugin = null;
+    const prepareConfig = async ()=>{
+        if (!rpc_config) {
+            rpc_config = await (0, plugin_core_namespaceObject.loadConfig)({
+                platform: "console"
+            });
+            rpc_databasePlugin = await rpc_config?.database({
+                cwd: plugin_core_namespaceObject.getCwd()
+            }) ?? null;
         }
+        return {
+            config: rpc_config,
+            databasePlugin: rpc_databasePlugin
+        };
     };
-}
-function omit(schema, keys) {
-    const entries = {
-        ...schema.entries
-    };
-    for (const key of keys)delete entries[key];
-    return {
-        ...schema,
-        entries
-    };
-}
-function partial(schema, keys) {
-    const entries = {};
-    for(const key in schema.entries)entries[key] = !keys || keys.includes(key) ? optional(schema.entries[key]) : schema.entries[key];
-    return {
-        ...schema,
-        entries
-    };
-}
-async function safeParseAsync(schema, input, config2) {
-    const dataset = await schema._run({
-        typed: false,
-        value: input
-    }, getGlobalConfig(config2));
-    return {
-        typed: dataset.typed,
-        success: !dataset.issues,
-        output: dataset.value,
-        issues: dataset.issues
-    };
-}
-var vValidator = (target, schema, hook)=>validator(target, async (value, c)=>{
-        const result = await safeParseAsync(schema, value);
-        if (hook) {
-            const hookResult = hook(result, c);
-            if (hookResult instanceof Response || hookResult instanceof Promise) return hookResult;
-        }
-        if (!result.success) return c.json(result, 400);
-        const data = result.output;
-        return data;
-    });
-const plugin_core_namespaceObject = require("@hot-updater/plugin-core");
-const bundleSchema = dist_object({
-    platform: union([
-        literal("ios"),
-        literal("android")
-    ]),
-    targetAppVersion: string(),
-    id: string(),
-    shouldForceUpdate: dist_boolean(),
-    enabled: dist_boolean(),
-    fileUrl: string(),
-    fileHash: string(),
-    gitCommitHash: nullable(string()),
-    message: nullable(string())
-});
-let rpc_config = null;
-let rpc_databasePlugin = null;
-const prepareConfig = async ()=>{
-    if (!rpc_config) {
-        rpc_config = await (0, plugin_core_namespaceObject.loadConfig)({
-            platform: "console"
+    const rpc = new hono_Hono().get("/getConfig", async (c)=>{
+        const { config } = await prepareConfig();
+        return c.json({
+            console: config?.console
         });
-        rpc_databasePlugin = await rpc_config?.database({
-            cwd: plugin_core_namespaceObject.getCwd()
-        }) ?? null;
-    }
-    return {
-        config: rpc_config,
-        databasePlugin: rpc_databasePlugin
-    };
-};
-const rpc = new hono_Hono().get("/getConfig", async (c)=>{
-    const { config } = await prepareConfig();
-    return c.json({
-        console: config?.console
+    }).get("/isConfigLoaded", (c)=>c.json(null !== rpc_config)).get("/getBundles", async (c)=>{
+        const { databasePlugin } = await prepareConfig();
+        const bundles = await databasePlugin?.getBundles(true);
+        return c.json(bundles ?? []);
+    }).get("/getBundleById", (0, cjs.typiaValidator)("query", bundleIdValidator), async (c)=>{
+        const { bundleId } = c.req.valid("query");
+        const { databasePlugin } = await prepareConfig();
+        const bundle = await databasePlugin?.getBundleById(bundleId);
+        return c.json(bundle ?? null);
+    }).post("/updateBundle", (0, cjs.typiaValidator)("json", updateBundleValidator), async (c)=>{
+        const { targetBundleId, bundle } = c.req.valid("json");
+        const { databasePlugin } = await prepareConfig();
+        await databasePlugin?.updateBundle(targetBundleId, bundle);
+        await databasePlugin?.commitBundle();
+        return c.json(true);
     });
-}).get("/isConfigLoaded", (c)=>c.json(null !== rpc_config)).get("/getBundles", async (c)=>{
-    const { databasePlugin } = await prepareConfig();
-    const bundles = await databasePlugin?.getBundles(true);
-    return c.json(bundles ?? []);
-}).get("/getBundleById", vValidator("query", dist_object({
-    bundleId: string()
-})), async (c)=>{
-    const { bundleId } = c.req.valid("query");
-    const { databasePlugin } = await prepareConfig();
-    const bundle = await databasePlugin?.getBundleById(bundleId);
-    return c.json(bundle ?? null);
-}).post("/updateBundle", vValidator("json", dist_object({
-    targetBundleId: string(),
-    bundle: partial(omit(bundleSchema, [
-        "id"
-    ]))
-})), async (c)=>{
-    const { targetBundleId, bundle } = c.req.valid("json");
-    const { databasePlugin } = await prepareConfig();
-    await databasePlugin?.updateBundle(targetBundleId, bundle);
-    await databasePlugin?.commitBundle();
-    return c.json(true);
-});
-const src_server_rslib_entry_dirname = external_path_default().dirname((0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
-const relativePathToScript = external_path_default().relative(process.cwd(), src_server_rslib_entry_dirname);
-const src_server_rslib_entry_app = new hono_Hono().get("/ping", (c)=>c.text("pong")).route("/rpc", rpc).use("/assets/*", serveStatic({
-    root: relativePathToScript
-})).get("*", serveStatic({
-    root: relativePathToScript,
-    path: "index.html"
-}));
-const src_server_rslib_entry_ = src_server_rslib_entry_app;
+    const src_server_rslib_entry_dirname = external_path_default().dirname((0, external_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+    const relativePathToScript = external_path_default().relative(process.cwd(), src_server_rslib_entry_dirname);
+    const src_server_rslib_entry_app = new hono_Hono().get("/ping", (c)=>c.text("pong")).route("/rpc", rpc).use("/assets/*", serveStatic({
+        root: relativePathToScript
+    })).get("*", serveStatic({
+        root: relativePathToScript,
+        path: "index.html"
+    }));
+    const src_server_rslib_entry_ = src_server_rslib_entry_app;
+})();
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
 if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {