@hot-updater/console 0.1.5 → 0.2.0

package/dist/index.cjs

@@ -1,2422 +1,2095 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-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 && typeof from === "object" || typeof from === "function") {
-    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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-
-// src-server/index.ts
-var src_server_exports = {};
-__export(src_server_exports, {
-  default: () => src_server_default
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>src_server_rslib_entry_
 });
-module.exports = __toCommonJS(src_server_exports);
-var import_path = __toESM(require("path"), 1);
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/filepath.js
-var getFilePath = (options) => {
-  let filename = options.filename;
-  const defaultDocument = options.defaultDocument || "index.html";
-  if (filename.endsWith("/")) {
-    filename = filename.concat(defaultDocument);
-  } else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) {
-    filename = filename.concat("/" + defaultDocument);
-  }
-  const path2 = getFilePathWithoutDefaultDocument({
-    root: options.root,
-    filename
-  });
-  return path2;
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+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 path2 = root ? root + "/" + filename : filename;
-  path2 = path2.replace(/^\.?\//, "");
-  if (root[0] !== "/" && path2[0] === "/") {
-    return;
-  }
-  return path2;
+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;
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/mime.js
-var getMimeType = (filename, mimes = baseMimes) => {
-  const regexp = /\.([a-zA-Z0-9]+?)$/;
-  const match = filename.match(regexp);
-  if (!match) {
-    return;
-  }
-  let mimeType = mimes[match[1]];
-  if (mimeType && mimeType.startsWith("text") || mimeType === "application/json") {
-    mimeType += "; charset=utf-8";
-  }
-  return mimeType;
+var 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"
+    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"
 };
-
-// ../../node_modules/.pnpm/@hono+node-server@1.13.4_hono@4.6.3/node_modules/@hono/node-server/dist/serve-static.mjs
-var import_fs = require("fs");
+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"
+    br: ".br",
+    zstd: ".zst",
+    gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream) => {
-  const body = new ReadableStream({
-    start(controller) {
-      stream.on("data", (chunk) => {
-        controller.enqueue(chunk);
-      });
-      stream.on("end", () => {
-        controller.close();
-      });
-    },
-    cancel() {
-      stream.destroy();
-    }
-  });
-  return body;
-};
-var addCurrentDirPrefix = (path2) => {
-  return `./${path2}`;
-};
-var getStats = (path2) => {
-  let stats;
-  try {
-    stats = (0, import_fs.lstatSync)(path2);
-  } catch {
-  }
-  return stats;
+var createStreamBody = (stream)=>{
+    const body = new ReadableStream({
+        start (controller) {
+            stream.on("data", (chunk)=>{
+                controller.enqueue(chunk);
+            });
+            stream.on("end", ()=>{
+                controller.close();
+            });
+        },
+        cancel () {
+            stream.destroy();
+        }
+    });
+    return body;
 };
-var serveStatic = (options = { root: "" }) => {
-  return async (c, next) => {
-    if (c.finalized) {
-      return next();
-    }
-    let filename;
+var addCurrentDirPrefix = (path)=>`./${path}`;
+var getStats = (path)=>{
+    let stats;
     try {
-      filename = options.path ?? decodeURIComponent(c.req.path);
-    } catch {
-      await options.onNotFound?.(c.req.path, c);
-      return next();
-    }
-    let path2 = getFilePathWithoutDefaultDocument({
-      filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-      root: options.root
-    });
-    if (path2) {
-      path2 = addCurrentDirPrefix(path2);
-    } else {
-      return next();
-    }
-    let stats = getStats(path2);
-    if (stats && stats.isDirectory()) {
-      path2 = getFilePath({
-        filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-        root: options.root,
-        defaultDocument: options.index ?? "index.html"
-      });
-      if (path2) {
-        path2 = addCurrentDirPrefix(path2);
-      } else {
-        return next();
-      }
-      stats = getStats(path2);
-    }
-    if (!stats) {
-      await options.onNotFound?.(path2, c);
-      return next();
-    }
-    await options.onFound?.(path2, c);
-    const mimeType = getMimeType(path2);
-    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;
+        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();
         }
-        const precompressedStats = getStats(path2 + ENCODINGS[encoding]);
-        if (precompressedStats) {
-          c.header("Content-Encoding", encoding);
-          c.header("Vary", "Accept-Encoding", { append: true });
-          stats = precompressedStats;
-          path2 = path2 + ENCODINGS[encoding];
-          break;
+        let path = getFilePathWithoutDefaultDocument({
+            filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+            root: options.root
+        });
+        if (!path) return next();
+        path = addCurrentDirPrefix(path);
+        let stats = getStats(path);
+        if (stats && stats.isDirectory()) {
+            path = getFilePath({
+                filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+                root: options.root,
+                defaultDocument: options.index ?? "index.html"
+            });
+            if (!path) return next();
+            path = addCurrentDirPrefix(path);
+            stats = getStats(path);
         }
-      }
-    }
-    const size = stats.size;
-    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
-      c.header("Content-Length", size.toString());
-      c.status(200);
-      return c.body(null);
-    }
-    const range = c.req.header("range") || "";
-    if (!range) {
-      c.header("Content-Length", size.toString());
-      return c.body(createStreamBody((0, import_fs.createReadStream)(path2)), 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, import_fs.createReadStream)(path2, { start, end });
-    c.header("Content-Length", chunksize.toString());
-    c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c.body(createStreamBody(stream), 206);
-  };
-};
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/body.js
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-  const contentType = headers.get("Content-Type");
-  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
-    return parseFormData(request, { all, dot });
-  }
-  return {};
+        if (!stats) {
+            await options.onNotFound?.(path, c);
+            return next();
+        }
+        await options.onFound?.(path, c);
+        const mimeType = getMimeType(path);
+        c.header("Content-Type", mimeType || "application/octet-stream");
+        if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+            const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding)=>encoding.trim()));
+            for (const encoding of ENCODINGS_ORDERED_KEYS){
+                if (!acceptEncodingSet.has(encoding)) continue;
+                const precompressedStats = getStats(path + ENCODINGS[encoding]);
+                if (precompressedStats) {
+                    c.header("Content-Encoding", encoding);
+                    c.header("Vary", "Accept-Encoding", {
+                        append: true
+                    });
+                    stats = precompressedStats;
+                    path += ENCODINGS[encoding];
+                    break;
+                }
+            }
+        }
+        const size = stats.size;
+        if ("HEAD" == c.req.method || "OPTIONS" == c.req.method) {
+            c.header("Content-Length", size.toString());
+            c.status(200);
+            return c.body(null);
+        }
+        const range = c.req.header("range") || "";
+        if (!range) {
+            c.header("Content-Length", size.toString());
+            return c.body(createStreamBody((0, external_fs_namespaceObject.createReadStream)(path)), 200);
+        }
+        c.header("Accept-Ranges", "bytes");
+        c.header("Date", stats.birthtime.toUTCString());
+        const parts = range.replace(/bytes=/, "").split("-", 2);
+        const start = parts[0] ? parseInt(parts[0], 10) : 0;
+        let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+        if (size < end - start + 1) end = size - 1;
+        const chunksize = end - start + 1;
+        const stream = (0, external_fs_namespaceObject.createReadStream)(path, {
+            start,
+            end
+        });
+        c.header("Content-Length", chunksize.toString());
+        c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+        return c.body(createStreamBody(stream), 206);
+    };
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null))=>{
+    const { all = false, dot = false } = options;
+    const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+    const contentType = headers.get("Content-Type");
+    if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
+        all,
+        dot
+    });
+    return {};
 };
 async function parseFormData(request, options) {
-  const formData = await request.formData();
-  if (formData) {
-    return convertFormDataToBodyData(formData, options);
-  }
-  return {};
+    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) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-  if (options.dot) {
-    Object.entries(form).forEach(([key, value]) => {
-      const shouldParseDotValues = key.includes(".");
-      if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
-        delete form[key];
-      }
+    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;
+    return form;
 }
-var handleParsingAllValues = (form, key, value) => {
-  if (form[key] !== void 0) {
-    if (Array.isArray(form[key])) {
-      ;
-      form[key].push(value);
-    } else {
-      form[key] = [form[key], value];
-    }
-  } else {
-    form[key] = value;
-  }
+var 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] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
-        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-      }
-      nestedForm = nestedForm[key2];
-    }
-  });
+var handleParsingNestedValues = (form, key, value)=>{
+    let nestedForm = form;
+    const keys = key.split(".");
+    keys.forEach((key2, index)=>{
+        if (index === keys.length - 1) nestedForm[key2] = value;
+        else {
+            if (!nestedForm[key2] || "object" != typeof nestedForm[key2] || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+            nestedForm = nestedForm[key2];
+        }
+    });
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/url.js
-var splitPath = (path2) => {
-  const paths = path2.split("/");
-  if (paths[0] === "") {
-    paths.shift();
-  }
-  return paths;
+var splitPath = (path)=>{
+    const paths = path.split("/");
+    if ("" === paths[0]) paths.shift();
+    return paths;
 };
-var splitRoutingPath = (routePath) => {
-  const { groups, path: path2 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path2);
-  return replaceGroupMarks(paths, groups);
+var splitRoutingPath = (routePath)=>{
+    const { groups, path } = extractGroupsFromPath(routePath);
+    const paths = splitPath(path);
+    return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path2) => {
-  const groups = [];
-  path2 = path2.replace(/\{[^}]+\}/g, (match, index) => {
-    const mark = `@${index}`;
-    groups.push([mark, match]);
-    return mark;
-  });
-  return { groups, path: path2 };
+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 replaceGroupMarks = (paths, groups)=>{
+    for(let i = groups.length - 1; i >= 0; i--){
+        const [mark] = groups[i];
+        for(let j = paths.length - 1; j >= 0; j--)if (paths[j].includes(mark)) {
+            paths[j] = paths[j].replace(mark, groups[i][1]);
+            break;
+        }
+    }
+    return paths;
 };
 var patternCache = {};
-var getPattern = (label) => {
-  if (label === "*") {
-    return "*";
-  }
-  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match) {
-    if (!patternCache[label]) {
-      if (match[2]) {
-        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
-      } else {
-        patternCache[label] = [label, match[1], true];
-      }
-    }
-    return patternCache[label];
-  }
-  return null;
-};
-var tryDecodeURI = (str) => {
-  try {
-    return decodeURI(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-      try {
-        return decodeURI(match);
-      } catch {
-        return match;
-      }
-    });
-  }
+var 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 getPath = (request) => {
-  const url = request.url;
-  const start = url.indexOf("/", 8);
-  let i = start;
-  for (; i < url.length; i++) {
-    const charCode = url.charCodeAt(i);
-    if (charCode === 37) {
-      const queryIndex = url.indexOf("?", i);
-      const path2 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
-    } else if (charCode === 63) {
-      break;
-    }
-  }
-  return url.slice(start, i);
+var tryDecodeURI = (str)=>{
+    try {
+        return decodeURI(str);
+    } catch  {
+        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match)=>{
+            try {
+                return decodeURI(match);
+            } catch  {
+                return match;
+            }
+        });
+    }
 };
-var getPathNoStrict = (request) => {
-  const result = getPath(request);
-  return result.length > 1 && result[result.length - 1] === "/" ? result.slice(0, -1) : result;
+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 mergePath = (...paths) => {
-  let p = "";
-  let endsWithSlash = false;
-  for (let path2 of paths) {
-    if (p[p.length - 1] === "/") {
-      p = p.slice(0, -1);
-      endsWithSlash = true;
-    }
-    if (path2[0] !== "/") {
-      path2 = `/${path2}`;
-    }
-    if (path2 === "/" && endsWithSlash) {
-      p = `${p}/`;
-    } else if (path2 !== "/") {
-      p = `${p}${path2}`;
-    }
-    if (path2 === "/" && p === "") {
-      p = "/";
-    }
-  }
-  return p;
+var getPathNoStrict = (request)=>{
+    const result = getPath(request);
+    return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
 };
-var checkOptionalParameter = (path2) => {
-  if (!path2.match(/\:.+\?$/)) {
-    return null;
-  }
-  const segments = path2.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
-        } else {
-          results.push(basePath);
+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;
         }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
-      } else {
-        basePath += "/" + segment;
-      }
-    }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
+        if ("/" !== path[0]) path = `/${path}`;
+        if ("/" === path && endsWithSlash) p = `${p}/`;
+        else if ("/" !== path) p = `${p}${path}`;
+        if ("/" === path && "" === p) p = "/";
+    }
+    return p;
 };
-var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
-  if (value.indexOf("+") !== -1) {
-    value = value.replace(/\+/g, " ");
-  }
-  return /%/.test(value) ? decodeURIComponent_(value) : value;
+var checkOptionalParameter = (path)=>{
+    if (!path.match(/\:.+\?$/)) return null;
+    const segments = path.split("/");
+    const results = [];
+    let basePath = "";
+    segments.forEach((segment)=>{
+        if ("" === segment || /\:/.test(segment)) {
+            if (/\:/.test(segment)) {
+                if (/\?/.test(segment)) {
+                    if (0 === results.length && "" === basePath) results.push("/");
+                    else results.push(basePath);
+                    const optionalSegment = segment.replace("?", "");
+                    basePath += "/" + optionalSegment;
+                    results.push(basePath);
+                } else basePath += "/" + segment;
+            }
+        } else basePath += "/" + segment;
+    });
+    return results.filter((v, i, a)=>a.indexOf(v) === i);
 };
-var _getQueryParam = (url, key, multiple) => {
-  let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url.indexOf(`?${key}`, 8);
-    if (keyIndex2 === -1) {
-      keyIndex2 = url.indexOf(`&${key}`, 8);
-    }
-    while (keyIndex2 !== -1) {
-      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-      if (trailingKeyCode === 61) {
-        const valueIndex = keyIndex2 + key.length + 2;
-        const endIndex = url.indexOf("&", valueIndex);
-        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
-      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
-        return "";
-      }
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    encoded = /[%+]/.test(url);
-    if (!encoded) {
-      return void 0;
-    }
-  }
-  const results = {};
-  encoded ?? (encoded = /[%+]/.test(url));
-  let keyIndex = url.indexOf("?", 8);
-  while (keyIndex !== -1) {
-    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-    let valueIndex = url.indexOf("=", keyIndex);
-    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
-      valueIndex = -1;
-    }
-    let name = url.slice(
-      keyIndex + 1,
-      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
-    );
-    if (encoded) {
-      name = _decodeURI(name);
-    }
-    keyIndex = nextKeyIndex;
-    if (name === "") {
-      continue;
-    }
-    let value;
-    if (valueIndex === -1) {
-      value = "";
-    } else {
-      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
-      if (encoded) {
-        value = _decodeURI(value);
-      }
-    }
-    if (multiple) {
-      if (!(results[name] && Array.isArray(results[name]))) {
-        results[name] = [];
-      }
-      ;
-      results[name].push(value);
-    } else {
-      results[name] ?? (results[name] = value);
-    }
-  }
-  return key ? results[key] : results;
+var _decodeURI = (value)=>{
+    if (!/[%+]/.test(value)) return value;
+    if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
+    return /%/.test(value) ? decodeURIComponent_(value) : value;
 };
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key) => {
-  return _getQueryParam(url, key, true);
+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;
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/request.js
-var _validatedData, _matchResult, _a;
-var HonoRequest = (_a = class {
-  constructor(request, path2 = "/", matchResult = [[]]) {
-    __publicField(this, "raw");
-    __privateAdd(this, _validatedData);
-    __privateAdd(this, _matchResult);
-    __publicField(this, "routeIndex", 0);
-    __publicField(this, "path");
-    __publicField(this, "bodyCache", {});
-    __publicField(this, "cachedBody", (key) => {
-      const { bodyCache, raw: raw2 } = this;
-      const cachedBody = bodyCache[key];
-      if (cachedBody) {
-        return cachedBody;
-      }
-      const anyCachedKey = Object.keys(bodyCache)[0];
-      if (anyCachedKey) {
-        return bodyCache[anyCachedKey].then((body) => {
-          if (anyCachedKey === "json") {
-            body = JSON.stringify(body);
-          }
-          return new Response(body)[key]();
+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 bodyCache[key] = raw2[key]();
-    });
-    this.raw = request;
-    this.path = path2;
-    __privateSet(this, _matchResult, matchResult);
-    __privateSet(this, _validatedData, {});
-  }
-  param(key) {
-    return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
-  }
-  getDecodedParam(key) {
-    const paramKey = __privateGet(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(__privateGet(this, _matchResult)[0][this.routeIndex][1]);
-    for (const key of keys) {
-      const value = this.getParamValue(__privateGet(this, _matchResult)[0][this.routeIndex][1][key]);
-      if (value && typeof value === "string") {
-        decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
-      }
-    }
-    return decoded;
-  }
-  getParamValue(paramKey) {
-    return __privateGet(this, _matchResult)[1] ? __privateGet(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) {
-    var _a4;
-    return (_a4 = this.bodyCache).parsedBody ?? (_a4.parsedBody = await parseBody(this, options));
-  }
-  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) {
-    __privateGet(this, _validatedData)[target] = data;
-  }
-  valid(target) {
-    return __privateGet(this, _validatedData)[target];
-  }
-  get url() {
-    return this.raw.url;
-  }
-  get method() {
-    return this.raw.method;
-  }
-  get matchedRoutes() {
-    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route);
-  }
-  get routePath() {
-    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route)[this.routeIndex].path;
-  }
-}, _validatedData = new WeakMap(), _matchResult = new WeakMap(), _a);
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/html.js
+        return headerData;
+    }
+    async parseBody(options) {
+        return this.bodyCache.parsedBody ??= await parseBody(this, options);
+    }
+    cachedBody = (key)=>{
+        const { bodyCache, raw } = this;
+        const cachedBody = bodyCache[key];
+        if (cachedBody) return cachedBody;
+        const anyCachedKey = Object.keys(bodyCache)[0];
+        if (anyCachedKey) return bodyCache[anyCachedKey].then((body)=>{
+            if ("json" === anyCachedKey) body = JSON.stringify(body);
+            return new Response(body)[key]();
+        });
+        return bodyCache[key] = raw[key]();
+    };
+    json() {
+        return this.cachedBody("json");
+    }
+    text() {
+        return this.cachedBody("text");
+    }
+    arrayBuffer() {
+        return this.cachedBody("arrayBuffer");
+    }
+    blob() {
+        return this.cachedBody("blob");
+    }
+    formData() {
+        return this.cachedBody("formData");
+    }
+    addValidatedData(target, data) {
+        this.#validatedData[target] = data;
+    }
+    valid(target) {
+        return this.#validatedData[target];
+    }
+    get url() {
+        return this.raw.url;
+    }
+    get method() {
+        return this.raw.method;
+    }
+    get matchedRoutes() {
+        return this.#matchResult[0].map(([[, route]])=>route);
+    }
+    get routePath() {
+        return this.#matchResult[0].map(([[, route]])=>route)[this.routeIndex].path;
+    }
+};
 var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
+    Stringify: 1,
+    BeforeStream: 2,
+    Stream: 3
 };
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
+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 (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
-    (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
-    ).then(() => buffer[0])
-  );
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
+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;
-  }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/context.js
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setHeaders = (headers, map = {}) => {
-  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
-  return headers;
+var setHeaders = (headers, map = {})=>{
+    Object.entries(map).forEach(([key, value])=>headers.set(key, value));
+    return headers;
 };
-var _rawRequest, _req, _var, _status, _executionCtx, _headers, _preparedHeaders, _res, _isFresh, _layout, _renderer, _notFoundHandler, _matchResult2, _path, _a2;
-var Context = (_a2 = class {
-  constructor(req, options) {
-    __privateAdd(this, _rawRequest);
-    __privateAdd(this, _req);
-    __publicField(this, "env", {});
-    __privateAdd(this, _var);
-    __publicField(this, "finalized", false);
-    __publicField(this, "error");
-    __privateAdd(this, _status, 200);
-    __privateAdd(this, _executionCtx);
-    __privateAdd(this, _headers);
-    __privateAdd(this, _preparedHeaders);
-    __privateAdd(this, _res);
-    __privateAdd(this, _isFresh, true);
-    __privateAdd(this, _layout);
-    __privateAdd(this, _renderer);
-    __privateAdd(this, _notFoundHandler);
-    __privateAdd(this, _matchResult2);
-    __privateAdd(this, _path);
-    __publicField(this, "render", (...args) => {
-      __privateGet(this, _renderer) ?? __privateSet(this, _renderer, (content) => this.html(content));
-      return __privateGet(this, _renderer).call(this, ...args);
-    });
-    __publicField(this, "setLayout", (layout) => __privateSet(this, _layout, layout));
-    __publicField(this, "getLayout", () => __privateGet(this, _layout));
-    __publicField(this, "setRenderer", (renderer) => {
-      __privateSet(this, _renderer, renderer);
-    });
-    __publicField(this, "header", (name, value, options) => {
-      if (value === void 0) {
-        if (__privateGet(this, _headers)) {
-          __privateGet(this, _headers).delete(name);
-        } else if (__privateGet(this, _preparedHeaders)) {
-          delete __privateGet(this, _preparedHeaders)[name.toLocaleLowerCase()];
+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;
         }
-        if (this.finalized) {
-          this.res.headers.delete(name);
-        }
-        return;
-      }
-      if (options?.append) {
-        if (!__privateGet(this, _headers)) {
-          __privateSet(this, _isFresh, false);
-          __privateSet(this, _headers, new Headers(__privateGet(this, _preparedHeaders)));
-          __privateSet(this, _preparedHeaders, {});
+    }
+    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;
         }
-        __privateGet(this, _headers).append(name, value);
-      } else {
-        if (__privateGet(this, _headers)) {
-          __privateGet(this, _headers).set(name, value);
-        } else {
-          __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-          __privateGet(this, _preparedHeaders)[name.toLowerCase()] = value;
+        this.#res = _res;
+        this.finalized = true;
+    }
+    render = (...args)=>{
+        this.#renderer ??= (content)=>this.html(content);
+        return this.#renderer(...args);
+    };
+    setLayout = (layout)=>this.#layout = layout;
+    getLayout = ()=>this.#layout;
+    setRenderer = (renderer)=>{
+        this.#renderer = renderer;
+    };
+    header = (name, value, options)=>{
+        if (void 0 === value) {
+            if (this.#headers) this.#headers.delete(name);
+            else if (this.#preparedHeaders) delete this.#preparedHeaders[name.toLocaleLowerCase()];
+            if (this.finalized) this.res.headers.delete(name);
+            return;
         }
-      }
-      if (this.finalized) {
         if (options?.append) {
-          this.res.headers.append(name, value);
-        } else {
-          this.res.headers.set(name, value);
-        }
-      }
-    });
-    __publicField(this, "status", (status) => {
-      __privateSet(this, _isFresh, false);
-      __privateSet(this, _status, status);
-    });
-    __publicField(this, "set", (key, value) => {
-      __privateGet(this, _var) ?? __privateSet(this, _var, /* @__PURE__ */ new Map());
-      __privateGet(this, _var).set(key, value);
-    });
-    __publicField(this, "get", (key) => {
-      return __privateGet(this, _var) ? __privateGet(this, _var).get(key) : void 0;
-    });
-    __publicField(this, "newResponse", (data, arg, headers) => {
-      if (__privateGet(this, _isFresh) && !headers && !arg && __privateGet(this, _status) === 200) {
-        return new Response(data, {
-          headers: __privateGet(this, _preparedHeaders)
-        });
-      }
-      if (arg && typeof arg !== "number") {
-        const header = new Headers(arg.headers);
-        if (__privateGet(this, _headers)) {
-          __privateGet(this, _headers).forEach((v, k) => {
-            if (k === "set-cookie") {
-              header.append(k, v);
-            } else {
-              header.set(k, v);
+            if (!this.#headers) {
+                this.#isFresh = false;
+                this.#headers = new Headers(this.#preparedHeaders);
+                this.#preparedHeaders = {};
             }
-          });
+            this.#headers.append(name, value);
+        } else if (this.#headers) this.#headers.set(name, value);
+        else {
+            this.#preparedHeaders ??= {};
+            this.#preparedHeaders[name.toLowerCase()] = value;
         }
-        const headers2 = setHeaders(header, __privateGet(this, _preparedHeaders));
-        return new Response(data, {
-          headers: headers2,
-          status: arg.status ?? __privateGet(this, _status)
-        });
-      }
-      const status = typeof arg === "number" ? arg : __privateGet(this, _status);
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
-      setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
-      if (__privateGet(this, _res)) {
-        __privateGet(this, _res).headers.forEach((v, k) => {
-          if (k === "set-cookie") {
-            __privateGet(this, _headers)?.append(k, v);
-          } else {
-            __privateGet(this, _headers)?.set(k, v);
-          }
-        });
-        setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
-      }
-      headers ?? (headers = {});
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          __privateGet(this, _headers).set(k, v);
-        } else {
-          __privateGet(this, _headers).delete(k);
-          for (const v2 of v) {
-            __privateGet(this, _headers).append(k, v2);
-          }
-        }
-      }
-      return new Response(data, {
-        status,
-        headers: __privateGet(this, _headers)
-      });
-    });
-    __publicField(this, "body", (data, arg, headers) => {
-      return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
-    });
-    __publicField(this, "text", (text, arg, headers) => {
-      if (!__privateGet(this, _preparedHeaders)) {
-        if (__privateGet(this, _isFresh) && !headers && !arg) {
-          return new Response(text);
+        if (this.finalized) {
+            if (options?.append) this.res.headers.append(name, value);
+            else this.res.headers.set(name, value);
         }
-        __privateSet(this, _preparedHeaders, {});
-      }
-      __privateGet(this, _preparedHeaders)["content-type"] = TEXT_PLAIN;
-      return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
-    });
-    __publicField(this, "json", (object2, arg, headers) => {
-      const body = JSON.stringify(object2);
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _preparedHeaders)["content-type"] = "application/json; charset=UTF-8";
-      return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
-    });
-    __publicField(this, "html", (html, arg, headers) => {
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _preparedHeaders)["content-type"] = "text/html; charset=UTF-8";
-      if (typeof html === "object") {
-        return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-          return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+    };
+    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
         });
-      }
-      return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
-    });
-    __publicField(this, "redirect", (location, status) => {
-      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
-      __privateGet(this, _headers).set("Location", location);
-      return this.newResponse(null, status ?? 302);
-    });
-    __publicField(this, "notFound", () => {
-      __privateGet(this, _notFoundHandler) ?? __privateSet(this, _notFoundHandler, () => new Response());
-      return __privateGet(this, _notFoundHandler).call(this, this);
-    });
-    __privateSet(this, _rawRequest, req);
-    if (options) {
-      __privateSet(this, _executionCtx, options.executionCtx);
-      this.env = options.env;
-      __privateSet(this, _notFoundHandler, options.notFoundHandler);
-      __privateSet(this, _path, options.path);
-      __privateSet(this, _matchResult2, options.matchResult);
-    }
-  }
-  get req() {
-    __privateGet(this, _req) ?? __privateSet(this, _req, new HonoRequest(__privateGet(this, _rawRequest), __privateGet(this, _path), __privateGet(this, _matchResult2)));
-    return __privateGet(this, _req);
-  }
-  get event() {
-    if (__privateGet(this, _executionCtx) && "respondWith" in __privateGet(this, _executionCtx)) {
-      return __privateGet(this, _executionCtx);
-    } else {
-      throw Error("This context has no FetchEvent");
-    }
-  }
-  get executionCtx() {
-    if (__privateGet(this, _executionCtx)) {
-      return __privateGet(this, _executionCtx);
-    } else {
-      throw Error("This context has no ExecutionContext");
-    }
-  }
-  get res() {
-    __privateSet(this, _isFresh, false);
-    return __privateGet(this, _res) || __privateSet(this, _res, new Response("404 Not Found", { status: 404 }));
-  }
-  set res(_res2) {
-    __privateSet(this, _isFresh, false);
-    if (__privateGet(this, _res) && _res2) {
-      try {
-        for (const [k, v] of __privateGet(this, _res).headers.entries()) {
-          if (k === "content-type") {
-            continue;
-          }
-          if (k === "set-cookie") {
-            const cookies = __privateGet(this, _res).headers.getSetCookie();
-            _res2.headers.delete("set-cookie");
-            for (const cookie of cookies) {
-              _res2.headers.append("set-cookie", cookie);
-            }
-          } else {
-            _res2.headers.set(k, v);
-          }
-        }
-      } catch (e) {
-        if (e instanceof TypeError && e.message.includes("immutable")) {
-          this.res = new Response(_res2.body, {
-            headers: _res2.headers,
-            status: _res2.status
-          });
-          return;
-        } else {
-          throw e;
+        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
+            });
         }
-      }
-    }
-    __privateSet(this, _res, _res2);
-    this.finalized = true;
-  }
-  get var() {
-    if (!__privateGet(this, _var)) {
-      return {};
-    }
-    return Object.fromEntries(__privateGet(this, _var));
-  }
-}, _rawRequest = new WeakMap(), _req = new WeakMap(), _var = new WeakMap(), _status = new WeakMap(), _executionCtx = new WeakMap(), _headers = new WeakMap(), _preparedHeaders = new WeakMap(), _res = new WeakMap(), _isFresh = new WeakMap(), _layout = new WeakMap(), _renderer = new WeakMap(), _notFoundHandler = new WeakMap(), _matchResult2 = new WeakMap(), _path = new WeakMap(), _a2);
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/compose.js
-var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
-    let index = -1;
-    return dispatch(0);
-    async function dispatch(i) {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      let res;
-      let isError = false;
-      let handler;
-      if (middleware[i]) {
-        handler = middleware[i][0][0];
-        if (context instanceof Context) {
-          context.req.routeIndex = i;
+        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);
         }
-      } else {
-        handler = i === middleware.length && next || void 0;
-      }
-      if (!handler) {
-        if (context instanceof Context && context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
+        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);
         }
-      } else {
-        try {
-          res = await handler(context, () => {
-            return dispatch(i + 1);
-          });
-        } catch (err) {
-          if (err instanceof Error && context instanceof Context && onError) {
-            context.error = err;
-            res = await onError(err, context);
-            isError = true;
-          } else {
-            throw err;
-          }
+        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 = {};
         }
-      }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
-      }
-      return context;
-    }
-  };
+        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);
+    };
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router.js
+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 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 {
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono-base.js
 var COMPOSED_HANDLER = Symbol("composedHandler");
-var notFoundHandler = (c) => {
-  return c.text("404 Not Found", 404);
+var 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 errorHandler = (err, c) => {
-  if ("getResponse" in err) {
-    return err.getResponse();
-  }
-  console.error(err);
-  return c.text("Internal Server Error", 500);
-};
-var _path2, _a3;
-var Hono = (_a3 = class {
-  constructor(options = {}) {
-    __publicField(this, "get");
-    __publicField(this, "post");
-    __publicField(this, "put");
-    __publicField(this, "delete");
-    __publicField(this, "options");
-    __publicField(this, "patch");
-    __publicField(this, "all");
-    __publicField(this, "on");
-    __publicField(this, "use");
-    __publicField(this, "router");
-    __publicField(this, "getPath");
-    __publicField(this, "_basePath", "/");
-    __privateAdd(this, _path2, "/");
-    __publicField(this, "routes", []);
-    __publicField(this, "notFoundHandler", notFoundHandler);
-    __publicField(this, "errorHandler", errorHandler);
-    __publicField(this, "onError", (handler) => {
-      this.errorHandler = handler;
-      return this;
-    });
-    __publicField(this, "notFound", (handler) => {
-      this.notFoundHandler = handler;
-      return this;
-    });
-    __publicField(this, "fetch", (request, ...rest) => {
-      return this.dispatch(request, rest[1], rest[0], request.method);
-    });
-    __publicField(this, "request", (input, requestInit, Env, executionCtx) => {
-      if (input instanceof Request) {
-        if (requestInit !== void 0) {
-          input = new Request(input, requestInit);
-        }
-        return this.fetch(input, Env, executionCtx);
-      }
-      input = input.toString();
-      const path2 = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-      const req = new Request(path2, requestInit);
-      return this.fetch(req, Env, executionCtx);
-    });
-    __publicField(this, "fire", () => {
-      addEventListener("fetch", (event) => {
-        event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
-      });
-    });
-    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
-    allMethods.forEach((method) => {
-      this[method] = (args1, ...args) => {
-        if (typeof args1 === "string") {
-          __privateSet(this, _path2, args1);
-        } else {
-          this.addRoute(method, __privateGet(this, _path2), args1);
-        }
-        args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.addRoute(method, __privateGet(this, _path2), handler);
-          }
+var Hono = class {
+    get;
+    post;
+    put;
+    delete;
+    options;
+    patch;
+    all;
+    on;
+    use;
+    router;
+    getPath;
+    _basePath = "/";
+    #path = "/";
+    routes = [];
+    constructor(options = {}){
+        const allMethods = [
+            ...METHODS,
+            METHOD_NAME_ALL_LOWERCASE
+        ];
+        allMethods.forEach((method)=>{
+            this[method] = (args1, ...args)=>{
+                if ("string" == typeof args1) this.#path = args1;
+                else this.addRoute(method, this.#path, args1);
+                args.forEach((handler)=>{
+                    if ("string" != typeof handler) this.addRoute(method, this.#path, handler);
+                });
+                return this;
+            };
+        });
+        this.on = (method, path, ...handlers)=>{
+            for (const p of [
+                path
+            ].flat()){
+                this.#path = p;
+                for (const m of [
+                    method
+                ].flat())handlers.map((handler)=>{
+                    this.addRoute(m.toUpperCase(), this.#path, handler);
+                });
+            }
+            return this;
+        };
+        this.use = (arg1, ...handlers)=>{
+            if ("string" == typeof arg1) this.#path = arg1;
+            else {
+                this.#path = "*";
+                handlers.unshift(arg1);
+            }
+            handlers.forEach((handler)=>{
+                this.addRoute(METHOD_NAME_ALL, this.#path, handler);
+            });
+            return this;
+        };
+        const strict = options.strict ?? true;
+        delete options.strict;
+        Object.assign(this, options);
+        this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
+    }
+    clone() {
+        const clone = new Hono({
+            router: this.router,
+            getPath: this.getPath
+        });
+        clone.routes = this.routes;
+        return clone;
+    }
+    notFoundHandler = notFoundHandler;
+    errorHandler = errorHandler;
+    route(path, app) {
+        const subApp = this.basePath(path);
+        app.routes.map((r)=>{
+            let handler;
+            if (app.errorHandler === errorHandler) handler = r.handler;
+            else {
+                handler = async (c, next)=>(await compose([], app.errorHandler)(c, ()=>r.handler(c, next))).res;
+                handler[COMPOSED_HANDLER] = r.handler;
+            }
+            subApp.addRoute(r.method, r.path, handler);
         });
         return this;
-      };
-    });
-    this.on = (method, path2, ...handlers) => {
-      for (const p of [path2].flat()) {
-        __privateSet(this, _path2, p);
-        for (const m of [method].flat()) {
-          handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), __privateGet(this, _path2), handler);
-          });
-        }
-      }
-      return this;
-    };
-    this.use = (arg1, ...handlers) => {
-      if (typeof arg1 === "string") {
-        __privateSet(this, _path2, arg1);
-      } else {
-        __privateSet(this, _path2, "*");
-        handlers.unshift(arg1);
-      }
-      handlers.forEach((handler) => {
-        this.addRoute(METHOD_NAME_ALL, __privateGet(this, _path2), handler);
-      });
-      return this;
-    };
-    const strict = options.strict ?? true;
-    delete options.strict;
-    Object.assign(this, options);
-    this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
-  }
-  clone() {
-    const clone = new Hono({
-      router: this.router,
-      getPath: this.getPath
-    });
-    clone.routes = this.routes;
-    return clone;
-  }
-  route(path2, app2) {
-    const subApp = this.basePath(path2);
-    app2.routes.map((r) => {
-      let handler;
-      if (app2.errorHandler === errorHandler) {
-        handler = r.handler;
-      } else {
-        handler = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
-        handler[COMPOSED_HANDLER] = r.handler;
-      }
-      subApp.addRoute(r.method, r.path, handler);
-    });
-    return this;
-  }
-  basePath(path2) {
-    const subApp = this.clone();
-    subApp._basePath = mergePath(this._basePath, path2);
-    return subApp;
-  }
-  mount(path2, applicationHandler, options) {
-    let replaceRequest;
-    let optionHandler;
-    if (options) {
-      if (typeof options === "function") {
-        optionHandler = options;
-      } else {
-        optionHandler = options.optionHandler;
-        replaceRequest = options.replaceRequest;
-      }
-    }
-    const getOptions = optionHandler ? (c) => {
-      const options2 = optionHandler(c);
-      return Array.isArray(options2) ? options2 : [options2];
-    } : (c) => {
-      let executionContext = void 0;
-      try {
-        executionContext = c.executionCtx;
-      } catch {
-      }
-      return [c.env, executionContext];
+    }
+    basePath(path) {
+        const subApp = this.clone();
+        subApp._basePath = mergePath(this._basePath, path);
+        return subApp;
+    }
+    onError = (handler)=>{
+        this.errorHandler = handler;
+        return this;
     };
-    replaceRequest || (replaceRequest = (() => {
-      const mergedPath = mergePath(this._basePath, path2);
-      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();
+    notFound = (handler)=>{
+        this.notFoundHandler = handler;
+        return this;
     };
-    this.addRoute(METHOD_NAME_ALL, mergePath(path2, "*"), handler);
-    return this;
-  }
-  addRoute(method, path2, handler) {
-    method = method.toUpperCase();
-    path2 = mergePath(this._basePath, path2);
-    const r = { path: path2, method, handler };
-    this.router.add(method, path2, [handler, r]);
-    this.routes.push(r);
-  }
-  matchRoute(method, path2) {
-    return this.router.match(method, path2);
-  }
-  handleError(err, c) {
-    if (err instanceof Error) {
-      return this.errorHandler(err, c);
-    }
-    throw err;
-  }
-  dispatch(request, executionCtx, env, method) {
-    if (method === "HEAD") {
-      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
-    }
-    const path2 = this.getPath(request, { env });
-    const matchResult = this.matchRoute(method, path2);
-    const c = new Context(request, {
-      path: path2,
-      matchResult,
-      env,
-      executionCtx,
-      notFoundHandler: this.notFoundHandler
-    });
-    if (matchResult[0].length === 1) {
-      let res;
-      try {
-        res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.notFoundHandler(c);
+    mount(path, applicationHandler, options) {
+        let replaceRequest;
+        let optionHandler;
+        if (options) {
+            if ("function" == typeof options) optionHandler = options;
+            else {
+                optionHandler = options.optionHandler;
+                replaceRequest = options.replaceRequest;
+            }
+        }
+        const getOptions = optionHandler ? (c)=>{
+            const options2 = optionHandler(c);
+            return Array.isArray(options2) ? options2 : [
+                options2
+            ];
+        } : (c)=>{
+            let executionContext;
+            try {
+                executionContext = c.executionCtx;
+            } catch  {}
+            return [
+                c.env,
+                executionContext
+            ];
+        };
+        replaceRequest ||= (()=>{
+            const mergedPath = mergePath(this._basePath, path);
+            const pathPrefixLength = "/" === mergedPath ? 0 : mergedPath.length;
+            return (request)=>{
+                const url = new URL(request.url);
+                url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+                return new Request(url, request);
+            };
+        })();
+        const handler = async (c, next)=>{
+            const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+            if (res) return res;
+            await next();
+        };
+        this.addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+        return this;
+    }
+    addRoute(method, path, handler) {
+        method = method.toUpperCase();
+        path = mergePath(this._basePath, path);
+        const r = {
+            path,
+            method,
+            handler
+        };
+        this.router.add(method, path, [
+            handler,
+            r
+        ]);
+        this.routes.push(r);
+    }
+    matchRoute(method, path) {
+        return this.router.match(method, path);
+    }
+    handleError(err, c) {
+        if (err instanceof Error) return this.errorHandler(err, c);
+        throw err;
+    }
+    dispatch(request, executionCtx, env, method) {
+        if ("HEAD" === method) return (async ()=>new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+        const path = this.getPath(request, {
+            env
+        });
+        const matchResult = this.matchRoute(method, path);
+        const c = new Context(request, {
+            path,
+            matchResult,
+            env,
+            executionCtx,
+            notFoundHandler: this.notFoundHandler
         });
-      } 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()`?"
-          );
+        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);
         }
-        return context.res;
-      } catch (err) {
-        return this.handleError(err, c);
-      }
-    })();
-  }
-}, _path2 = new WeakMap(), _a3);
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/node.js
+        const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
+        return (async ()=>{
+            try {
+                const context = await composed(c);
+                if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+                return context.res;
+            } catch (err) {
+                return this.handleError(err, c);
+            }
+        })();
+    }
+    fetch = (request, ...rest)=>this.dispatch(request, rest[1], rest[0], request.method);
+    request = (input, requestInit, Env, executionCtx)=>{
+        if (input instanceof Request) {
+            if (void 0 !== requestInit) input = new Request(input, requestInit);
+            return this.fetch(input, Env, executionCtx);
+        }
+        input = input.toString();
+        const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
+        const req = new Request(path, requestInit);
+        return this.fetch(req, Env, executionCtx);
+    };
+    fire = ()=>{
+        addEventListener("fetch", (event)=>{
+            event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+        });
+    };
+};
 var LABEL_REG_EXP_STR = "[^/]+";
 var ONLY_WILDCARD_REG_EXP_STR = ".*";
 var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
 var PATH_ERROR = Symbol();
 var regExpMetaChars = new Set(".\\+*[^]$()");
 function compareKey(a, b) {
-  if (a.length === 1) {
-    return b.length === 1 ? a < b ? -1 : 1 : -1;
-  }
-  if (b.length === 1) {
-    return 1;
-  }
-  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
-  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-    return -1;
-  }
-  if (a === LABEL_REG_EXP_STR) {
-    return 1;
-  } else if (b === LABEL_REG_EXP_STR) {
-    return -1;
-  }
-  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+    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 {
-  constructor() {
-    __publicField(this, "index");
-    __publicField(this, "varIndex");
-    __publicField(this, "children", /* @__PURE__ */ Object.create(null));
-  }
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.index = index;
-      return;
-    }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.children).some(
-          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.children[regexpStr] = new Node();
-        if (name !== "") {
-          node.varIndex = context.varIndex++;
+    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;
         }
-      }
-      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;
+        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 = 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 (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-    });
-    if (typeof this.index === "number") {
-      strList.unshift(`#${this.index}`);
-    }
-    if (strList.length === 0) {
-      return "";
+        node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
     }
-    if (strList.length === 1) {
-      return strList[0];
+    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("|") + ")";
     }
-    return "(?:" + strList.join("|") + ")";
-  }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/trie.js
 var Trie = class {
-  constructor() {
-    __publicField(this, "context", { varIndex: 0 });
-    __publicField(this, "root", new Node());
-  }
-  insert(path2, index, pathErrorCheckOnly) {
-    const paramAssoc = [];
-    const groups = [];
-    for (let i = 0; ; ) {
-      let replaced = false;
-      path2 = path2.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
-      }
-    }
-    const tokens = path2.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
+    context = {
+        varIndex: 0
+    };
+    root = new Node();
+    insert(path, index, pathErrorCheckOnly) {
+        const paramAssoc = [];
+        const groups = [];
+        for(let i = 0;;){
+            let replaced = false;
+            path = path.replace(/\{[^}]+\}/g, (m)=>{
+                const mark = `@\\${i}`;
+                groups[i] = [
+                    mark,
+                    m
+                ];
+                i++;
+                replaced = true;
+                return mark;
+            });
+            if (!replaced) break;
         }
-      }
-    }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
-    return paramAssoc;
-  }
-  buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
-    }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (typeof handlerIndex !== "undefined") {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
-      }
-      if (typeof paramIndex !== "undefined") {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
-      }
-      return "";
-    });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-  }
+        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+        for(let i = groups.length - 1; i >= 0; i--){
+            const [mark] = groups[i];
+            for(let j = tokens.length - 1; j >= 0; j--)if (-1 !== tokens[j].indexOf(mark)) {
+                tokens[j] = tokens[j].replace(mark, groups[i][1]);
+                break;
+            }
+        }
+        this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+        return paramAssoc;
+    }
+    buildRegExp() {
+        let regexp = this.root.buildRegExpStr();
+        if ("" === regexp) return [
+            /^$/,
+            [],
+            []
+        ];
+        let captureIndex = 0;
+        const indexReplacementMap = [];
+        const paramReplacementMap = [];
+        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex)=>{
+            if (void 0 !== handlerIndex) {
+                indexReplacementMap[++captureIndex] = Number(handlerIndex);
+                return "$()";
+            }
+            if (void 0 !== paramIndex) paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+            return "";
+        });
+        return [
+            new RegExp(`^${regexp}`),
+            indexReplacementMap,
+            paramReplacementMap
+        ];
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/router.js
 var emptyParam = [];
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var nullMatcher = [
+    /^$/,
+    [],
+    /* @__PURE__ */ Object.create(null)
+];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path2) {
-  return wildcardRegExpCache[path2] ?? (wildcardRegExpCache[path2] = new RegExp(
-    path2 === "*" ? "" : `^${path2.replace(
-      /\/\*$|([.\\+*[^\]$()])/g,
-      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
-    )}$`
-  ));
+function buildWildcardRegExp(path) {
+    return wildcardRegExpCache[path] ??= new RegExp("*" === path ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar)=>metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
 }
 function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+    wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 }
 function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path2, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path2, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
-      }
-      return [h, paramIndexMap];
-    });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-      const map = handlerData[i][j]?.[1];
-      if (!map) {
-        continue;
-      }
-      const keys = Object.keys(map);
-      for (let k = 0, len3 = keys.length; k < len3; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
+    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, path2) {
-  if (!middleware) {
-    return void 0;
-  }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path2)) {
-      return [...middleware[k]];
-    }
-  }
-  return void 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 RegExpRouter = class {
-  constructor() {
-    __publicField(this, "name", "RegExpRouter");
-    __publicField(this, "middleware");
-    __publicField(this, "routes");
-    this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-  }
-  add(method, path2, handler) {
-    var _a4;
-    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]];
+    name = "RegExpRouter";
+    middleware;
+    routes;
+    constructor(){
+        this.middleware = {
+            [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
+        };
+        this.routes = {
+            [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null)
+        };
+    }
+    add(method, path, handler) {
+        const { middleware, routes } = this;
+        if (!middleware || !routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        if (!middleware[method]) [
+            middleware,
+            routes
+        ].forEach((handlerMap)=>{
+            handlerMap[method] = /* @__PURE__ */ Object.create(null);
+            Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p)=>{
+                handlerMap[method][p] = [
+                    ...handlerMap[METHOD_NAME_ALL][p]
+                ];
+            });
         });
-      });
-    }
-    if (path2 === "/*") {
-      path2 = "*";
-    }
-    const paramCount = (path2.match(/\/:/g) || []).length;
-    if (/\*$/.test(path2)) {
-      const re = buildWildcardRegExp(path2);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          var _a5;
-          (_a5 = middleware[m])[path2] || (_a5[path2] = findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []);
-        });
-      } else {
-        (_a4 = middleware[method])[path2] || (_a4[path2] = findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []);
-      }
-      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])
-          );
+        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;
-    }
-    const paths = checkOptionalParameter(path2) || [path2];
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path22 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        var _a5;
-        if (method === METHOD_NAME_ALL || method === m) {
-          (_a5 = routes[m])[path22] || (_a5[path22] = [
-            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
-          ]);
-          routes[m][path22].push([handler, paramCount - len + i + 1]);
+        const paths = checkOptionalParameter(path) || [
+            path
+        ];
+        for(let i = 0, len = paths.length; i < len; i++){
+            const path2 = paths[i];
+            Object.keys(routes).forEach((m)=>{
+                if (method === METHOD_NAME_ALL || method === m) {
+                    routes[m][path2] ||= [
+                        ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+                    ];
+                    routes[m][path2].push([
+                        handler,
+                        paramCount - len + i + 1
+                    ]);
+                }
+            });
         }
-      });
-    }
-  }
-  match(method, path2) {
-    clearWildcardRegExpCache();
-    const matchers = this.buildAllMatchers();
-    this.match = (method2, path22) => {
-      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path22];
-      if (staticMatch) {
-        return staticMatch;
-      }
-      const match = path22.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
-      }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path2);
-  }
-  buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
-      matchers[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((path2) => [path2, r[method][path2]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute || (hasOwnRoute = true);
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path2) => [path2, r[METHOD_NAME_ALL][path2]])
-        );
-      }
-    });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
     }
-  }
+    match(method, path) {
+        clearWildcardRegExpCache();
+        const matchers = this.buildAllMatchers();
+        this.match = (method2, path2)=>{
+            const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+            const staticMatch = matcher[2][path2];
+            if (staticMatch) return staticMatch;
+            const match = path2.match(matcher[0]);
+            if (!match) return [
+                [],
+                emptyParam
+            ];
+            const index = match.indexOf("", 1);
+            return [
+                matcher[1][index],
+                match
+            ];
+        };
+        return this.match(method, path);
+    }
+    buildAllMatchers() {
+        const matchers = /* @__PURE__ */ Object.create(null);
+        [
+            ...Object.keys(this.routes),
+            ...Object.keys(this.middleware)
+        ].forEach((method)=>{
+            matchers[method] ||= this.buildMatcher(method);
+        });
+        this.middleware = this.routes = void 0;
+        return matchers;
+    }
+    buildMatcher(method) {
+        const routes = [];
+        let hasOwnRoute = method === METHOD_NAME_ALL;
+        [
+            this.middleware,
+            this.routes
+        ].forEach((r)=>{
+            const ownRoute = r[method] ? Object.keys(r[method]).map((path)=>[
+                    path,
+                    r[method][path]
+                ]) : [];
+            if (0 !== ownRoute.length) {
+                hasOwnRoute ||= true;
+                routes.push(...ownRoute);
+            } else if (method !== METHOD_NAME_ALL) routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path)=>[
+                    path,
+                    r[METHOD_NAME_ALL][path]
+                ]));
+        });
+        if (!hasOwnRoute) return null;
+        return buildMatcherFromPreprocessedRoutes(routes);
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/smart-router/router.js
 var SmartRouter = class {
-  constructor(init) {
-    __publicField(this, "name", "SmartRouter");
-    __publicField(this, "routers", []);
-    __publicField(this, "routes", []);
-    Object.assign(this, init);
-  }
-  add(method, path2, handler) {
-    if (!this.routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    this.routes.push([method, path2, handler]);
-  }
-  match(method, path2) {
-    if (!this.routes) {
-      throw new Error("Fatal error");
-    }
-    const { routers, routes } = this;
-    const len = routers.length;
-    let i = 0;
-    let res;
-    for (; i < len; i++) {
-      const router = routers[i];
-      try {
-        routes.forEach((args) => {
-          router.add(...args);
-        });
-        res = router.match(method, path2);
-      } catch (e) {
-        if (e instanceof UnsupportedPathError) {
-          continue;
+    name = "SmartRouter";
+    routers = [];
+    routes = [];
+    constructor(init){
+        Object.assign(this, init);
+    }
+    add(method, path, handler) {
+        if (!this.routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        this.routes.push([
+            method,
+            path,
+            handler
+        ]);
+    }
+    match(method, path) {
+        if (!this.routes) throw new Error("Fatal error");
+        const { routers, routes } = this;
+        const len = routers.length;
+        let i = 0;
+        let res;
+        for(; i < len; i++){
+            const router = routers[i];
+            try {
+                routes.forEach((args)=>{
+                    router.add(...args);
+                });
+                res = router.match(method, path);
+            } catch (e) {
+                if (e instanceof UnsupportedPathError) continue;
+                throw e;
+            }
+            this.match = router.match.bind(router);
+            this.routers = [
+                router
+            ];
+            this.routes = void 0;
+            break;
         }
-        throw e;
-      }
-      this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
-      break;
-    }
-    if (i === len) {
-      throw new Error("Fatal error");
-    }
-    this.name = `SmartRouter + ${this.activeRouter.name}`;
-    return res;
-  }
-  get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
-      throw new Error("No active router has been determined yet.");
-    }
-    return this.routers[0];
-  }
+        if (i === len) throw new Error("Fatal error");
+        this.name = `SmartRouter + ${this.activeRouter.name}`;
+        return res;
+    }
+    get activeRouter() {
+        if (this.routes || 1 !== this.routers.length) throw new Error("No active router has been determined yet.");
+        return this.routers[0];
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/node.js
-var Node2 = class {
-  constructor(method, handler, children) {
-    __publicField(this, "methods");
-    __publicField(this, "children");
-    __publicField(this, "patterns");
-    __publicField(this, "order", 0);
-    __publicField(this, "name");
-    __publicField(this, "params", /* @__PURE__ */ Object.create(null));
-    this.children = children || /* @__PURE__ */ Object.create(null);
-    this.methods = [];
-    this.name = "";
-    if (method && handler) {
-      const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
-      this.methods = [m];
-    }
-    this.patterns = [];
-  }
-  insert(method, path2, handler) {
-    this.name = `${method} ${path2}`;
-    this.order = ++this.order;
-    let curNode = this;
-    const parts = splitRoutingPath(path2);
-    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]);
+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
+            ];
         }
-        continue;
-      }
-      curNode.children[p] = new Node2();
-      const pattern = getPattern(p);
-      if (pattern) {
-        curNode.patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
-      }
-      curNode = curNode.children[p];
-    }
-    if (!curNode.methods.length) {
-      curNode.methods = [];
-    }
-    const m = /* @__PURE__ */ Object.create(null);
-    const handlerSet = {
-      handler,
-      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      name: this.name,
-      score: this.order
-    };
-    m[method] = handlerSet;
-    curNode.methods.push(m);
-    return curNode;
-  }
-  gHSets(node, method, nodeParams, params) {
-    const handlerSets = [];
-    for (let i = 0, len = node.methods.length; i < len; i++) {
-      const m = node.methods[i];
-      const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = /* @__PURE__ */ Object.create(null);
-      if (handlerSet !== void 0) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSet.possibleKeys.forEach((key) => {
-          const processed = processedSet[handlerSet.name];
-          handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
-          processedSet[handlerSet.name] = true;
-        });
-        handlerSets.push(handlerSet);
-      }
-    }
-    return handlerSets;
-  }
-  search(method, path2) {
-    const handlerSets = [];
-    this.params = /* @__PURE__ */ Object.create(null);
-    const curNode = this;
-    let curNodes = [curNode];
-    const parts = splitPath(path2);
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const part = parts[i];
-      const isLast = i === len - 1;
-      const tempNodes = [];
-      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-        const node = curNodes[j];
-        const nextNode = node.children[part];
-        if (nextNode) {
-          nextNode.params = node.params;
-          if (isLast === true) {
-            if (nextNode.children["*"]) {
-              handlerSets.push(
-                ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
-              );
+        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]);
             }
-            handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
-          } else {
-            tempNodes.push(nextNode);
-          }
+            curNode = curNode.children[p];
         }
-        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);
+        if (!curNode.methods.length) curNode.methods = [];
+        const m = /* @__PURE__ */ Object.create(null);
+        const handlerSet = {
+            handler,
+            possibleKeys: possibleKeys.filter((v, i, a)=>a.indexOf(v) === i),
+            name: this.name,
+            score: this.order
+        };
+        m[method] = handlerSet;
+        curNode.methods.push(m);
+        return curNode;
+    }
+    gHSets(node, method, nodeParams, params) {
+        const handlerSets = [];
+        for(let i = 0, len = node.methods.length; i < len; i++){
+            const m = node.methods[i];
+            const handlerSet = m[method] || m[METHOD_NAME_ALL];
+            const processedSet = /* @__PURE__ */ Object.create(null);
+            if (void 0 !== handlerSet) {
+                handlerSet.params = /* @__PURE__ */ Object.create(null);
+                handlerSet.possibleKeys.forEach((key)=>{
+                    const processed = processedSet[handlerSet.name];
+                    handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
+                    processedSet[handlerSet.name] = true;
+                });
+                handlerSets.push(handlerSet);
             }
-            continue;
-          }
-          if (part === "") {
-            continue;
-          }
-          const [key, name, matcher] = pattern;
-          const child = node.children[key];
-          const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp && matcher.test(restPathString)) {
-            params[name] = restPathString;
-            handlerSets.push(...this.gHSets(child, method, node.params, params));
-            continue;
-          }
-          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
-            if (typeof key === "string") {
-              params[name] = part;
-              if (isLast === true) {
-                handlerSets.push(...this.gHSets(child, method, params, node.params));
-                if (child.children["*"]) {
-                  handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
+        }
+        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);
+                            }
+                        }
+                    }
                 }
-              } else {
-                child.params = params;
-                tempNodes.push(child);
-              }
             }
-          }
+            curNodes = tempNodes;
         }
-      }
-      curNodes = tempNodes;
+        const results = handlerSets.sort((a, b)=>a.score - b.score);
+        return [
+            results.map(({ handler, params })=>[
+                    handler,
+                    params
+                ])
+        ];
     }
-    const results = handlerSets.sort((a, b) => {
-      return a.score - b.score;
-    });
-    return [results.map(({ handler, params }) => [handler, params])];
-  }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/router.js
 var TrieRouter = class {
-  constructor() {
-    __publicField(this, "name", "TrieRouter");
-    __publicField(this, "node");
-    this.node = new Node2();
-  }
-  add(method, path2, handler) {
-    const results = checkOptionalParameter(path2);
-    if (results) {
-      for (const p of results) {
-        this.node.insert(method, p, handler);
-      }
-      return;
-    }
-    this.node.insert(method, path2, handler);
-  }
-  match(method, path2) {
-    return this.node.search(method, path2);
-  }
+    name = "TrieRouter";
+    node;
+    constructor(){
+        this.node = new node_Node();
+    }
+    add(method, path, handler) {
+        const results = checkOptionalParameter(path);
+        if (results) {
+            for (const p of results)this.node.insert(method, p, handler);
+            return;
+        }
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono.js
-var Hono2 = class extends Hono {
-  constructor(options = {}) {
-    super(options);
-    this.router = options.router ?? new SmartRouter({
-      routers: [new RegExpRouter(), new TrieRouter()]
-    });
-  }
+var hono_Hono = class extends Hono {
+    constructor(options = {}){
+        super(options);
+        this.router = options.router ?? new SmartRouter({
+            routers: [
+                new RegExpRouter(),
+                new TrieRouter()
+            ]
+        });
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/cookie.js
 var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
 var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-var parse = (cookie, name) => {
-  const pairs = cookie.trim().split(";");
-  return pairs.reduce((parsedCookie, pairStr) => {
-    pairStr = pairStr.trim();
-    const valueStartPos = pairStr.indexOf("=");
-    if (valueStartPos === -1) {
-      return parsedCookie;
-    }
-    const cookieName = pairStr.substring(0, valueStartPos).trim();
-    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) {
-      return parsedCookie;
-    }
-    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
-      cookieValue = cookieValue.slice(1, -1);
-    }
-    if (validCookieValueRegEx.test(cookieValue)) {
-      parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
-    }
-    return parsedCookie;
-  }, {});
+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;
+    }, {});
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/helper/cookie/index.js
-var getCookie = (c, key, prefix) => {
-  const cookie = c.req.raw.headers.get("Cookie");
-  if (typeof key === "string") {
-    if (!cookie) {
-      return void 0;
-    }
-    let finalKey = key;
-    if (prefix === "secure") {
-      finalKey = "__Secure-" + key;
-    } else if (prefix === "host") {
-      finalKey = "__Host-" + key;
-    }
-    const obj2 = parse(cookie, finalKey);
-    return obj2[finalKey];
-  }
-  if (!cookie) {
-    return {};
-  }
-  const obj = parse(cookie);
-  return obj;
+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;
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/http-exception.js
 var HTTPException = class extends Error {
-  constructor(status = 500, options) {
-    super(options?.message, { cause: options?.cause });
-    __publicField(this, "res");
-    __publicField(this, "status");
-    this.res = options?.res;
-    this.status = status;
-  }
-  getResponse() {
-    if (this.res) {
-      const newResponse = new Response(this.res.body, {
-        status: this.status,
-        headers: this.res.headers
-      });
-      return newResponse;
-    }
-    return new Response(this.message, {
-      status: this.status
-    });
-  }
+    res;
+    status;
+    constructor(status = 500, options){
+        super(options?.message, {
+            cause: options?.cause
+        });
+        this.res = options?.res;
+        this.status = status;
+    }
+    getResponse() {
+        if (this.res) {
+            const newResponse = new Response(this.res.body, {
+                status: this.status,
+                headers: this.res.headers
+            });
+            return newResponse;
+        }
+        return new Response(this.message, {
+            status: this.status
+        });
+    }
 };
-
-// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/buffer.js
-var bufferToFormData = (arrayBuffer, contentType) => {
-  const response = new Response(arrayBuffer, {
-    headers: {
-      "Content-Type": contentType
-    }
-  });
-  return response.formData();
+var 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/validator/validator.js
 var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
 var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
 var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-var validator = (target, validationFunc) => {
-  return async (c, next) => {
-    let value = {};
-    const contentType = c.req.header("Content-Type");
-    switch (target) {
-      case "json":
-        if (!contentType || !jsonRegex.test(contentType)) {
-          break;
-        }
-        try {
-          value = await c.req.json();
-        } catch {
-          const message = "Malformed JSON in request body";
-          throw new HTTPException(400, { message });
-        }
-        break;
-      case "form": {
-        if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) {
-          break;
-        }
-        let formData;
-        if (c.req.bodyCache.formData) {
-          formData = await c.req.bodyCache.formData;
-        } else {
-          try {
-            const arrayBuffer = await c.req.arrayBuffer();
-            formData = await bufferToFormData(arrayBuffer, contentType);
-            c.req.bodyCache.formData = formData;
-          } catch (e) {
-            let message = "Malformed FormData request.";
-            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-            throw new HTTPException(400, { message });
-          }
+var validator = (target, validationFunc)=>async (c, next)=>{
+        let value = {};
+        const contentType = c.req.header("Content-Type");
+        switch(target){
+            case "json":
+                if (!contentType || !jsonRegex.test(contentType)) break;
+                try {
+                    value = await c.req.json();
+                } catch  {
+                    const message = "Malformed JSON in request body";
+                    throw new HTTPException(400, {
+                        message
+                    });
+                }
+                break;
+            case "form":
+                {
+                    if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) break;
+                    let formData;
+                    if (c.req.bodyCache.formData) formData = await c.req.bodyCache.formData;
+                    else try {
+                        const arrayBuffer = await c.req.arrayBuffer();
+                        formData = await bufferToFormData(arrayBuffer, contentType);
+                        c.req.bodyCache.formData = formData;
+                    } catch (e) {
+                        let message = "Malformed FormData request.";
+                        message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+                        throw new HTTPException(400, {
+                            message
+                        });
+                    }
+                    const form = {};
+                    formData.forEach((value2, key)=>{
+                        if (key.endsWith("[]")) (form[key] ??= []).push(value2);
+                        else if (Array.isArray(form[key])) form[key].push(value2);
+                        else if (key in form) form[key] = [
+                            form[key],
+                            value2
+                        ];
+                        else form[key] = value2;
+                    });
+                    value = form;
+                    break;
+                }
+            case "query":
+                value = Object.fromEntries(Object.entries(c.req.queries()).map(([k, v])=>1 === v.length ? [
+                        k,
+                        v[0]
+                    ] : [
+                        k,
+                        v
+                    ]));
+                break;
+            case "param":
+                value = c.req.param();
+                break;
+            case "header":
+                value = c.req.header();
+                break;
+            case "cookie":
+                value = getCookie(c);
+                break;
         }
-        const form = {};
-        formData.forEach((value2, key) => {
-          if (key.endsWith("[]")) {
-            ;
-            (form[key] ?? (form[key] = [])).push(value2);
-          } else if (Array.isArray(form[key])) {
-            ;
-            form[key].push(value2);
-          } else if (key in form) {
-            form[key] = [form[key], value2];
-          } else {
-            form[key] = value2;
-          }
-        });
-        value = form;
-        break;
-      }
-      case "query":
-        value = Object.fromEntries(
-          Object.entries(c.req.queries()).map(([k, v]) => {
-            return v.length === 1 ? [k, v[0]] : [k, v];
-          })
-        );
-        break;
-      case "param":
-        value = c.req.param();
-        break;
-      case "header":
-        value = c.req.header();
-        break;
-      case "cookie":
-        value = getCookie(c);
-        break;
-    }
-    const res = await validationFunc(value, c);
-    if (res instanceof Response) {
-      return res;
-    }
-    c.req.addValidatedData(target, res);
-    await next();
-  };
-};
-
-// ../../node_modules/.pnpm/valibot@0.42.1_typescript@5.6.3/node_modules/valibot/dist/index.js
+        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
-  };
+    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);
+    return store2?.get(lang);
 }
 var store3;
 function getSchemaMessage(lang) {
-  return store3?.get(lang);
+    return store3?.get(lang);
 }
 var store4;
 function getSpecificMessage(reference, lang) {
-  return store4?.get(reference)?.get(lang);
+    return store4?.get(reference)?.get(lang);
 }
 function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") {
-    return `"${input}"`;
-  }
-  if (type === "number" || type === "bigint" || type === "boolean") {
-    return `${input}`;
-  }
-  if (type === "object" || type === "function") {
-    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  }
-  return type;
+    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 = context.kind === "schema";
-  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 = typeof message === "function" ? (
-      // @ts-expect-error
-      message(issue)
-    ) : message;
-  }
-  if (isSchema) {
-    dataset.typed = false;
-  }
-  if (dataset.issues) {
-    dataset.issues.push(issue);
-  } else {
-    dataset.issues = [issue];
-  }
+    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";
+    const list = [
+        ...new Set(values)
+    ];
+    if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+    return list[0] ?? "never";
 }
 function getDefault(schema, dataset, config2) {
-  return typeof schema.default === "function" ? (
-    // @ts-expect-error
-    schema.default(dataset, config2)
-  ) : (
-    // @ts-expect-error
-    schema.default
-  );
+    return "function" == typeof schema.default ? schema.default(dataset, config2) : schema.default;
 }
-function boolean(message) {
-  return {
-    kind: "schema",
-    type: "boolean",
-    reference: boolean,
-    expects: "boolean",
-    async: false,
-    message,
-    _run(dataset, config2) {
-      if (typeof dataset.value === "boolean") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+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;
+        }
+    };
 }
 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;
-    }
-  };
+    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;
+        }
+    };
 }
-function object(entries, message) {
-  return {
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
-    async: false,
-    entries,
-    message,
-    _run(dataset, config2) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        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
-            };
-            for (const issue of valueDataset.issues) {
-              if (issue.path) {
-                issue.path.unshift(pathItem);
-              } else {
-                issue.path = [pathItem];
-              }
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) {
-              dataset.issues = valueDataset.issues;
-            }
-            if (config2.abortEarly) {
-              dataset.typed = false;
-              break;
+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;
+                }
             }
-          }
-          if (!valueDataset.typed) {
-            dataset.typed = false;
-          }
-          if (valueDataset.value !== void 0 || key in input) {
-            dataset.value[key] = valueDataset.value;
-          }
+            return this.wrapped._run(dataset, config2);
         }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+    };
+    if (0 in args) schema.default = args[0];
+    return schema;
 }
-function optional(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `(${wrapped.expects} | undefined)`,
-    async: false,
-    wrapped,
-    _run(dataset, config2) {
-      if (dataset.value === void 0) {
-        if ("default" in this) {
-          dataset.value = getDefault(
-            this,
-            dataset,
-            config2
-          );
+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
+                        };
+                        for (const issue of valueDataset.issues){
+                            if (issue.path) issue.path.unshift(pathItem);
+                            else issue.path = [
+                                pathItem
+                            ];
+                            dataset.issues?.push(issue);
+                        }
+                        if (!dataset.issues) dataset.issues = valueDataset.issues;
+                        if (config2.abortEarly) {
+                            dataset.typed = false;
+                            break;
+                        }
+                    }
+                    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;
         }
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
+    };
+}
+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;
+                }
+            }
+            return this.wrapped._run(dataset, config2);
         }
-      }
-      return this.wrapped._run(dataset, config2);
-    }
-  };
-  if (0 in args) {
-    schema.default = args[0];
-  }
-  return schema;
+    };
+    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 (typeof dataset.value === "string") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+    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;
+        }
+    };
 }
 function _subIssues(datasets) {
-  let issues;
-  if (datasets) {
-    for (const dataset of datasets) {
-      if (issues) {
-        issues.push(...dataset.issues);
-      } else {
-        issues = dataset.issues;
-      }
-    }
-  }
-  return issues;
+    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) {
+    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
+                ];
+            }
+            if (validDataset) return validDataset;
             if (typedDatasets) {
-              typedDatasets.push(optionDataset);
+                if (1 === typedDatasets.length) return typedDatasets[0];
+                _addIssue(this, "type", dataset, config2, {
+                    issues: _subIssues(typedDatasets)
+                });
+                dataset.typed = true;
             } else {
-              typedDatasets = [optionDataset];
+                if (untypedDatasets?.length === 1) return untypedDatasets[0];
+                _addIssue(this, "type", dataset, config2, {
+                    issues: _subIssues(untypedDatasets)
+                });
             }
-          } else {
-            validDataset = optionDataset;
-            break;
-          }
-        } else {
-          if (untypedDatasets) {
-            untypedDatasets.push(optionDataset);
-          } else {
-            untypedDatasets = [optionDataset];
-          }
+            return dataset;
         }
-      }
-      if (validDataset) {
-        return validDataset;
-      }
-      if (typedDatasets) {
-        if (typedDatasets.length === 1) {
-          return typedDatasets[0];
-        }
-        _addIssue(this, "type", dataset, config2, {
-          issues: _subIssues(typedDatasets)
-        });
-        dataset.typed = true;
-      } else if (untypedDatasets?.length === 1) {
-        return untypedDatasets[0];
-      } else {
-        _addIssue(this, "type", dataset, config2, {
-          issues: _subIssues(untypedDatasets)
-        });
-      }
-      return dataset;
-    }
-  };
+    };
 }
 function omit(schema, keys) {
-  const entries = {
-    ...schema.entries
-  };
-  for (const key of keys) {
-    delete entries[key];
-  }
-  return { ...schema, entries };
+    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 };
+    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
-  };
+    const dataset = await schema._run({
+        typed: false,
+        value: input
+    }, getGlobalConfig(config2));
+    return {
+        typed: dataset.typed,
+        success: !dataset.issues,
+        output: dataset.value,
+        issues: dataset.issues
+    };
 }
-
-// ../../node_modules/.pnpm/@hono+valibot-validator@0.4.1_hono@4.6.3_valibot@0.42.1_typescript@5.6.3_/node_modules/@hono/valibot-validator/dist/index.js
-var vValidator = (target, schema, hook) => (
-  // @ts-expect-error not typed well
-  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;
-  })
-);
-
-// src-server/rpc.ts
-var import_plugin_core = require("@hot-updater/plugin-core");
-var bundleSchema = object({
-  platform: union([literal("ios"), literal("android")]),
-  targetVersion: string(),
-  id: string(),
-  forceUpdate: boolean(),
-  enabled: boolean(),
-  file: string(),
-  hash: string(),
-  message: optional(string(), "")
+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(),
+    forceUpdate: dist_boolean(),
+    enabled: dist_boolean(),
+    fileUrl: string(),
+    fileHash: string(),
+    gitCommitHash: nullable(string()),
+    message: nullable(string())
 });
-var config = null;
-var rpc = new Hono2().get("/loadConfig", async (c) => {
-  config = await (0, import_plugin_core.loadConfig)();
-  return c.json(true);
-}).get("/isConfigLoaded", (c) => {
-  return c.json(config !== null);
-}).get("/getBundles", async (c) => {
-  if (!config) {
-    config = await (0, import_plugin_core.loadConfig)();
-  }
-  const databasePlugin = config?.database({
-    cwd: (0, import_plugin_core.getCwd)()
-  });
-  const bundles = await databasePlugin?.getBundles();
-  return c.json(bundles ?? []);
-}).post(
-  "/getBundleById",
-  vValidator("json", object({ bundleId: string() })),
-  async (c) => {
+let rpc_config = null;
+const rpc = new hono_Hono().get("/loadConfig", async (c)=>{
+    rpc_config = await (0, plugin_core_namespaceObject.loadConfig)();
+    return c.json(true);
+}).get("/getConfig", async (c)=>{
+    if (!rpc_config) rpc_config = await (0, plugin_core_namespaceObject.loadConfig)();
+    return c.json({
+        console: rpc_config?.console
+    });
+}).get("/isConfigLoaded", (c)=>c.json(null !== rpc_config)).get("/getBundles", async (c)=>{
+    if (!rpc_config) rpc_config = await (0, plugin_core_namespaceObject.loadConfig)();
+    const databasePlugin = rpc_config?.database({
+        cwd: plugin_core_namespaceObject.getCwd()
+    });
+    const bundles = await databasePlugin?.getBundles();
+    return c.json(bundles ?? []);
+}).post("/getBundleById", vValidator("json", dist_object({
+    bundleId: string()
+})), async (c)=>{
     const { bundleId } = c.req.valid("json");
-    if (!config) {
-      config = await (0, import_plugin_core.loadConfig)();
-    }
-    const databasePlugin = config?.database({
-      cwd: (0, import_plugin_core.getCwd)()
+    if (!rpc_config) rpc_config = await (0, plugin_core_namespaceObject.loadConfig)();
+    const databasePlugin = rpc_config?.database({
+        cwd: plugin_core_namespaceObject.getCwd()
     });
     const bundle = await databasePlugin?.getBundleById(bundleId);
     return c.json(bundle ?? null);
-  }
-).post(
-  "/updateBundle",
-  vValidator(
-    "json",
-    object({
-      targetBundleId: string(),
-      bundle: partial(omit(bundleSchema, ["id"]))
-    })
-  ),
-  async (c) => {
+}).post("/updateBundle", vValidator("json", dist_object({
+    targetBundleId: string(),
+    bundle: partial(omit(bundleSchema, [
+        "id"
+    ]))
+})), async (c)=>{
     const { targetBundleId, bundle } = c.req.valid("json");
-    if (!config) {
-      config = await (0, import_plugin_core.loadConfig)();
-    }
-    const databasePlugin = config?.database({
-      cwd: (0, import_plugin_core.getCwd)()
+    if (!rpc_config) rpc_config = await (0, plugin_core_namespaceObject.loadConfig)();
+    const databasePlugin = rpc_config?.database({
+        cwd: plugin_core_namespaceObject.getCwd()
     });
     await databasePlugin?.updateBundle(targetBundleId, bundle);
     await databasePlugin?.commitBundle();
     return c.json(true);
-  }
-);
-
-// src-server/index.ts
-var relativePathToScript = import_path.default.relative(process.cwd(), __dirname);
-var app = new Hono2().get("/ping", (c) => c.text("pong")).route("/rpc", rpc).use(
-  "/static/*",
-  serveStatic({
+});
+const relativePathToScript = external_path_default().relative(process.cwd(), __dirname);
+const src_server_rslib_entry_app = new hono_Hono().get("/ping", (c)=>c.text("pong")).route("/rpc", rpc).use("/static/*", serveStatic({
     root: relativePathToScript
-  })
-).get(
-  "*",
-  serveStatic({
+})).get("*", serveStatic({
     root: relativePathToScript,
     path: "index.html"
-  })
-);
-var src_server_default = app;
+}));
+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', {
+    value: true
+});