Erster Docker-Stand

_node_modules/hono/dist/cjs/adapter/aws-lambda/handler.js

@@ -0,0 +1,398 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  ALBProcessor: () => ALBProcessor,
+  EventProcessor: () => EventProcessor,
+  EventV1Processor: () => EventV1Processor,
+  EventV2Processor: () => EventV2Processor,
+  LatticeV2Processor: () => LatticeV2Processor,
+  defaultIsContentTypeBinary: () => defaultIsContentTypeBinary,
+  getProcessor: () => getProcessor,
+  handle: () => handle,
+  isContentEncodingBinary: () => isContentEncodingBinary,
+  streamHandle: () => streamHandle
+});
+module.exports = __toCommonJS(handler_exports);
+var import_encode = require("../../utils/encode");
+function sanitizeHeaderValue(value) {
+  const hasNonAscii = /[^\x00-\x7F]/.test(value);
+  if (!hasNonAscii) {
+    return value;
+  }
+  return encodeURIComponent(value);
+}
+const getRequestContext = (event) => {
+  return event.requestContext;
+};
+const streamToNodeStream = async (reader, writer) => {
+  let readResult = await reader.read();
+  while (!readResult.done) {
+    writer.write(readResult.value);
+    readResult = await reader.read();
+  }
+  writer.end();
+};
+const streamHandle = (app) => {
+  return awslambda.streamifyResponse(
+    async (event, responseStream, context) => {
+      const processor = getProcessor(event);
+      try {
+        const req = processor.createRequest(event);
+        const requestContext = getRequestContext(event);
+        const res = await app.fetch(req, {
+          event,
+          requestContext,
+          context
+        });
+        const headers = {};
+        const cookies = [];
+        res.headers.forEach((value, name) => {
+          if (name === "set-cookie") {
+            cookies.push(value);
+          } else {
+            headers[name] = value;
+          }
+        });
+        const httpResponseMetadata = {
+          statusCode: res.status,
+          headers,
+          cookies
+        };
+        responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+        if (res.body) {
+          await streamToNodeStream(res.body.getReader(), responseStream);
+        } else {
+          responseStream.write("");
+        }
+      } catch (error) {
+        console.error("Error processing request:", error);
+        responseStream.write("Internal Server Error");
+      } finally {
+        responseStream.end();
+      }
+    }
+  );
+};
+const handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
+  return async (event, lambdaContext) => {
+    const processor = getProcessor(event);
+    const req = processor.createRequest(event);
+    const requestContext = getRequestContext(event);
+    const res = await app.fetch(req, {
+      event,
+      requestContext,
+      lambdaContext
+    });
+    return processor.createResult(event, res, { isContentTypeBinary });
+  };
+};
+class EventProcessor {
+  getHeaderValue(headers, key) {
+    const value = headers ? Array.isArray(headers[key]) ? headers[key][0] : headers[key] : void 0;
+    return value;
+  }
+  getDomainName(event) {
+    if (event.requestContext && "domainName" in event.requestContext) {
+      return event.requestContext.domainName;
+    }
+    const hostFromHeaders = this.getHeaderValue(event.headers, "host");
+    if (hostFromHeaders) {
+      return hostFromHeaders;
+    }
+    const multiValueHeaders = "multiValueHeaders" in event ? event.multiValueHeaders : {};
+    const hostFromMultiValueHeaders = this.getHeaderValue(multiValueHeaders, "host");
+    return hostFromMultiValueHeaders;
+  }
+  createRequest(event) {
+    const queryString = this.getQueryString(event);
+    const domainName = this.getDomainName(event);
+    const path = this.getPath(event);
+    const urlPath = `https://${domainName}${path}`;
+    const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+    const headers = this.getHeaders(event);
+    const method = this.getMethod(event);
+    const requestInit = {
+      headers,
+      method
+    };
+    if (event.body) {
+      requestInit.body = event.isBase64Encoded ? (0, import_encode.decodeBase64)(event.body) : event.body;
+    }
+    return new Request(url, requestInit);
+  }
+  async createResult(event, res, options) {
+    const contentType = res.headers.get("content-type");
+    const isContentTypeBinary = options.isContentTypeBinary ?? defaultIsContentTypeBinary;
+    let isBase64Encoded = contentType && isContentTypeBinary(contentType) ? true : false;
+    if (!isBase64Encoded) {
+      const contentEncoding = res.headers.get("content-encoding");
+      isBase64Encoded = isContentEncodingBinary(contentEncoding);
+    }
+    const body = isBase64Encoded ? (0, import_encode.encodeBase64)(await res.arrayBuffer()) : await res.text();
+    const result = {
+      body,
+      statusCode: res.status,
+      isBase64Encoded,
+      ..."multiValueHeaders" in event && event.multiValueHeaders ? {
+        multiValueHeaders: {}
+      } : {
+        headers: {}
+      }
+    };
+    this.setCookies(event, res, result);
+    if (result.multiValueHeaders) {
+      res.headers.forEach((value, key) => {
+        result.multiValueHeaders[key] = [value];
+      });
+    } else {
+      res.headers.forEach((value, key) => {
+        result.headers[key] = value;
+      });
+    }
+    return result;
+  }
+  setCookies(event, res, result) {
+    if (res.headers.has("set-cookie")) {
+      const cookies = res.headers.getSetCookie ? res.headers.getSetCookie() : Array.from(res.headers.entries()).filter(([k]) => k === "set-cookie").map(([, v]) => v);
+      if (Array.isArray(cookies)) {
+        this.setCookiesToResult(result, cookies);
+        res.headers.delete("set-cookie");
+      }
+    }
+  }
+}
+class EventV2Processor extends EventProcessor {
+  getPath(event) {
+    return event.rawPath;
+  }
+  getMethod(event) {
+    return event.requestContext.http.method;
+  }
+  getQueryString(event) {
+    return event.rawQueryString;
+  }
+  getCookies(event, headers) {
+    if (Array.isArray(event.cookies)) {
+      headers.set("Cookie", event.cookies.join("; "));
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    result.cookies = cookies;
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, v);
+        }
+      }
+    }
+    return headers;
+  }
+}
+const v2Processor = new EventV2Processor();
+class EventV1Processor extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(
+        ([key, values]) => values.map((value) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
+      ).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
+    }
+  }
+  getCookies(event, headers) {
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, sanitizeHeaderValue(v));
+        }
+      }
+    }
+    if (event.multiValueHeaders) {
+      for (const [k, values] of Object.entries(event.multiValueHeaders)) {
+        if (values) {
+          const foundK = headers.get(k);
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
+        }
+      }
+    }
+    return headers;
+  }
+  setCookiesToResult(result, cookies) {
+    result.multiValueHeaders = {
+      "set-cookie": cookies
+    };
+  }
+}
+const v1Processor = new EventV1Processor();
+class ALBProcessor extends EventProcessor {
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.multiValueHeaders) {
+      for (const [key, values] of Object.entries(event.multiValueHeaders)) {
+        if (values && Array.isArray(values)) {
+          const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+          headers.set(key, sanitizedValue);
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(event.headers ?? {})) {
+        if (value) {
+          headers.set(key, sanitizeHeaderValue(value));
+        }
+      }
+    }
+    return headers;
+  }
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+    }
+  }
+  getCookies(event, headers) {
+    let cookie;
+    if (event.multiValueHeaders) {
+      cookie = event.multiValueHeaders["cookie"]?.join("; ");
+    } else {
+      cookie = event.headers ? event.headers["cookie"] : void 0;
+    }
+    if (cookie) {
+      headers.append("Cookie", cookie);
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    if (result.multiValueHeaders) {
+      result.multiValueHeaders["set-cookie"] = cookies;
+    } else {
+      result.headers["set-cookie"] = cookies.join(", ");
+    }
+  }
+}
+const albProcessor = new ALBProcessor();
+class LatticeV2Processor extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.method;
+  }
+  getQueryString() {
+    return "";
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.headers) {
+      for (const [k, values] of Object.entries(event.headers)) {
+        if (values) {
+          const foundK = headers.get(k);
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
+        }
+      }
+    }
+    return headers;
+  }
+  getCookies() {
+  }
+  setCookiesToResult(result, cookies) {
+    result.headers = {
+      ...result.headers,
+      "set-cookie": cookies.join(", ")
+    };
+  }
+}
+const latticeV2Processor = new LatticeV2Processor();
+const getProcessor = (event) => {
+  if (isProxyEventALB(event)) {
+    return albProcessor;
+  }
+  if (isProxyEventV2(event)) {
+    return v2Processor;
+  }
+  if (isLatticeEventV2(event)) {
+    return latticeV2Processor;
+  }
+  return v1Processor;
+};
+const isProxyEventALB = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "elb");
+  }
+  return false;
+};
+const isProxyEventV2 = (event) => {
+  return Object.hasOwn(event, "rawPath");
+};
+const isLatticeEventV2 = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "serviceArn");
+  }
+  return false;
+};
+const defaultIsContentTypeBinary = (contentType) => {
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/.test(
+    contentType
+  );
+};
+const isContentEncodingBinary = (contentEncoding) => {
+  if (contentEncoding === null) {
+    return false;
+  }
+  return /^(gzip|deflate|compress|br)/.test(contentEncoding);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALBProcessor,
+  EventProcessor,
+  EventV1Processor,
+  EventV2Processor,
+  LatticeV2Processor,
+  defaultIsContentTypeBinary,
+  getProcessor,
+  handle,
+  isContentEncodingBinary,
+  streamHandle
+});

_node_modules/hono/dist/cjs/adapter/aws-lambda/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aws_lambda_exports = {};
+__export(aws_lambda_exports, {
+  defaultIsContentTypeBinary: () => import_handler.defaultIsContentTypeBinary,
+  handle: () => import_handler.handle,
+  streamHandle: () => import_handler.streamHandle
+});
+module.exports = __toCommonJS(aws_lambda_exports);
+var import_handler = require("./handler");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultIsContentTypeBinary,
+  handle,
+  streamHandle
+});

_node_modules/hono/dist/cjs/adapter/aws-lambda/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

_node_modules/hono/dist/cjs/adapter/bun/conninfo.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+var import_server = require("./server");
+const getConnInfo = (c) => {
+  const server = (0, import_server.getBunServer)(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  if (typeof server.requestIP !== "function") {
+    throw new TypeError("server.requestIP is not a function.");
+  }
+  const info = server.requestIP(c.req.raw);
+  if (!info) {
+    return {
+      remote: {}
+    };
+  }
+  return {
+    remote: {
+      address: info.address,
+      addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+      port: info.port
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

_node_modules/hono/dist/cjs/adapter/bun/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bun_exports = {};
+__export(bun_exports, {
+  bunFileSystemModule: () => import_ssg.bunFileSystemModule,
+  createBunWebSocket: () => import_websocket.createBunWebSocket,
+  getConnInfo: () => import_conninfo.getConnInfo,
+  serveStatic: () => import_serve_static.serveStatic,
+  toSSG: () => import_ssg.toSSG,
+  upgradeWebSocket: () => import_websocket.upgradeWebSocket,
+  websocket: () => import_websocket.websocket
+});
+module.exports = __toCommonJS(bun_exports);
+var import_serve_static = require("./serve-static");
+var import_ssg = require("./ssg");
+var import_websocket = require("./websocket");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bunFileSystemModule,
+  createBunWebSocket,
+  getConnInfo,
+  serveStatic,
+  toSSG,
+  upgradeWebSocket,
+  websocket
+});

_node_modules/hono/dist/cjs/adapter/bun/serve-static.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_static_exports = {};
+__export(serve_static_exports, {
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(serve_static_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_serve_static = require("../../middleware/serve-static");
+const serveStatic = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await (0, import_promises.stat)(path);
+        isDir2 = stats.isDirectory();
+      } catch {
+      }
+      return isDir2;
+    };
+    return (0, import_serve_static.serveStatic)({
+      ...options,
+      getContent,
+      join: import_node_path.join,
+      isDir
+    })(c, next);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/bun/server.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  getBunServer: () => getBunServer
+});
+module.exports = __toCommonJS(server_exports);
+const getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBunServer
+});

_node_modules/hono/dist/cjs/adapter/bun/ssg.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  bunFileSystemModule: () => bunFileSystemModule,
+  toSSG: () => toSSG
+});
+module.exports = __toCommonJS(ssg_exports);
+var import_ssg = require("../../helper/ssg");
+const { write } = Bun;
+const bunFileSystemModule = {
+  writeFile: async (path, data) => {
+    await write(path, data);
+  },
+  mkdir: async () => {
+  }
+};
+const toSSG = async (app, options) => {
+  return (0, import_ssg.toSSG)(app, bunFileSystemModule, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bunFileSystemModule,
+  toSSG
+});

_node_modules/hono/dist/cjs/adapter/bun/websocket.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websocket_exports = {};
+__export(websocket_exports, {
+  createBunWebSocket: () => createBunWebSocket,
+  createWSContext: () => createWSContext,
+  upgradeWebSocket: () => upgradeWebSocket,
+  websocket: () => websocket
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_websocket = require("../../helper/websocket");
+var import_server = require("./server");
+const createWSContext = (ws) => {
+  return new import_websocket.WSContext({
+    send: (source, options) => {
+      ws.send(source, options?.compress);
+    },
+    raw: ws,
+    readyState: ws.readyState,
+    url: ws.data.url,
+    protocol: ws.data.protocol,
+    close(code, reason) {
+      ws.close(code, reason);
+    }
+  });
+};
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)((c, events) => {
+  const server = (0, import_server.getBunServer)(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      protocol: c.req.url
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+const websocket = {
+  open(ws) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onOpen) {
+      websocketListeners.onOpen(new Event("open"), createWSContext(ws));
+    }
+  },
+  close(ws, code, reason) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onClose) {
+      websocketListeners.onClose(
+        new CloseEvent("close", {
+          code,
+          reason
+        }),
+        createWSContext(ws)
+      );
+    }
+  },
+  message(ws, message) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onMessage) {
+      const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
+      websocketListeners.onMessage((0, import_websocket.createWSMessageEvent)(normalizedReceiveData), createWSContext(ws));
+    }
+  }
+};
+const createBunWebSocket = () => ({
+  upgradeWebSocket,
+  websocket
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBunWebSocket,
+  createWSContext,
+  upgradeWebSocket,
+  websocket
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-pages/handler.js

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  handle: () => handle,
+  handleMiddleware: () => handleMiddleware,
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(handler_exports);
+var import_context = require("../../context");
+var import_http_exception = require("../../http-exception");
+const handle = (app) => (eventContext) => {
+  return app.fetch(
+    eventContext.request,
+    { ...eventContext.env, eventContext },
+    {
+      waitUntil: eventContext.waitUntil,
+      passThroughOnException: eventContext.passThroughOnException,
+      props: {}
+    }
+  );
+};
+function handleMiddleware(middleware) {
+  return async (executionCtx) => {
+    const context = new import_context.Context(executionCtx.request, {
+      env: { ...executionCtx.env, eventContext: executionCtx },
+      executionCtx
+    });
+    let response = void 0;
+    try {
+      response = await middleware(context, async () => {
+        try {
+          context.res = await executionCtx.next();
+        } catch (error) {
+          if (error instanceof Error) {
+            context.error = error;
+          } else {
+            throw error;
+          }
+        }
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        context.error = error;
+      } else {
+        throw error;
+      }
+    }
+    if (response) {
+      return response;
+    }
+    if (context.error instanceof import_http_exception.HTTPException) {
+      return context.error.getResponse();
+    }
+    if (context.error) {
+      throw context.error;
+    }
+    return context.res;
+  };
+}
+const serveStatic = () => {
+  return async (c) => {
+    const env = c.env;
+    const res = await env.ASSETS.fetch(c.req.raw);
+    if (res.status === 404) {
+      return c.notFound();
+    }
+    return res;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle,
+  handleMiddleware,
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-pages/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudflare_pages_exports = {};
+__export(cloudflare_pages_exports, {
+  handle: () => import_handler.handle,
+  handleMiddleware: () => import_handler.handleMiddleware,
+  serveStatic: () => import_handler.serveStatic
+});
+module.exports = __toCommonJS(cloudflare_pages_exports);
+var import_handler = require("./handler");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle,
+  handleMiddleware,
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/conninfo.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+const getConnInfo = (c) => ({
+  remote: {
+    address: c.req.header("cf-connecting-ip")
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudflare_workers_exports = {};
+__export(cloudflare_workers_exports, {
+  getConnInfo: () => import_conninfo.getConnInfo,
+  serveStatic: () => import_serve_static_module.serveStatic,
+  upgradeWebSocket: () => import_websocket.upgradeWebSocket
+});
+module.exports = __toCommonJS(cloudflare_workers_exports);
+var import_serve_static_module = require("./serve-static-module");
+var import_websocket = require("./websocket");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo,
+  serveStatic,
+  upgradeWebSocket
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/serve-static-module.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_static_module_exports = {};
+__export(serve_static_module_exports, {
+  serveStatic: () => module2
+});
+module.exports = __toCommonJS(serve_static_module_exports);
+var import_serve_static = require("./serve-static");
+const module2 = (options) => {
+  return (0, import_serve_static.serveStatic)(options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/serve-static.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_static_exports = {};
+__export(serve_static_exports, {
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(serve_static_exports);
+var import_serve_static = require("../../middleware/serve-static");
+var import_utils = require("./utils");
+const serveStatic = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      return (0, import_utils.getContentFromKVAsset)(path, {
+        manifest: options.manifest,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : void 0
+      });
+    };
+    return (0, import_serve_static.serveStatic)({
+      ...options,
+      getContent
+    })(c, next);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getContentFromKVAsset: () => getContentFromKVAsset
+});
+module.exports = __toCommonJS(utils_exports);
+const getContentFromKVAsset = async (path, options) => {
+  let ASSET_MANIFEST;
+  if (options && options.manifest) {
+    if (typeof options.manifest === "string") {
+      ASSET_MANIFEST = JSON.parse(options.manifest);
+    } else {
+      ASSET_MANIFEST = options.manifest;
+    }
+  } else {
+    if (typeof __STATIC_CONTENT_MANIFEST === "string") {
+      ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+    } else {
+      ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+    }
+  }
+  let ASSET_NAMESPACE;
+  if (options && options.namespace) {
+    ASSET_NAMESPACE = options.namespace;
+  } else {
+    ASSET_NAMESPACE = __STATIC_CONTENT;
+  }
+  const key = ASSET_MANIFEST[path] || path;
+  if (!key) {
+    return null;
+  }
+  const content = await ASSET_NAMESPACE.get(key, { type: "stream" });
+  if (!content) {
+    return null;
+  }
+  return content;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContentFromKVAsset
+});

_node_modules/hono/dist/cjs/adapter/cloudflare-workers/websocket.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websocket_exports = {};
+__export(websocket_exports, {
+  upgradeWebSocket: () => upgradeWebSocket
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_websocket = require("../../helper/websocket");
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(async (c, events) => {
+  const upgradeHeader = c.req.header("Upgrade");
+  if (upgradeHeader !== "websocket") {
+    return;
+  }
+  const webSocketPair = new WebSocketPair();
+  const client = webSocketPair[0];
+  const server = webSocketPair[1];
+  const wsContext = new import_websocket.WSContext({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol;
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState;
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source)
+  });
+  if (events.onClose) {
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+  }
+  if (events.onMessage) {
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+  }
+  if (events.onError) {
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+  }
+  server.accept?.();
+  return new Response(null, {
+    status: 101,
+    // @ts-expect-error - webSocket is not typed
+    webSocket: client
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  upgradeWebSocket
+});

_node_modules/hono/dist/cjs/adapter/deno/conninfo.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+const getConnInfo = (c) => {
+  const { remoteAddr } = c.env;
+  return {
+    remote: {
+      address: remoteAddr.hostname,
+      port: remoteAddr.port,
+      transport: remoteAddr.transport
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

_node_modules/hono/dist/cjs/adapter/deno/deno.d.js

@@ -0,0 +1 @@
+"use strict";

_node_modules/hono/dist/cjs/adapter/deno/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deno_exports = {};
+__export(deno_exports, {
+  denoFileSystemModule: () => import_ssg.denoFileSystemModule,
+  getConnInfo: () => import_conninfo.getConnInfo,
+  serveStatic: () => import_serve_static.serveStatic,
+  toSSG: () => import_ssg.toSSG,
+  upgradeWebSocket: () => import_websocket.upgradeWebSocket
+});
+module.exports = __toCommonJS(deno_exports);
+var import_serve_static = require("./serve-static");
+var import_ssg = require("./ssg");
+var import_websocket = require("./websocket");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  denoFileSystemModule,
+  getConnInfo,
+  serveStatic,
+  toSSG,
+  upgradeWebSocket
+});

_node_modules/hono/dist/cjs/adapter/deno/serve-static.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_static_exports = {};
+__export(serve_static_exports, {
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(serve_static_exports);
+var import_node_path = require("node:path");
+var import_serve_static = require("../../middleware/serve-static");
+const { open, lstatSync, errors } = Deno;
+const serveStatic = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      try {
+        if (isDir(path)) {
+          return null;
+        }
+        const file = await open(path);
+        return file.readable;
+      } catch (e) {
+        if (!(e instanceof errors.NotFound)) {
+          console.warn(`${e}`);
+        }
+        return null;
+      }
+    };
+    const isDir = (path) => {
+      let isDir2;
+      try {
+        const stat = lstatSync(path);
+        isDir2 = stat.isDirectory;
+      } catch {
+      }
+      return isDir2;
+    };
+    return (0, import_serve_static.serveStatic)({
+      ...options,
+      getContent,
+      join: import_node_path.join,
+      isDir
+    })(c, next);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

_node_modules/hono/dist/cjs/adapter/deno/ssg.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  denoFileSystemModule: () => denoFileSystemModule,
+  toSSG: () => toSSG
+});
+module.exports = __toCommonJS(ssg_exports);
+var import_ssg = require("../../helper/ssg/index");
+const denoFileSystemModule = {
+  writeFile: async (path, data) => {
+    const uint8Data = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    await Deno.writeFile(path, uint8Data);
+  },
+  mkdir: async (path, options) => {
+    return Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+};
+const toSSG = async (app, options) => {
+  return (0, import_ssg.toSSG)(app, denoFileSystemModule, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  denoFileSystemModule,
+  toSSG
+});

_node_modules/hono/dist/cjs/adapter/deno/websocket.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websocket_exports = {};
+__export(websocket_exports, {
+  upgradeWebSocket: () => upgradeWebSocket
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_websocket = require("../../helper/websocket");
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(async (c, events, options) => {
+  if (c.req.header("upgrade") !== "websocket") {
+    return;
+  }
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options ?? {});
+  const wsContext = new import_websocket.WSContext({
+    close: (code, reason) => socket.close(code, reason),
+    get protocol() {
+      return socket.protocol;
+    },
+    raw: socket,
+    get readyState() {
+      return socket.readyState;
+    },
+    url: socket.url ? new URL(socket.url) : null,
+    send: (source) => socket.send(source)
+  });
+  socket.onopen = (evt) => events.onOpen?.(evt, wsContext);
+  socket.onmessage = (evt) => events.onMessage?.(evt, wsContext);
+  socket.onclose = (evt) => events.onClose?.(evt, wsContext);
+  socket.onerror = (evt) => events.onError?.(evt, wsContext);
+  return response;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  upgradeWebSocket
+});

_node_modules/hono/dist/cjs/adapter/lambda-edge/conninfo.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+const getConnInfo = (c) => ({
+  remote: {
+    address: c.env.event.Records[0].cf.request.clientIp
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

_node_modules/hono/dist/cjs/adapter/lambda-edge/handler.js

@@ -0,0 +1,114 @@
+"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 __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 handler_exports = {};
+__export(handler_exports, {
+  createBody: () => createBody,
+  handle: () => handle,
+  isContentTypeBinary: () => isContentTypeBinary
+});
+module.exports = __toCommonJS(handler_exports);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_encode = require("../../utils/encode");
+globalThis.crypto ??= import_node_crypto.default;
+const convertHeaders = (headers) => {
+  const cfHeaders = {};
+  headers.forEach((value, key) => {
+    cfHeaders[key.toLowerCase()] = [
+      ...cfHeaders[key.toLowerCase()] || [],
+      { key: key.toLowerCase(), value }
+    ];
+  });
+  return cfHeaders;
+};
+const handle = (app) => {
+  return async (event, context, callback) => {
+    const res = await app.fetch(createRequest(event), {
+      event,
+      context,
+      callback: (err, result) => {
+        callback?.(err, result);
+      },
+      config: event.Records[0].cf.config,
+      request: event.Records[0].cf.request,
+      response: event.Records[0].cf.response
+    });
+    return createResult(res);
+  };
+};
+const createResult = async (res) => {
+  const isBase64Encoded = isContentTypeBinary(res.headers.get("content-type") || "");
+  const body = isBase64Encoded ? (0, import_encode.encodeBase64)(await res.arrayBuffer()) : await res.text();
+  return {
+    status: res.status.toString(),
+    headers: convertHeaders(res.headers),
+    body,
+    ...isBase64Encoded && { bodyEncoding: "base64" }
+  };
+};
+const createRequest = (event) => {
+  const queryString = event.Records[0].cf.request.querystring;
+  const host = event.Records[0].cf.request.headers?.host?.[0]?.value || event.Records[0].cf.config.distributionDomainName;
+  const urlPath = `https://${host}${event.Records[0].cf.request.uri}`;
+  const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+  const headers = new Headers();
+  Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
+    v.forEach((header) => headers.set(k, header.value));
+  });
+  const requestBody = event.Records[0].cf.request.body;
+  const method = event.Records[0].cf.request.method;
+  const body = createBody(method, requestBody);
+  return new Request(url, {
+    headers,
+    method,
+    body
+  });
+};
+const createBody = (method, requestBody) => {
+  if (!requestBody || !requestBody.data) {
+    return void 0;
+  }
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  if (requestBody.encoding === "base64") {
+    return (0, import_encode.decodeBase64)(requestBody.data);
+  }
+  return requestBody.data;
+};
+const isContentTypeBinary = (contentType) => {
+  return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(
+    contentType
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBody,
+  handle,
+  isContentTypeBinary
+});

_node_modules/hono/dist/cjs/adapter/lambda-edge/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lambda_edge_exports = {};
+__export(lambda_edge_exports, {
+  getConnInfo: () => import_conninfo.getConnInfo,
+  handle: () => import_handler.handle
+});
+module.exports = __toCommonJS(lambda_edge_exports);
+var import_handler = require("./handler");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo,
+  handle
+});

_node_modules/hono/dist/cjs/adapter/netlify/handler.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  handle: () => handle
+});
+module.exports = __toCommonJS(handler_exports);
+const handle = (app) => {
+  return (req, context) => {
+    return app.fetch(req, { context });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle
+});

_node_modules/hono/dist/cjs/adapter/netlify/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var netlify_exports = {};
+module.exports = __toCommonJS(netlify_exports);
+__reExport(netlify_exports, require("./mod"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./mod")
+});

_node_modules/hono/dist/cjs/adapter/netlify/mod.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mod_exports = {};
+__export(mod_exports, {
+  handle: () => import_handler.handle
+});
+module.exports = __toCommonJS(mod_exports);
+var import_handler = require("./handler");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle
+});

_node_modules/hono/dist/cjs/adapter/service-worker/handler.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  handle: () => handle
+});
+module.exports = __toCommonJS(handler_exports);
+const handle = (app, opts = {
+  // To use `fetch` on a Service Worker correctly, bind it to `globalThis`.
+  fetch: globalThis.fetch.bind(globalThis)
+}) => {
+  return (evt) => {
+    evt.respondWith(
+      (async () => {
+        const res = await app.fetch(evt.request, {}, evt);
+        if (opts.fetch && res.status === 404) {
+          return await opts.fetch(evt.request);
+        }
+        return res;
+      })()
+    );
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle
+});

_node_modules/hono/dist/cjs/adapter/service-worker/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_worker_exports = {};
+__export(service_worker_exports, {
+  fire: () => fire,
+  handle: () => import_handler.handle
+});
+module.exports = __toCommonJS(service_worker_exports);
+var import_handler = require("./handler");
+const fire = (app, options = {
+  fetch: void 0
+}) => {
+  addEventListener("fetch", (0, import_handler.handle)(app, options));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fire,
+  handle
+});

_node_modules/hono/dist/cjs/adapter/service-worker/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

_node_modules/hono/dist/cjs/adapter/vercel/conninfo.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+const getConnInfo = (c) => ({
+  remote: {
+    // https://github.com/vercel/vercel/blob/b70bfb5fbf28a4650d4042ce68ca5c636d37cf44/packages/edge/src/edge-headers.ts#L10-L12C32
+    address: c.req.header("x-real-ip")
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

_node_modules/hono/dist/cjs/adapter/vercel/handler.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  handle: () => handle
+});
+module.exports = __toCommonJS(handler_exports);
+const handle = (app) => (req) => {
+  return app.fetch(req);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle
+});

_node_modules/hono/dist/cjs/adapter/vercel/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vercel_exports = {};
+__export(vercel_exports, {
+  getConnInfo: () => import_conninfo.getConnInfo,
+  handle: () => import_handler.handle
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_handler = require("./handler");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo,
+  handle
+});

_node_modules/hono/dist/cjs/client/client.js

@@ -0,0 +1,190 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  hc: () => hc
+});
+module.exports = __toCommonJS(client_exports);
+var import_cookie = require("../utils/cookie");
+var import_utils = require("./utils");
+const createProxy = (callback, path) => {
+  const proxy = new Proxy(() => {
+  }, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") {
+        return void 0;
+      }
+      return createProxy(callback, [...path, key]);
+    },
+    apply(_1, _2, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+};
+class ClientRequestImpl {
+  url;
+  method;
+  buildSearchParams;
+  queryParams = void 0;
+  pathParams = {};
+  rBody;
+  cType = void 0;
+  constructor(url, method, options) {
+    this.url = url;
+    this.method = method;
+    this.buildSearchParams = options.buildSearchParams;
+  }
+  fetch = async (args, opt) => {
+    if (args) {
+      if (args.query) {
+        this.queryParams = this.buildSearchParams(args.query);
+      }
+      if (args.form) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(args.form)) {
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
+        }
+        this.rBody = form;
+      }
+      if (args.json) {
+        this.rBody = JSON.stringify(args.json);
+        this.cType = "application/json";
+      }
+      if (args.param) {
+        this.pathParams = args.param;
+      }
+    }
+    let methodUpperCase = this.method.toUpperCase();
+    const headerValues = {
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
+    };
+    if (args?.cookie) {
+      const cookies = [];
+      for (const [key, value] of Object.entries(args.cookie)) {
+        cookies.push((0, import_cookie.serialize)(key, value, { path: "/" }));
+      }
+      headerValues["Cookie"] = cookies.join(",");
+    }
+    if (this.cType) {
+      headerValues["Content-Type"] = this.cType;
+    }
+    const headers = new Headers(headerValues ?? void 0);
+    let url = this.url;
+    url = (0, import_utils.removeIndexString)(url);
+    url = (0, import_utils.replaceUrlParam)(url, this.pathParams);
+    if (this.queryParams) {
+      url = url + "?" + this.queryParams.toString();
+    }
+    methodUpperCase = this.method.toUpperCase();
+    const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    return (opt?.fetch || fetch)(url, {
+      body: setBody ? this.rBody : void 0,
+      method: methodUpperCase,
+      headers,
+      ...opt?.init
+    });
+  };
+}
+const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
+  const buildSearchParamsOption = options?.buildSearchParams ?? import_utils.buildSearchParams;
+  const parts = [...opts.path];
+  const lastParts = parts.slice(-3).reverse();
+  if (lastParts[0] === "toString") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback.toString();
+  }
+  if (lastParts[0] === "valueOf") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback;
+  }
+  let method = "";
+  if (/^\$/.test(lastParts[0])) {
+    const last = parts.pop();
+    if (last) {
+      method = last.replace(/^\$/, "");
+    }
+  }
+  const path = parts.join("/");
+  const url = (0, import_utils.mergePath)(baseUrl, path);
+  if (method === "url") {
+    let result = url;
+    if (opts.args[0]) {
+      if (opts.args[0].param) {
+        result = (0, import_utils.replaceUrlParam)(url, opts.args[0].param);
+      }
+      if (opts.args[0].query) {
+        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+      }
+    }
+    result = (0, import_utils.removeIndexString)(result);
+    return new URL(result);
+  }
+  if (method === "ws") {
+    const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
+      opts.args[0] && opts.args[0].param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
+      "ws"
+    );
+    const targetUrl = new URL(webSocketUrl);
+    const queryParams = opts.args[0]?.query;
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((item) => targetUrl.searchParams.append(key, item));
+        } else {
+          targetUrl.searchParams.set(key, value);
+        }
+      });
+    }
+    const establishWebSocket = (...args) => {
+      if (options?.webSocket !== void 0 && typeof options.webSocket === "function") {
+        return options.webSocket(...args);
+      }
+      return new WebSocket(...args);
+    };
+    return establishWebSocket(targetUrl.toString());
+  }
+  const req = new ClientRequestImpl(url, method, {
+    buildSearchParams: buildSearchParamsOption
+  });
+  if (method) {
+    options ??= {};
+    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] });
+    return req.fetch(opts.args[0], args);
+  }
+  return req;
+}, []);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hc
+});

_node_modules/hono/dist/cjs/client/fetch-result-please.js

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_result_please_exports = {};
+__export(fetch_result_please_exports, {
+  DetailedError: () => DetailedError,
+  fetchRP: () => fetchRP
+});
+module.exports = __toCommonJS(fetch_result_please_exports);
+const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+async function fetchRP(fetchRes) {
+  const _fetchRes = await fetchRes;
+  const hasBody = (_fetchRes.body || _fetchRes._bodyInit) && !nullBodyResponses.has(_fetchRes.status);
+  if (hasBody) {
+    const responseType = detectResponseType(_fetchRes);
+    _fetchRes._data = await _fetchRes[responseType]();
+  }
+  if (!_fetchRes.ok) {
+    throw new DetailedError(`${_fetchRes.status} ${_fetchRes.statusText}`, {
+      statusCode: _fetchRes?.status,
+      detail: {
+        data: _fetchRes?._data,
+        statusText: _fetchRes?.statusText
+      }
+    });
+  }
+  return _fetchRes._data;
+}
+class DetailedError extends Error {
+  /**
+   * Additional `message` that will be logged AND returned to client
+   */
+  detail;
+  /**
+   * Additional `code` that will be logged AND returned to client
+   */
+  code;
+  /**
+   * Additional value that will be logged AND NOT returned to client
+   */
+  log;
+  /**
+   * Optionally set the status code to return, in a web server context
+   */
+  statusCode;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "DetailedError";
+    this.log = options.log;
+    this.detail = options.detail;
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+  }
+}
+const jsonRegex = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
+function detectResponseType(response) {
+  const _contentType = response.headers.get("content-type");
+  if (!_contentType) {
+    return "text";
+  }
+  const contentType = _contentType.split(";").shift();
+  if (jsonRegex.test(contentType)) {
+    return "json";
+  }
+  return "text";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DetailedError,
+  fetchRP
+});

_node_modules/hono/dist/cjs/client/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  DetailedError: () => import_utils.DetailedError,
+  hc: () => import_client.hc,
+  parseResponse: () => import_utils.parseResponse
+});
+module.exports = __toCommonJS(client_exports);
+var import_client = require("./client");
+var import_utils = require("./utils");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DetailedError,
+  hc,
+  parseResponse
+});

_node_modules/hono/dist/cjs/client/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

_node_modules/hono/dist/cjs/client/utils.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  DetailedError: () => import_fetch_result_please.DetailedError,
+  buildSearchParams: () => buildSearchParams,
+  deepMerge: () => deepMerge,
+  mergePath: () => mergePath,
+  parseResponse: () => parseResponse,
+  removeIndexString: () => removeIndexString,
+  replaceUrlParam: () => replaceUrlParam,
+  replaceUrlProtocol: () => replaceUrlProtocol
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fetch_result_please = require("./fetch-result-please");
+const mergePath = (base, path) => {
+  base = base.replace(/\/+$/, "");
+  base = base + "/";
+  path = path.replace(/^\/+/, "");
+  return base + path;
+};
+const replaceUrlParam = (urlString, params) => {
+  for (const [k, v] of Object.entries(params)) {
+    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??");
+    urlString = urlString.replace(reg, v ? `/${v}` : "");
+  }
+  return urlString;
+};
+const buildSearchParams = (query) => {
+  const searchParams = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (const v2 of v) {
+        searchParams.append(k, v2);
+      }
+    } else {
+      searchParams.set(k, v);
+    }
+  }
+  return searchParams;
+};
+const replaceUrlProtocol = (urlString, protocol) => {
+  switch (protocol) {
+    case "ws":
+      return urlString.replace(/^http/, "ws");
+    case "http":
+      return urlString.replace(/^ws/, "http");
+  }
+};
+const removeIndexString = (urlString) => {
+  if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) {
+    return urlString.replace(/\/index(?=\?|$)/, "/");
+  }
+  return urlString.replace(/\/index(?=\?|$)/, "");
+};
+function isObject(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (!isObject(target) && !isObject(source)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    const value = source[key];
+    if (isObject(merged[key]) && isObject(value)) {
+      merged[key] = deepMerge(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+async function parseResponse(fetchRes) {
+  return (0, import_fetch_result_please.fetchRP)(fetchRes);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DetailedError,
+  buildSearchParams,
+  deepMerge,
+  mergePath,
+  parseResponse,
+  removeIndexString,
+  replaceUrlParam,
+  replaceUrlProtocol
+});

_node_modules/hono/dist/cjs/compose.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compose_exports = {};
+__export(compose_exports, {
+  compose: () => compose
+});
+module.exports = __toCommonJS(compose_exports);
+const 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];
+        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 && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compose
+});

_node_modules/hono/dist/cjs/context.js

@@ -0,0 +1,435 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  Context: () => Context,
+  TEXT_PLAIN: () => TEXT_PLAIN
+});
+module.exports = __toCommonJS(context_exports);
+var import_request = require("./request");
+var import_html = require("./utils/html");
+const TEXT_PLAIN = "text/plain; charset=UTF-8";
+const setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+class Context {
+  #rawRequest;
+  #req;
+  /**
+   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#env}
+   *
+   * @example
+   * ```ts
+   * // Environment object for Cloudflare Workers
+   * app.get('*', async c => {
+   *   const counter = c.env.COUNTER
+   * })
+   * ```
+   */
+  env = {};
+  #var;
+  finalized = false;
+  /**
+   * `.error` can get the error object from the middleware if the Handler throws an error.
+   *
+   * @see {@link https://hono.dev/docs/api/context#error}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   await next()
+   *   if (c.error) {
+   *     // do something...
+   *   }
+   * })
+   * ```
+   */
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  /**
+   * Creates an instance of the Context class.
+   *
+   * @param req - The Request object.
+   * @param options - Optional configuration options for the context.
+   */
+  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;
+    }
+  }
+  /**
+   * `.req` is the instance of {@link HonoRequest}.
+   */
+  get req() {
+    this.#req ??= new import_request.HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#event}
+   * The FetchEvent associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have a FetchEvent.
+   */
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#executionctx}
+   * The ExecutionContext associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have an ExecutionContext.
+   */
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#res}
+   * The Response object for the current request.
+   */
+  get res() {
+    return this.#res ||= new Response(null, {
+      headers: this.#preparedHeaders ??= new Headers()
+    });
+  }
+  /**
+   * Sets the Response object for the current request.
+   *
+   * @param _res - The Response object to set.
+   */
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = new Response(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type") {
+          continue;
+        }
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies) {
+            _res.headers.append("set-cookie", cookie);
+          }
+        } else {
+          _res.headers.set(k, v);
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  /**
+   * `.render()` can create a response within a layout.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   return c.render('Hello!')
+   * })
+   * ```
+   */
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  /**
+   * Sets the layout for the response.
+   *
+   * @param layout - The layout to set.
+   * @returns The layout function.
+   */
+  setLayout = (layout) => this.#layout = layout;
+  /**
+   * Gets the current layout for the response.
+   *
+   * @returns The current layout function.
+   */
+  getLayout = () => this.#layout;
+  /**
+   * `.setRenderer()` can set the layout in the custom middleware.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```tsx
+   * app.use('*', async (c, next) => {
+   *   c.setRenderer((content) => {
+   *     return c.html(
+   *       <html>
+   *         <body>
+   *           <p>{content}</p>
+   *         </body>
+   *       </html>
+   *     )
+   *   })
+   *   await next()
+   * })
+   * ```
+   */
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  /**
+   * `.header()` can set headers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#header}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  header = (name, value, options) => {
+    if (this.finalized) {
+      this.#res = new Response(this.#res.body, this.#res);
+    }
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+    if (value === void 0) {
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  /**
+   * `.set()` can set the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   c.set('message', 'Hono is hot!!')
+   *   await next()
+   * })
+   * ```
+   */
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map();
+    this.#var.set(key, value);
+  };
+  /**
+   * `.get()` can use the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   const message = c.get('message')
+   *   return c.text(`The message is "${message}"`)
+   * })
+   * ```
+   */
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : void 0;
+  };
+  /**
+   * `.var` can access the value of a variable.
+   *
+   * @see {@link https://hono.dev/docs/api/context#var}
+   *
+   * @example
+   * ```ts
+   * const result = c.var.client.oneMethod()
+   * ```
+   */
+  // c.var.propName is a read-only
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
+    if (typeof arg === "object" && "headers" in arg) {
+      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
+      for (const [key, value] of argHeaders) {
+        if (key.toLowerCase() === "set-cookie") {
+          responseHeaders.append(key, value);
+        } else {
+          responseHeaders.set(key, value);
+        }
+      }
+    }
+    if (headers) {
+      for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === "string") {
+          responseHeaders.set(k, v);
+        } else {
+          responseHeaders.delete(k);
+          for (const v2 of v) {
+            responseHeaders.append(k, v2);
+          }
+        }
+      }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return new Response(data, { status, headers: responseHeaders });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  /**
+   * `.body()` can return the HTTP response.
+   * You can set headers with `.header()` and set HTTP status code with `.status`.
+   * This can also be set in `.text()`, `.json()` and so on.
+   *
+   * @see {@link https://hono.dev/docs/api/context#body}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *   // Set HTTP status code
+   *   c.status(201)
+   *
+   *   // Return the response body
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  /**
+   * `.text()` can render text as `Content-Type:text/plain`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#text}
+   *
+   * @example
+   * ```ts
+   * app.get('/say', (c) => {
+   *   return c.text('Hello!')
+   * })
+   * ```
+   */
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
+      text,
+      arg,
+      setDefaultContentType(TEXT_PLAIN, headers)
+    );
+  };
+  /**
+   * `.json()` can render JSON as `Content-Type:application/json`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#json}
+   *
+   * @example
+   * ```ts
+   * app.get('/api', (c) => {
+   *   return c.json({ message: 'Hello!' })
+   * })
+   * ```
+   */
+  json = (object, arg, headers) => {
+    return this.#newResponse(
+      JSON.stringify(object),
+      arg,
+      setDefaultContentType("application/json", headers)
+    );
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? (0, import_html.resolveCallback)(html, import_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  /**
+   * `.redirect()` can Redirect, default status code is 302.
+   *
+   * @see {@link https://hono.dev/docs/api/context#redirect}
+   *
+   * @example
+   * ```ts
+   * app.get('/redirect', (c) => {
+   *   return c.redirect('/')
+   * })
+   * app.get('/redirect-permanently', (c) => {
+   *   return c.redirect('/', 301)
+   * })
+   * ```
+   */
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header(
+      "Location",
+      // Multibyes should be encoded
+      // eslint-disable-next-line no-control-regex
+      !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
+    );
+    return this.newResponse(null, status ?? 302);
+  };
+  /**
+   * `.notFound()` can return the Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/context#notfound}
+   *
+   * @example
+   * ```ts
+   * app.get('/notfound', (c) => {
+   *   return c.notFound()
+   * })
+   * ```
+   */
+  notFound = () => {
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context,
+  TEXT_PLAIN
+});

_node_modules/hono/dist/cjs/helper/accepts/accepts.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accepts_exports = {};
+__export(accepts_exports, {
+  accepts: () => accepts,
+  defaultMatch: () => defaultMatch
+});
+module.exports = __toCommonJS(accepts_exports);
+var import_accept = require("../../utils/accept");
+const defaultMatch = (accepts2, config) => {
+  const { supports, default: defaultSupport } = config;
+  const accept = accepts2.sort((a, b) => b.q - a.q).find((accept2) => supports.includes(accept2.type));
+  return accept ? accept.type : defaultSupport;
+};
+const accepts = (c, options) => {
+  const acceptHeader = c.req.header(options.header);
+  if (!acceptHeader) {
+    return options.default;
+  }
+  const accepts2 = (0, import_accept.parseAccept)(acceptHeader);
+  const match = options.match || defaultMatch;
+  return match(accepts2, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  accepts,
+  defaultMatch
+});

_node_modules/hono/dist/cjs/helper/accepts/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accepts_exports = {};
+__export(accepts_exports, {
+  accepts: () => import_accepts.accepts
+});
+module.exports = __toCommonJS(accepts_exports);
+var import_accepts = require("./accepts");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  accepts
+});

_node_modules/hono/dist/cjs/helper/adapter/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var adapter_exports = {};
+__export(adapter_exports, {
+  checkUserAgentEquals: () => checkUserAgentEquals,
+  env: () => env,
+  getRuntimeKey: () => getRuntimeKey,
+  knownUserAgents: () => knownUserAgents
+});
+module.exports = __toCommonJS(adapter_exports);
+const env = (c, runtime) => {
+  const global = globalThis;
+  const globalEnv = global?.process?.env;
+  runtime ??= getRuntimeKey();
+  const runtimeEnvHandlers = {
+    bun: () => globalEnv,
+    node: () => globalEnv,
+    "edge-light": () => globalEnv,
+    deno: () => {
+      return Deno.env.toObject();
+    },
+    workerd: () => c.env,
+    // On Fastly Compute, you can use the ConfigStore to manage user-defined data.
+    fastly: () => ({}),
+    other: () => ({})
+  };
+  return runtimeEnvHandlers[runtime]();
+};
+const knownUserAgents = {
+  deno: "Deno",
+  bun: "Bun",
+  workerd: "Cloudflare-Workers",
+  node: "Node.js"
+};
+const getRuntimeKey = () => {
+  const global = globalThis;
+  const userAgentSupported = typeof navigator !== "undefined" && typeof navigator.userAgent === "string";
+  if (userAgentSupported) {
+    for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) {
+      if (checkUserAgentEquals(userAgent)) {
+        return runtimeKey;
+      }
+    }
+  }
+  if (typeof global?.EdgeRuntime === "string") {
+    return "edge-light";
+  }
+  if (global?.fastly !== void 0) {
+    return "fastly";
+  }
+  if (global?.process?.release?.name === "node") {
+    return "node";
+  }
+  return "other";
+};
+const checkUserAgentEquals = (platform) => {
+  const userAgent = navigator.userAgent;
+  return userAgent.startsWith(platform);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkUserAgentEquals,
+  env,
+  getRuntimeKey,
+  knownUserAgents
+});

_node_modules/hono/dist/cjs/helper/conninfo/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+module.exports = __toCommonJS(conninfo_exports);

_node_modules/hono/dist/cjs/helper/conninfo/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

_node_modules/hono/dist/cjs/helper/cookie/index.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cookie_exports = {};
+__export(cookie_exports, {
+  deleteCookie: () => deleteCookie,
+  generateCookie: () => generateCookie,
+  generateSignedCookie: () => generateSignedCookie,
+  getCookie: () => getCookie,
+  getSignedCookie: () => getSignedCookie,
+  setCookie: () => setCookie,
+  setSignedCookie: () => setSignedCookie
+});
+module.exports = __toCommonJS(cookie_exports);
+var import_cookie = require("../../utils/cookie");
+const 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 = (0, import_cookie.parse)(cookie, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = (0, import_cookie.parse)(cookie);
+  return obj;
+};
+const getSignedCookie = async (c, secret, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (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 = await (0, import_cookie.parseSigned)(cookie, secret, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = await (0, import_cookie.parseSigned)(cookie, secret);
+  return obj;
+};
+const generateCookie = (name, value, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = (0, import_cookie.serialize)("__Secure-" + name, value, { path: "/", ...opt, secure: true });
+  } else if (opt?.prefix === "host") {
+    cookie = (0, import_cookie.serialize)("__Host-" + name, value, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = (0, import_cookie.serialize)(name, value, { path: "/", ...opt });
+  }
+  return cookie;
+};
+const setCookie = (c, name, value, opt) => {
+  const cookie = generateCookie(name, value, opt);
+  c.header("Set-Cookie", cookie, { append: true });
+};
+const generateSignedCookie = async (name, value, secret, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = await (0, import_cookie.serializeSigned)("__Secure-" + name, value, secret, {
+      path: "/",
+      ...opt,
+      secure: true
+    });
+  } else if (opt?.prefix === "host") {
+    cookie = await (0, import_cookie.serializeSigned)("__Host-" + name, value, secret, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = await (0, import_cookie.serializeSigned)(name, value, secret, { path: "/", ...opt });
+  }
+  return cookie;
+};
+const setSignedCookie = async (c, name, value, secret, opt) => {
+  const cookie = await generateSignedCookie(name, value, secret, opt);
+  c.header("set-cookie", cookie, { append: true });
+};
+const deleteCookie = (c, name, opt) => {
+  const deletedCookie = getCookie(c, name, opt?.prefix);
+  setCookie(c, name, "", { ...opt, maxAge: 0 });
+  return deletedCookie;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCookie,
+  generateCookie,
+  generateSignedCookie,
+  getCookie,
+  getSignedCookie,
+  setCookie,
+  setSignedCookie
+});

_node_modules/hono/dist/cjs/helper/css/common.js

@@ -0,0 +1,223 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+__export(common_exports, {
+  CLASS_NAME: () => CLASS_NAME,
+  DEFAULT_STYLE_ID: () => DEFAULT_STYLE_ID,
+  EXTERNAL_CLASS_NAMES: () => EXTERNAL_CLASS_NAMES,
+  IS_CSS_ESCAPED: () => IS_CSS_ESCAPED,
+  PSEUDO_GLOBAL_SELECTOR: () => PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR: () => SELECTOR,
+  SELECTORS: () => SELECTORS,
+  STYLE_STRING: () => STYLE_STRING,
+  buildStyleString: () => buildStyleString,
+  cssCommon: () => cssCommon,
+  cxCommon: () => cxCommon,
+  isPseudoGlobalSelectorRe: () => isPseudoGlobalSelectorRe,
+  keyframesCommon: () => keyframesCommon,
+  minify: () => minify,
+  rawCssString: () => rawCssString,
+  viewTransitionCommon: () => viewTransitionCommon
+});
+module.exports = __toCommonJS(common_exports);
+const PSEUDO_GLOBAL_SELECTOR = ":-hono-global";
+const isPseudoGlobalSelectorRe = new RegExp(`^${PSEUDO_GLOBAL_SELECTOR}{(.*)}$`);
+const DEFAULT_STYLE_ID = "hono-css";
+const SELECTOR = /* @__PURE__ */ Symbol();
+const CLASS_NAME = /* @__PURE__ */ Symbol();
+const STYLE_STRING = /* @__PURE__ */ Symbol();
+const SELECTORS = /* @__PURE__ */ Symbol();
+const EXTERNAL_CLASS_NAMES = /* @__PURE__ */ Symbol();
+const CSS_ESCAPED = /* @__PURE__ */ Symbol();
+const IS_CSS_ESCAPED = /* @__PURE__ */ Symbol();
+const rawCssString = (value) => {
+  return {
+    [CSS_ESCAPED]: value
+  };
+};
+const toHash = (str) => {
+  let i = 0, out = 11;
+  while (i < str.length) {
+    out = 101 * out + str.charCodeAt(i++) >>> 0;
+  }
+  return "css-" + out;
+};
+const cssStringReStr = [
+  '"(?:(?:\\\\[\\s\\S]|[^"\\\\])*)"',
+  // double quoted string
+  "'(?:(?:\\\\[\\s\\S]|[^'\\\\])*)'"
+  // single quoted string
+].join("|");
+const minifyCssRe = new RegExp(
+  [
+    "(" + cssStringReStr + ")",
+    // $1: quoted string
+    "(?:" + [
+      "^\\s+",
+      // head whitespace
+      "\\/\\*.*?\\*\\/\\s*",
+      // multi-line comment
+      "\\/\\/.*\\n\\s*",
+      // single-line comment
+      "\\s+$"
+      // tail whitespace
+    ].join("|") + ")",
+    "\\s*;\\s*(}|$)\\s*",
+    // $2: trailing semicolon
+    "\\s*([{};:,])\\s*",
+    // $3: whitespace around { } : , ;
+    "(\\s)\\s+"
+    // $4: 2+ spaces
+  ].join("|"),
+  "g"
+);
+const minify = (css) => {
+  return css.replace(minifyCssRe, (_, $1, $2, $3, $4) => $1 || $2 || $3 || $4 || "");
+};
+const buildStyleString = (strings, values) => {
+  const selectors = [];
+  const externalClassNames = [];
+  const label = strings[0].match(/^\s*\/\*(.*?)\*\//)?.[1] || "";
+  let styleString = "";
+  for (let i = 0, len = strings.length; i < len; i++) {
+    styleString += strings[i];
+    let vArray = values[i];
+    if (typeof vArray === "boolean" || vArray === null || vArray === void 0) {
+      continue;
+    }
+    if (!Array.isArray(vArray)) {
+      vArray = [vArray];
+    }
+    for (let j = 0, len2 = vArray.length; j < len2; j++) {
+      let value = vArray[j];
+      if (typeof value === "boolean" || value === null || value === void 0) {
+        continue;
+      }
+      if (typeof value === "string") {
+        if (/([\\"'\/])/.test(value)) {
+          styleString += value.replace(/([\\"']|(?<=<)\/)/g, "\\$1");
+        } else {
+          styleString += value;
+        }
+      } else if (typeof value === "number") {
+        styleString += value;
+      } else if (value[CSS_ESCAPED]) {
+        styleString += value[CSS_ESCAPED];
+      } else if (value[CLASS_NAME].startsWith("@keyframes ")) {
+        selectors.push(value);
+        styleString += ` ${value[CLASS_NAME].substring(11)} `;
+      } else {
+        if (strings[i + 1]?.match(/^\s*{/)) {
+          selectors.push(value);
+          value = `.${value[CLASS_NAME]}`;
+        } else {
+          selectors.push(...value[SELECTORS]);
+          externalClassNames.push(...value[EXTERNAL_CLASS_NAMES]);
+          value = value[STYLE_STRING];
+          const valueLen = value.length;
+          if (valueLen > 0) {
+            const lastChar = value[valueLen - 1];
+            if (lastChar !== ";" && lastChar !== "}") {
+              value += ";";
+            }
+          }
+        }
+        styleString += `${value || ""}`;
+      }
+    }
+  }
+  return [label, minify(styleString), selectors, externalClassNames];
+};
+const cssCommon = (strings, values) => {
+  let [label, thisStyleString, selectors, externalClassNames] = buildStyleString(strings, values);
+  const isPseudoGlobal = isPseudoGlobalSelectorRe.exec(thisStyleString);
+  if (isPseudoGlobal) {
+    thisStyleString = isPseudoGlobal[1];
+  }
+  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : "") + toHash(label + thisStyleString);
+  const className = (isPseudoGlobal ? selectors.map((s) => s[CLASS_NAME]) : [selector, ...externalClassNames]).join(" ");
+  return {
+    [SELECTOR]: selector,
+    [CLASS_NAME]: className,
+    [STYLE_STRING]: thisStyleString,
+    [SELECTORS]: selectors,
+    [EXTERNAL_CLASS_NAMES]: externalClassNames
+  };
+};
+const cxCommon = (args) => {
+  for (let i = 0, len = args.length; i < len; i++) {
+    const arg = args[i];
+    if (typeof arg === "string") {
+      args[i] = {
+        [SELECTOR]: "",
+        [CLASS_NAME]: "",
+        [STYLE_STRING]: "",
+        [SELECTORS]: [],
+        [EXTERNAL_CLASS_NAMES]: [arg]
+      };
+    }
+  }
+  return args;
+};
+const keyframesCommon = (strings, ...values) => {
+  const [label, styleString] = buildStyleString(strings, values);
+  return {
+    [SELECTOR]: "",
+    [CLASS_NAME]: `@keyframes ${toHash(label + styleString)}`,
+    [STYLE_STRING]: styleString,
+    [SELECTORS]: [],
+    [EXTERNAL_CLASS_NAMES]: []
+  };
+};
+let viewTransitionNameIndex = 0;
+const viewTransitionCommon = ((strings, values) => {
+  if (!strings) {
+    strings = [`/* h-v-t ${viewTransitionNameIndex++} */`];
+  }
+  const content = Array.isArray(strings) ? cssCommon(strings, values) : strings;
+  const transitionName = content[CLASS_NAME];
+  const res = cssCommon(["view-transition-name:", ""], [transitionName]);
+  content[CLASS_NAME] = PSEUDO_GLOBAL_SELECTOR + content[CLASS_NAME];
+  content[STYLE_STRING] = content[STYLE_STRING].replace(
+    /(?<=::view-transition(?:[a-z-]*)\()(?=\))/g,
+    transitionName
+  );
+  res[CLASS_NAME] = res[SELECTOR] = transitionName;
+  res[SELECTORS] = [...content[SELECTORS], content];
+  return res;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  EXTERNAL_CLASS_NAMES,
+  IS_CSS_ESCAPED,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  buildStyleString,
+  cssCommon,
+  cxCommon,
+  isPseudoGlobalSelectorRe,
+  keyframesCommon,
+  minify,
+  rawCssString,
+  viewTransitionCommon
+});

_node_modules/hono/dist/cjs/helper/css/index.js

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_exports = {};
+__export(css_exports, {
+  Style: () => Style,
+  createCssContext: () => createCssContext,
+  css: () => css,
+  cx: () => cx,
+  keyframes: () => keyframes,
+  rawCssString: () => import_common2.rawCssString,
+  viewTransition: () => viewTransition
+});
+module.exports = __toCommonJS(css_exports);
+var import_html = require("../../helper/html");
+var import_constants = require("../../jsx/constants");
+var import_css = require("../../jsx/dom/css");
+var import_common = require("./common");
+var import_common2 = require("./common");
+const createCssContext = ({ id }) => {
+  const [cssJsxDomObject, StyleRenderToDom] = (0, import_css.createCssJsxDomObjects)({ id });
+  const contextMap = /* @__PURE__ */ new WeakMap();
+  const nonceMap = /* @__PURE__ */ new WeakMap();
+  const replaceStyleRe = new RegExp(`(<style id="${id}"(?: nonce="[^"]*")?>.*?)(</style>)`);
+  const newCssClassNameObject = (cssClassName) => {
+    const appendStyle = ({ buffer, context }) => {
+      const [toAdd, added] = contextMap.get(context);
+      const names = Object.keys(toAdd);
+      if (!names.length) {
+        return;
+      }
+      let stylesStr = "";
+      names.forEach((className2) => {
+        added[className2] = true;
+        stylesStr += className2.startsWith(import_common.PSEUDO_GLOBAL_SELECTOR) ? toAdd[className2] : `${className2[0] === "@" ? "" : "."}${className2}{${toAdd[className2]}}`;
+      });
+      contextMap.set(context, [{}, added]);
+      if (buffer && replaceStyleRe.test(buffer[0])) {
+        buffer[0] = buffer[0].replace(replaceStyleRe, (_, pre, post) => `${pre}${stylesStr}${post}`);
+        return;
+      }
+      const nonce = nonceMap.get(context);
+      const appendStyleScript = `<script${nonce ? ` nonce="${nonce}"` : ""}>document.querySelector('#${id}').textContent+=${JSON.stringify(stylesStr)}</script>`;
+      if (buffer) {
+        buffer[0] = `${appendStyleScript}${buffer[0]}`;
+        return;
+      }
+      return Promise.resolve(appendStyleScript);
+    };
+    const addClassNameToContext = ({ context }) => {
+      if (!contextMap.has(context)) {
+        contextMap.set(context, [{}, {}]);
+      }
+      const [toAdd, added] = contextMap.get(context);
+      let allAdded = true;
+      if (!added[cssClassName[import_common.SELECTOR]]) {
+        allAdded = false;
+        toAdd[cssClassName[import_common.SELECTOR]] = cssClassName[import_common.STYLE_STRING];
+      }
+      cssClassName[import_common.SELECTORS].forEach(
+        ({ [import_common.CLASS_NAME]: className2, [import_common.STYLE_STRING]: styleString }) => {
+          if (!added[className2]) {
+            allAdded = false;
+            toAdd[className2] = styleString;
+          }
+        }
+      );
+      if (allAdded) {
+        return;
+      }
+      return Promise.resolve((0, import_html.raw)("", [appendStyle]));
+    };
+    const className = new String(cssClassName[import_common.CLASS_NAME]);
+    Object.assign(className, cssClassName);
+    className.isEscaped = true;
+    className.callbacks = [addClassNameToContext];
+    const promise = Promise.resolve(className);
+    Object.assign(promise, cssClassName);
+    promise.toString = cssJsxDomObject.toString;
+    return promise;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+  };
+  const cx2 = (...args) => {
+    args = (0, import_common.cxCommon)(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = import_common.keyframesCommon;
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+  });
+  const Style2 = ({ children, nonce } = {}) => (0, import_html.raw)(
+    `<style id="${id}"${nonce ? ` nonce="${nonce}"` : ""}>${children ? children[import_common.STYLE_STRING] : ""}</style>`,
+    [
+      ({ context }) => {
+        nonceMap.set(context, nonce);
+        return void 0;
+      }
+    ]
+  );
+  Style2[import_constants.DOM_RENDERER] = StyleRenderToDom;
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+const defaultContext = createCssContext({
+  id: import_common.DEFAULT_STYLE_ID
+});
+const css = defaultContext.css;
+const cx = defaultContext.cx;
+const keyframes = defaultContext.keyframes;
+const viewTransition = defaultContext.viewTransition;
+const Style = defaultContext.Style;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Style,
+  createCssContext,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+});

_node_modules/hono/dist/cjs/helper/dev/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_exports = {};
+__export(dev_exports, {
+  getRouterName: () => getRouterName,
+  inspectRoutes: () => inspectRoutes,
+  showRoutes: () => showRoutes
+});
+module.exports = __toCommonJS(dev_exports);
+var import_color = require("../../utils/color");
+var import_handler = require("../../utils/handler");
+const handlerName = (handler) => {
+  return handler.name || ((0, import_handler.isMiddleware)(handler) ? "[middleware]" : "[handler]");
+};
+const inspectRoutes = (hono) => {
+  return hono.routes.map(({ path, method, handler }) => {
+    const targetHandler = (0, import_handler.findTargetHandler)(handler);
+    return {
+      path,
+      method,
+      name: handlerName(targetHandler),
+      isMiddleware: (0, import_handler.isMiddleware)(targetHandler)
+    };
+  });
+};
+const showRoutes = (hono, opts) => {
+  const colorEnabled = opts?.colorize ?? (0, import_color.getColorEnabled)();
+  const routeData = {};
+  let maxMethodLength = 0;
+  let maxPathLength = 0;
+  inspectRoutes(hono).filter(({ isMiddleware: isMiddleware2 }) => opts?.verbose || !isMiddleware2).map((route) => {
+    const key = `${route.method}-${route.path}`;
+    (routeData[key] ||= []).push(route);
+    if (routeData[key].length > 1) {
+      return;
+    }
+    maxMethodLength = Math.max(maxMethodLength, route.method.length);
+    maxPathLength = Math.max(maxPathLength, route.path.length);
+    return { method: route.method, path: route.path, routes: routeData[key] };
+  }).forEach((data) => {
+    if (!data) {
+      return;
+    }
+    const { method, path, routes } = data;
+    const methodStr = colorEnabled ? `\x1B[32m${method}\x1B[0m` : method;
+    console.log(`${methodStr} ${" ".repeat(maxMethodLength - method.length)} ${path}`);
+    if (!opts?.verbose) {
+      return;
+    }
+    routes.forEach(({ name }) => {
+      console.log(`${" ".repeat(maxMethodLength + 3)} ${name}`);
+    });
+  });
+};
+const getRouterName = (app) => {
+  app.router.match("GET", "/");
+  return app.router.name;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRouterName,
+  inspectRoutes,
+  showRoutes
+});

_node_modules/hono/dist/cjs/helper/factory/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  Factory: () => Factory,
+  createFactory: () => createFactory,
+  createMiddleware: () => createMiddleware
+});
+module.exports = __toCommonJS(factory_exports);
+var import_hono = require("../../hono");
+class Factory {
+  initApp;
+  #defaultAppOptions;
+  constructor(init) {
+    this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
+  }
+  createApp = (options) => {
+    const app = new import_hono.Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
+    if (this.initApp) {
+      this.initApp(app);
+    }
+    return app;
+  };
+  createMiddleware = (middleware) => middleware;
+  createHandlers = (...handlers) => {
+    return handlers.filter((handler) => handler !== void 0);
+  };
+}
+const createFactory = (init) => new Factory(init);
+const createMiddleware = (middleware) => middleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Factory,
+  createFactory,
+  createMiddleware
+});

_node_modules/hono/dist/cjs/helper/html/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_exports = {};
+__export(html_exports, {
+  html: () => html,
+  raw: () => import_html.raw
+});
+module.exports = __toCommonJS(html_exports);
+var import_html = require("../../utils/html");
+const html = (strings, ...values) => {
+  const buffer = [""];
+  for (let i = 0, len = strings.length - 1; i < len; i++) {
+    buffer[0] += strings[i];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
+    for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
+      const child = children[i2];
+      if (typeof child === "string") {
+        (0, import_html.escapeToBuffer)(child, buffer);
+      } else if (typeof child === "number") {
+        ;
+        buffer[0] += child;
+      } else if (typeof child === "boolean" || child === null || child === void 0) {
+        continue;
+      } else if (typeof child === "object" && child.isEscaped) {
+        if (child.callbacks) {
+          buffer.unshift("", child);
+        } else {
+          const tmp = child.toString();
+          if (tmp instanceof Promise) {
+            buffer.unshift("", tmp);
+          } else {
+            buffer[0] += tmp;
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
+      } else {
+        (0, import_html.escapeToBuffer)(child.toString(), buffer);
+      }
+    }
+  }
+  buffer[0] += strings.at(-1);
+  return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html.raw)((0, import_html.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks))) : (0, import_html.raw)(buffer[0]) : (0, import_html.stringBufferToString)(buffer, buffer.callbacks);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  html,
+  raw
+});

_node_modules/hono/dist/cjs/helper/proxy/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  proxy: () => proxy
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_http_exception = require("../../http-exception");
+const hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  if (strictConnectionProcessing) {
+    const connectionValue = headers.get("connection");
+    if (connectionValue) {
+      const headerNames = connectionValue.split(",").map((h) => h.trim());
+      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+      if (invalidHeaders.length > 0) {
+        throw new import_http_exception.HTTPException(400, {
+          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
+        });
+      }
+      headerNames.forEach((headerName) => {
+        headers.delete(headerName);
+      });
+    }
+  }
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers,
+    signal: request.signal
+  };
+};
+const preprocessRequestInit = (requestInit) => {
+  if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) {
+    return requestInit;
+  }
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(requestInit.headers)) {
+    if (value == null) {
+      headers.delete(key);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  requestInit.headers = headers;
+  return requestInit;
+};
+const proxy = async (input, proxyInit) => {
+  const {
+    raw,
+    customFetch,
+    strictConnectionProcessing = false,
+    ...requestInit
+  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+  const req = new Request(input, {
+    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+    ...preprocessRequestInit(requestInit)
+  });
+  req.headers.delete("accept-encoding");
+  const res = await (customFetch || fetch)(req);
+  const resHeaders = new Headers(res.headers);
+  hopByHopHeaders.forEach((header) => {
+    resHeaders.delete(header);
+  });
+  if (resHeaders.has("content-encoding")) {
+    resHeaders.delete("content-encoding");
+    resHeaders.delete("content-length");
+  }
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: resHeaders
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxy
+});

_node_modules/hono/dist/cjs/helper/route/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var route_exports = {};
+__export(route_exports, {
+  basePath: () => basePath,
+  baseRoutePath: () => baseRoutePath,
+  matchedRoutes: () => matchedRoutes,
+  routePath: () => routePath
+});
+module.exports = __toCommonJS(route_exports);
+var import_constants = require("../../request/constants");
+var import_url = require("../../utils/url");
+const matchedRoutes = (c) => (
+  // @ts-expect-error c.req[GET_MATCH_RESULT] is not typed
+  c.req[import_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route)
+);
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c, index) => {
+  index ??= c.req.routeIndex;
+  const cache = basePathCacheMap.get(c) || [];
+  if (typeof cache[index] === "string") {
+    return cache[index];
+  }
+  let result;
+  const rp = baseRoutePath(c, index);
+  if (!/[:*]/.test(rp)) {
+    result = rp;
+  } else {
+    const paths = (0, import_url.splitRoutingPath)(rp);
+    const reqPath = c.req.path;
+    let basePathLength = 0;
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const pattern = (0, import_url.getPattern)(paths[i], paths[i + 1]);
+      if (pattern) {
+        const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+        basePathLength += reqPath.substring(basePathLength + 1).match(re)?.[0].length || 0;
+      } else {
+        basePathLength += paths[i].length;
+      }
+      basePathLength += 1;
+    }
+    result = reqPath.substring(0, basePathLength);
+  }
+  cache[index] = result;
+  basePathCacheMap.set(c, cache);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basePath,
+  baseRoutePath,
+  matchedRoutes,
+  routePath
+});

_node_modules/hono/dist/cjs/helper/ssg/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  X_HONO_DISABLE_SSG_HEADER_KEY: () => import_middleware.X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG: () => import_middleware.disableSSG,
+  isSSGContext: () => import_middleware.isSSGContext,
+  onlySSG: () => import_middleware.onlySSG,
+  ssgParams: () => import_middleware.ssgParams
+});
+module.exports = __toCommonJS(ssg_exports);
+__reExport(ssg_exports, require("./ssg"), module.exports);
+var import_middleware = require("./middleware");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  ssgParams,
+  ...require("./ssg")
+});

_node_modules/hono/dist/cjs/helper/ssg/middleware.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  SSG_CONTEXT: () => SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE: () => SSG_DISABLED_RESPONSE,
+  X_HONO_DISABLE_SSG_HEADER_KEY: () => X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG: () => disableSSG,
+  isSSGContext: () => isSSGContext,
+  onlySSG: () => onlySSG,
+  ssgParams: () => ssgParams
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_utils = require("./utils");
+const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+const SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
+  }
+})();
+const ssgParams = (params) => async (c, next) => {
+  if ((0, import_utils.isDynamicRoute)(c.req.path)) {
+    ;
+    c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+    return c.notFound();
+  }
+  await next();
+};
+const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+const disableSSG = () => async function disableSSG2(c, next) {
+  if (isSSGContext(c)) {
+    c.header(X_HONO_DISABLE_SSG_HEADER_KEY, "true");
+    return c.notFound();
+  }
+  await next();
+};
+const onlySSG = () => async function onlySSG2(c, next) {
+  if (!isSSGContext(c)) {
+    return c.notFound();
+  }
+  await next();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE,
+  X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  ssgParams
+});

_node_modules/hono/dist/cjs/helper/ssg/ssg.js

@@ -0,0 +1,326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  DEFAULT_OUTPUT_DIR: () => DEFAULT_OUTPUT_DIR,
+  combineAfterGenerateHooks: () => combineAfterGenerateHooks,
+  combineAfterResponseHooks: () => combineAfterResponseHooks,
+  combineBeforeRequestHooks: () => combineBeforeRequestHooks,
+  defaultExtensionMap: () => defaultExtensionMap,
+  defaultPlugin: () => defaultPlugin,
+  fetchRoutesContent: () => fetchRoutesContent,
+  saveContentToFile: () => saveContentToFile,
+  toSSG: () => toSSG
+});
+module.exports = __toCommonJS(ssg_exports);
+var import_utils = require("../../client/utils");
+var import_concurrent = require("../../utils/concurrent");
+var import_mime = require("../../utils/mime");
+var import_middleware = require("./middleware");
+var import_utils2 = require("./utils");
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_CONTENT_TYPE = "text/plain";
+const DEFAULT_OUTPUT_DIR = "./static";
+const generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
+  const extension = determineExtension(mimeType, extensionMap);
+  if (routePath.endsWith(`.${extension}`)) {
+    return (0, import_utils2.joinPaths)(outDir, routePath);
+  }
+  if (routePath === "/") {
+    return (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
+  }
+  if (routePath.endsWith("/")) {
+    return (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
+  }
+  return (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
+};
+const parseResponseContent = async (response) => {
+  const contentType = response.headers.get("Content-Type");
+  try {
+    if (contentType?.includes("text") || contentType?.includes("json")) {
+      return await response.text();
+    } else {
+      return await response.arrayBuffer();
+    }
+  } catch (error) {
+    throw new Error(
+      `Error processing response: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+const defaultExtensionMap = {
+  "text/html": "html",
+  "text/xml": "xml",
+  "application/xml": "xml",
+  "application/yaml": "yaml"
+};
+const determineExtension = (mimeType, userExtensionMap) => {
+  const extensionMap = userExtensionMap || defaultExtensionMap;
+  if (mimeType in extensionMap) {
+    return extensionMap[mimeType];
+  }
+  return (0, import_mime.getExtension)(mimeType) || "html";
+};
+const combineBeforeRequestHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (req) => {
+    let currentReq = req;
+    for (const hook of hooks) {
+      const result = await hook(currentReq);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Request) {
+        currentReq = result;
+      }
+    }
+    return currentReq;
+  };
+};
+const combineAfterResponseHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (res) => {
+    let currentRes = res;
+    for (const hook of hooks) {
+      const result = await hook(currentRes);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Response) {
+        currentRes = result;
+      }
+    }
+    return currentRes;
+  };
+};
+const combineAfterGenerateHooks = (hooks, fsModule, options) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (result) => {
+    for (const hook of hooks) {
+      await hook(result, fsModule, options);
+    }
+  };
+};
+const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
+  const baseURL = "http://localhost";
+  const pool = (0, import_concurrent.createPool)({ concurrency });
+  for (const route of (0, import_utils2.filterStaticGenerateRoutes)(app)) {
+    const thisRouteBaseURL = new URL(route.path, baseURL).toString();
+    let forGetInfoURLRequest = new Request(thisRouteBaseURL);
+    yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+      try {
+        if (beforeRequestHook) {
+          const maybeRequest = await beforeRequestHook(forGetInfoURLRequest);
+          if (!maybeRequest) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest = maybeRequest;
+        }
+        await pool.run(() => app.fetch(forGetInfoURLRequest));
+        if (!forGetInfoURLRequest.ssgParams) {
+          if ((0, import_utils2.isDynamicRoute)(route.path)) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest.ssgParams = [{}];
+        }
+        const requestInit = {
+          method: forGetInfoURLRequest.method,
+          headers: forGetInfoURLRequest.headers
+        };
+        resolveGetInfo(
+          (function* () {
+            for (const param of forGetInfoURLRequest.ssgParams) {
+              yield new Promise(async (resolveReq, rejectReq) => {
+                try {
+                  const replacedUrlParam = (0, import_utils.replaceUrlParam)(route.path, param);
+                  let response = await pool.run(
+                    () => app.request(replacedUrlParam, requestInit, {
+                      [import_middleware.SSG_CONTEXT]: true
+                    })
+                  );
+                  if (response.headers.get(import_middleware.X_HONO_DISABLE_SSG_HEADER_KEY)) {
+                    resolveReq(void 0);
+                    return;
+                  }
+                  if (afterResponseHook) {
+                    const maybeResponse = await afterResponseHook(response);
+                    if (!maybeResponse) {
+                      resolveReq(void 0);
+                      return;
+                    }
+                    response = maybeResponse;
+                  }
+                  const mimeType = response.headers.get("Content-Type")?.split(";")[0] || DEFAULT_CONTENT_TYPE;
+                  const content = await parseResponseContent(response);
+                  resolveReq({
+                    routePath: replacedUrlParam,
+                    mimeType,
+                    content
+                  });
+                } catch (error) {
+                  rejectReq(error);
+                }
+              });
+            }
+          })()
+        );
+      } catch (error) {
+        rejectGetInfo(error);
+      }
+    });
+  }
+};
+const createdDirs = /* @__PURE__ */ new Set();
+const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
+  const awaitedData = await data;
+  if (!awaitedData) {
+    return;
+  }
+  const { routePath, content, mimeType } = awaitedData;
+  const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
+  const dirPath = (0, import_utils2.dirname)(filePath);
+  if (!createdDirs.has(dirPath)) {
+    await fsModule.mkdir(dirPath, { recursive: true });
+    createdDirs.add(dirPath);
+  }
+  if (typeof content === "string") {
+    await fsModule.writeFile(filePath, content);
+  } else if (content instanceof ArrayBuffer) {
+    await fsModule.writeFile(filePath, new Uint8Array(content));
+  }
+  return filePath;
+};
+const defaultPlugin = {
+  afterResponseHook: (res) => {
+    if (res.status !== 200) {
+      return false;
+    }
+    return res;
+  }
+};
+const toSSG = async (app, fs, options) => {
+  let result;
+  const getInfoPromises = [];
+  const savePromises = [];
+  const plugins = options?.plugins || [defaultPlugin];
+  const beforeRequestHooks = [];
+  const afterResponseHooks = [];
+  const afterGenerateHooks = [];
+  if (options?.beforeRequestHook) {
+    beforeRequestHooks.push(
+      ...Array.isArray(options.beforeRequestHook) ? options.beforeRequestHook : [options.beforeRequestHook]
+    );
+  }
+  if (options?.afterResponseHook) {
+    afterResponseHooks.push(
+      ...Array.isArray(options.afterResponseHook) ? options.afterResponseHook : [options.afterResponseHook]
+    );
+  }
+  if (options?.afterGenerateHook) {
+    afterGenerateHooks.push(
+      ...Array.isArray(options.afterGenerateHook) ? options.afterGenerateHook : [options.afterGenerateHook]
+    );
+  }
+  for (const plugin of plugins) {
+    if (plugin.beforeRequestHook) {
+      beforeRequestHooks.push(
+        ...Array.isArray(plugin.beforeRequestHook) ? plugin.beforeRequestHook : [plugin.beforeRequestHook]
+      );
+    }
+    if (plugin.afterResponseHook) {
+      afterResponseHooks.push(
+        ...Array.isArray(plugin.afterResponseHook) ? plugin.afterResponseHook : [plugin.afterResponseHook]
+      );
+    }
+    if (plugin.afterGenerateHook) {
+      afterGenerateHooks.push(
+        ...Array.isArray(plugin.afterGenerateHook) ? plugin.afterGenerateHook : [plugin.afterGenerateHook]
+      );
+    }
+  }
+  try {
+    const outputDir = options?.dir ?? DEFAULT_OUTPUT_DIR;
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const combinedBeforeRequestHook = combineBeforeRequestHooks(
+      beforeRequestHooks.length > 0 ? beforeRequestHooks : [(req) => req]
+    );
+    const combinedAfterResponseHook = combineAfterResponseHooks(
+      afterResponseHooks.length > 0 ? afterResponseHooks : [(req) => req]
+    );
+    const getInfoGen = fetchRoutesContent(
+      app,
+      combinedBeforeRequestHook,
+      combinedAfterResponseHook,
+      concurrency
+    );
+    for (const getInfo of getInfoGen) {
+      getInfoPromises.push(
+        getInfo.then((getContentGen) => {
+          if (!getContentGen) {
+            return;
+          }
+          for (const content of getContentGen) {
+            savePromises.push(
+              saveContentToFile(content, fs, outputDir, options?.extensionMap).catch((e) => e)
+            );
+          }
+        })
+      );
+    }
+    await Promise.all(getInfoPromises);
+    const files = [];
+    for (const savePromise of savePromises) {
+      const fileOrError = await savePromise;
+      if (typeof fileOrError === "string") {
+        files.push(fileOrError);
+      } else if (fileOrError) {
+        throw fileOrError;
+      }
+    }
+    result = { success: true, files };
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    result = { success: false, files: [], error: errorObj };
+  }
+  if (afterGenerateHooks.length > 0) {
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(afterGenerateHooks, fs, options);
+    await combinedAfterGenerateHooks(result, fs, options);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OUTPUT_DIR,
+  combineAfterGenerateHooks,
+  combineAfterResponseHooks,
+  combineBeforeRequestHooks,
+  defaultExtensionMap,
+  defaultPlugin,
+  fetchRoutesContent,
+  saveContentToFile,
+  toSSG
+});

_node_modules/hono/dist/cjs/helper/ssg/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  dirname: () => dirname,
+  filterStaticGenerateRoutes: () => filterStaticGenerateRoutes,
+  isDynamicRoute: () => isDynamicRoute,
+  joinPaths: () => joinPaths
+});
+module.exports = __toCommonJS(utils_exports);
+var import_router = require("../../router");
+var import_handler = require("../../utils/handler");
+const dirname = (path) => {
+  const separatedPath = path.split(/[\/\\]/);
+  return separatedPath.slice(0, -1).join("/");
+};
+const normalizePath = (path) => {
+  return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
+};
+const handleParent = (resultPaths, beforeParentFlag) => {
+  if (resultPaths.length === 0 || beforeParentFlag) {
+    resultPaths.push("..");
+  } else {
+    resultPaths.pop();
+  }
+};
+const handleNonDot = (path, resultPaths) => {
+  path = path.replace(/^\.(?!.)/, "");
+  if (path !== "") {
+    resultPaths.push(path);
+  }
+};
+const handleSegments = (paths, resultPaths) => {
+  let beforeParentFlag = false;
+  for (const path of paths) {
+    if (path === "..") {
+      handleParent(resultPaths, beforeParentFlag);
+      beforeParentFlag = true;
+    } else {
+      handleNonDot(path, resultPaths);
+      beforeParentFlag = false;
+    }
+  }
+};
+const joinPaths = (...paths) => {
+  paths = paths.map(normalizePath);
+  const resultPaths = [];
+  handleSegments(paths.join("/").split("/"), resultPaths);
+  return (paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
+};
+const filterStaticGenerateRoutes = (hono) => {
+  return hono.routes.reduce((acc, { method, handler, path }) => {
+    const targetHandler = (0, import_handler.findTargetHandler)(handler);
+    if (["GET", import_router.METHOD_NAME_ALL].includes(method) && !(0, import_handler.isMiddleware)(targetHandler)) {
+      acc.push({ path });
+    }
+    return acc;
+  }, []);
+};
+const isDynamicRoute = (path) => {
+  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dirname,
+  filterStaticGenerateRoutes,
+  isDynamicRoute,
+  joinPaths
+});

_node_modules/hono/dist/cjs/helper/streaming/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_exports = {};
+__export(streaming_exports, {
+  SSEStreamingApi: () => import_sse.SSEStreamingApi,
+  stream: () => import_stream.stream,
+  streamSSE: () => import_sse.streamSSE,
+  streamText: () => import_text.streamText
+});
+module.exports = __toCommonJS(streaming_exports);
+var import_stream = require("./stream");
+var import_sse = require("./sse");
+var import_text = require("./text");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSEStreamingApi,
+  stream,
+  streamSSE,
+  streamText
+});

_node_modules/hono/dist/cjs/helper/streaming/sse.js

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sse_exports = {};
+__export(sse_exports, {
+  SSEStreamingApi: () => SSEStreamingApi,
+  streamSSE: () => streamSSE
+});
+module.exports = __toCommonJS(sse_exports);
+var import_html = require("../../utils/html");
+var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
+class SSEStreamingApi extends import_stream.StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await (0, import_html.resolveCallback)(message.data, import_html.HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split("\n").map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+}
+const run = async (stream, cb, onError) => {
+  try {
+    await cb(stream);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream);
+      await stream.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream.close();
+  }
+};
+const contextStash = /* @__PURE__ */ new WeakMap();
+const streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream = new SSEStreamingApi(writable, readable);
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
+  contextStash.set(stream.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream, cb, onError);
+  return c.newResponse(stream.responseReadable);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSEStreamingApi,
+  streamSSE
+});

_node_modules/hono/dist/cjs/helper/streaming/stream.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_exports = {};
+__export(stream_exports, {
+  stream: () => stream
+});
+module.exports = __toCommonJS(stream_exports);
+var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
+const contextStash = /* @__PURE__ */ new WeakMap();
+const stream = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new import_stream.StreamingApi(writable, readable);
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  (async () => {
+    try {
+      await cb(stream2);
+    } catch (e) {
+      if (e === void 0) {
+      } else if (e instanceof Error && onError) {
+        await onError(e, stream2);
+      } else {
+        console.error(e);
+      }
+    } finally {
+      stream2.close();
+    }
+  })();
+  return c.newResponse(stream2.responseReadable);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stream
+});

_node_modules/hono/dist/cjs/helper/streaming/text.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var text_exports = {};
+__export(text_exports, {
+  streamText: () => streamText
+});
+module.exports = __toCommonJS(text_exports);
+var import_context = require("../../context");
+var import__ = require("./");
+const streamText = (c, cb, onError) => {
+  c.header("Content-Type", import_context.TEXT_PLAIN);
+  c.header("X-Content-Type-Options", "nosniff");
+  c.header("Transfer-Encoding", "chunked");
+  return (0, import__.stream)(c, cb, onError);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamText
+});

_node_modules/hono/dist/cjs/helper/streaming/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  isOldBunVersion: () => isOldBunVersion
+});
+module.exports = __toCommonJS(utils_exports);
+let isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isOldBunVersion
+});

_node_modules/hono/dist/cjs/helper/testing/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var testing_exports = {};
+__export(testing_exports, {
+  testClient: () => testClient
+});
+module.exports = __toCommonJS(testing_exports);
+var import_client = require("../../client");
+const testClient = (app, Env, executionCtx, options) => {
+  const customFetch = (input, init) => {
+    return app.request(input, init, Env, executionCtx);
+  };
+  return (0, import_client.hc)("http://localhost", { ...options, fetch: customFetch });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  testClient
+});

_node_modules/hono/dist/cjs/helper/websocket/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websocket_exports = {};
+__export(websocket_exports, {
+  WSContext: () => WSContext,
+  createWSMessageEvent: () => createWSMessageEvent,
+  defineWebSocketHelper: () => defineWebSocketHelper
+});
+module.exports = __toCommonJS(websocket_exports);
+class WSContext {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(source, options ?? {});
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+}
+const createWSMessageEvent = (source) => {
+  return new MessageEvent("message", {
+    data: source
+  });
+};
+const defineWebSocketHelper = (handler) => {
+  return ((...args) => {
+    if (typeof args[0] === "function") {
+      const [createEvents, options] = args;
+      return async function upgradeWebSocket(c, next) {
+        const events = await createEvents(c);
+        const result = await handler(c, events, options);
+        if (result) {
+          return result;
+        }
+        await next();
+      };
+    } else {
+      const [c, events, options] = args;
+      return (async () => {
+        const upgraded = await handler(c, events, options);
+        if (!upgraded) {
+          throw new Error("Failed to upgrade WebSocket");
+        }
+        return upgraded;
+      })();
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WSContext,
+  createWSMessageEvent,
+  defineWebSocketHelper
+});

_node_modules/hono/dist/cjs/hono-base.js

@@ -0,0 +1,401 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hono_base_exports = {};
+__export(hono_base_exports, {
+  HonoBase: () => Hono
+});
+module.exports = __toCommonJS(hono_base_exports);
+var import_compose = require("./compose");
+var import_context = require("./context");
+var import_router = require("./router");
+var import_constants = require("./utils/constants");
+var import_url = require("./utils/url");
+const notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+const errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+class Hono {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
+  /*
+    This class is like an abstract class and does not have a router.
+    To use it, inherit the class and implement router in the constructor.
+  */
+  router;
+  getPath;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...import_router.METHODS, import_router.METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(method, this.#path, args1);
+        }
+        args.forEach((handler) => {
+          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 (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? import_url.getPath : import_url.getPathNoStrict;
+  }
+  #clone() {
+    const clone = new Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  errorHandler = errorHandler;
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
+  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 (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[import_constants.COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler);
+    });
+    return this;
+  }
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
+    return subApp;
+  }
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // Create itty-router application
+   * const ittyRouter = IttyRouter()
+   * // GET /itty-router/hello
+   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+   *
+   * const app = new Hono()
+   * app.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request;
+        } else {
+          replaceRequest = options.replaceRequest;
+        }
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = void 0;
+      try {
+        executionContext = c.executionCtx;
+      } catch {
+      }
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = (0, import_url.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(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    path = (0, import_url.mergePath)(this._basePath, path);
+    const r = { basePath: this._basePath, path, method, handler };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  #dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new import_context.Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+      return res instanceof Promise ? res.then(
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = (0, import_compose.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()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} Env - env Object
+   * @param {ExecutionContext} - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
+  };
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HonoBase
+});

_node_modules/hono/dist/cjs/hono.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hono_exports = {};
+__export(hono_exports, {
+  Hono: () => Hono
+});
+module.exports = __toCommonJS(hono_exports);
+var import_hono_base = require("./hono-base");
+var import_reg_exp_router = require("./router/reg-exp-router");
+var import_smart_router = require("./router/smart-router");
+var import_trie_router = require("./router/trie-router");
+class Hono extends import_hono_base.HonoBase {
+  /**
+   * Creates an instance of the Hono class.
+   *
+   * @param options - Optional configuration options for the Hono instance.
+   */
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new import_smart_router.SmartRouter({
+      routers: [new import_reg_exp_router.RegExpRouter(), new import_trie_router.TrieRouter()]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hono
+});

_node_modules/hono/dist/cjs/http-exception.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exception_exports = {};
+__export(http_exception_exports, {
+  HTTPException: () => HTTPException
+});
+module.exports = __toCommonJS(http_exception_exports);
+class HTTPException extends Error {
+  res;
+  status;
+  /**
+   * Creates an instance of `HTTPException`.
+   * @param status - HTTP status code for the exception. Defaults to 500.
+   * @param options - Additional options for the exception.
+   */
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  /**
+   * Returns the response object associated with the exception.
+   * If a response object is not provided, a new response is created with the error message and status code.
+   * @returns The response object.
+   */
+  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
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTPException
+});

_node_modules/hono/dist/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Hono: () => import_hono.Hono
+});
+module.exports = __toCommonJS(index_exports);
+var import_hono = require("./hono");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hono
+});

_node_modules/hono/dist/cjs/jsx/base.js

@@ -0,0 +1,375 @@
+"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 __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 base_exports = {};
+__export(base_exports, {
+  Fragment: () => Fragment,
+  JSXFragmentNode: () => JSXFragmentNode,
+  JSXNode: () => JSXNode,
+  booleanAttributes: () => booleanAttributes,
+  cloneElement: () => cloneElement,
+  getNameSpaceContext: () => getNameSpaceContext,
+  isValidElement: () => isValidElement,
+  jsx: () => jsx,
+  jsxFn: () => jsxFn,
+  memo: () => memo,
+  reactAPICompatVersion: () => reactAPICompatVersion,
+  shallowEqual: () => shallowEqual
+});
+module.exports = __toCommonJS(base_exports);
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_constants = require("./constants");
+var import_context = require("./context");
+var import_common = require("./intrinsic-element/common");
+var intrinsicElementTags = __toESM(require("./intrinsic-element/components"), 1);
+var import_utils = require("./utils");
+let nameSpaceContext = void 0;
+const getNameSpaceContext = () => nameSpaceContext;
+const toSVGAttributeName = (key) => /[A-Z]/.test(key) && // Presentation attributes are findable in style object. "clip-path", "font-size", "stroke-width", etc.
+// Or other un-deprecated kebab-case attributes. "overline-position", "paint-order", "strikethrough-position", etc.
+key.match(
+  /^(?:al|basel|clip(?:Path|Rule)$|co|do|fill|fl|fo|gl|let|lig|i|marker[EMS]|o|pai|pointe|sh|st[or]|text[^L]|tr|u|ve|w)/
+) ? key.replace(/([A-Z])/g, "-$1").toLowerCase() : key;
+const emptyTags = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+const booleanAttributes = [
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "download",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+];
+const childrenToStringToBuffer = (children, buffer) => {
+  for (let i = 0, len = children.length; i < len; i++) {
+    const child = children[i];
+    if (typeof child === "string") {
+      (0, import_html2.escapeToBuffer)(child, buffer);
+    } else if (typeof child === "boolean" || child === null || child === void 0) {
+      continue;
+    } else if (child instanceof JSXNode) {
+      child.toStringToBuffer(buffer);
+    } else if (typeof child === "number" || child.isEscaped) {
+      ;
+      buffer[0] += child;
+    } else if (child instanceof Promise) {
+      buffer.unshift("", child);
+    } else {
+      childrenToStringToBuffer(child, buffer);
+    }
+  }
+};
+class JSXNode {
+  tag;
+  props;
+  key;
+  children;
+  isEscaped = true;
+  localContexts;
+  constructor(tag, props, children) {
+    this.tag = tag;
+    this.props = props;
+    this.children = children;
+  }
+  get type() {
+    return this.tag;
+  }
+  // Added for compatibility with libraries that rely on React's internal structure
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get ref() {
+    return this.props.ref || null;
+  }
+  toString() {
+    const buffer = [""];
+    this.localContexts?.forEach(([context, value]) => {
+      context.values.push(value);
+    });
+    try {
+      this.toStringToBuffer(buffer);
+    } finally {
+      this.localContexts?.forEach(([context]) => {
+        context.values.pop();
+      });
+    }
+    return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+  }
+  toStringToBuffer(buffer) {
+    const tag = this.tag;
+    const props = this.props;
+    let { children } = this;
+    buffer[0] += `<${tag}`;
+    const normalizeKey = nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName((0, import_utils.normalizeIntrinsicElementKey)(key)) : (key) => (0, import_utils.normalizeIntrinsicElementKey)(key);
+    for (let [key, v] of Object.entries(props)) {
+      key = normalizeKey(key);
+      if (key === "children") {
+      } else if (key === "style" && typeof v === "object") {
+        let styleStr = "";
+        (0, import_utils.styleObjectForEach)(v, (property, value) => {
+          if (value != null) {
+            styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+          }
+        });
+        buffer[0] += ' style="';
+        (0, import_html2.escapeToBuffer)(styleStr, buffer);
+        buffer[0] += '"';
+      } else if (typeof v === "string") {
+        buffer[0] += ` ${key}="`;
+        (0, import_html2.escapeToBuffer)(v, buffer);
+        buffer[0] += '"';
+      } else if (v === null || v === void 0) {
+      } else if (typeof v === "number" || v.isEscaped) {
+        buffer[0] += ` ${key}="${v}"`;
+      } else if (typeof v === "boolean" && booleanAttributes.includes(key)) {
+        if (v) {
+          buffer[0] += ` ${key}=""`;
+        }
+      } else if (key === "dangerouslySetInnerHTML") {
+        if (children.length > 0) {
+          throw new Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
+        }
+        children = [(0, import_html.raw)(v.__html)];
+      } else if (v instanceof Promise) {
+        buffer[0] += ` ${key}="`;
+        buffer.unshift('"', v);
+      } else if (typeof v === "function") {
+        if (!key.startsWith("on") && key !== "ref") {
+          throw new Error(`Invalid prop '${key}' of type 'function' supplied to '${tag}'.`);
+        }
+      } else {
+        buffer[0] += ` ${key}="`;
+        (0, import_html2.escapeToBuffer)(v.toString(), buffer);
+        buffer[0] += '"';
+      }
+    }
+    if (emptyTags.includes(tag) && children.length === 0) {
+      buffer[0] += "/>";
+      return;
+    }
+    buffer[0] += ">";
+    childrenToStringToBuffer(children, buffer);
+    buffer[0] += `</${tag}>`;
+  }
+}
+class JSXFunctionNode extends JSXNode {
+  toStringToBuffer(buffer) {
+    const { children } = this;
+    const props = { ...this.props };
+    if (children.length) {
+      props.children = children.length === 1 ? children[0] : children;
+    }
+    const res = this.tag.call(null, props);
+    if (typeof res === "boolean" || res == null) {
+      return;
+    } else if (res instanceof Promise) {
+      if (import_context.globalContexts.length === 0) {
+        buffer.unshift("", res);
+      } else {
+        const currentContexts = import_context.globalContexts.map((c) => [c, c.values.at(-1)]);
+        buffer.unshift(
+          "",
+          res.then((childRes) => {
+            if (childRes instanceof JSXNode) {
+              childRes.localContexts = currentContexts;
+            }
+            return childRes;
+          })
+        );
+      }
+    } else if (res instanceof JSXNode) {
+      res.toStringToBuffer(buffer);
+    } else if (typeof res === "number" || res.isEscaped) {
+      buffer[0] += res;
+      if (res.callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...res.callbacks);
+      }
+    } else {
+      (0, import_html2.escapeToBuffer)(res, buffer);
+    }
+  }
+}
+class JSXFragmentNode extends JSXNode {
+  toStringToBuffer(buffer) {
+    childrenToStringToBuffer(this.children, buffer);
+  }
+}
+const jsx = (tag, props, ...children) => {
+  props ??= {};
+  if (children.length) {
+    props.children = children.length === 1 ? children[0] : children;
+  }
+  const key = props.key;
+  delete props["key"];
+  const node = jsxFn(tag, props, children);
+  node.key = key;
+  return node;
+};
+let initDomRenderer = false;
+const jsxFn = (tag, props, children) => {
+  if (!initDomRenderer) {
+    for (const k in import_common.domRenderers) {
+      ;
+      intrinsicElementTags[k][import_constants.DOM_RENDERER] = import_common.domRenderers[k];
+    }
+    initDomRenderer = true;
+  }
+  if (typeof tag === "function") {
+    return new JSXFunctionNode(tag, props, children);
+  } else if (intrinsicElementTags[tag]) {
+    return new JSXFunctionNode(
+      intrinsicElementTags[tag],
+      props,
+      children
+    );
+  } else if (tag === "svg" || tag === "head") {
+    nameSpaceContext ||= (0, import_context.createContext)("");
+    return new JSXNode(tag, props, [
+      new JSXFunctionNode(
+        nameSpaceContext,
+        {
+          value: tag
+        },
+        children
+      )
+    ]);
+  } else {
+    return new JSXNode(tag, props, children);
+  }
+};
+const shallowEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (let i = 0, len = aKeys.length; i < len; i++) {
+    if (aKeys[i] === "children" && bKeys[i] === "children" && !a.children?.length && !b.children?.length) {
+      continue;
+    } else if (a[aKeys[i]] !== b[aKeys[i]]) {
+      return false;
+    }
+  }
+  return true;
+};
+const memo = (component, propsAreEqual = shallowEqual) => {
+  let computed = null;
+  let prevProps = void 0;
+  const wrapper = ((props) => {
+    if (prevProps && !propsAreEqual(prevProps, props)) {
+      computed = null;
+    }
+    prevProps = props;
+    return computed ||= component(props);
+  });
+  wrapper[import_constants.DOM_MEMO] = propsAreEqual;
+  wrapper[import_constants.DOM_RENDERER] = component;
+  return wrapper;
+};
+const Fragment = ({
+  children
+}) => {
+  return new JSXFragmentNode(
+    "",
+    {
+      children
+    },
+    Array.isArray(children) ? children : children ? [children] : []
+  );
+};
+const isValidElement = (element) => {
+  return !!(element && typeof element === "object" && "tag" in element && "props" in element);
+};
+const cloneElement = (element, props, ...children) => {
+  let childrenToClone;
+  if (children.length > 0) {
+    childrenToClone = children;
+  } else {
+    const c = element.props.children;
+    childrenToClone = Array.isArray(c) ? c : [c];
+  }
+  return jsx(
+    element.tag,
+    { ...element.props, ...props },
+    ...childrenToClone
+  );
+};
+const reactAPICompatVersion = "19.0.0-hono-jsx";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  JSXFragmentNode,
+  JSXNode,
+  booleanAttributes,
+  cloneElement,
+  getNameSpaceContext,
+  isValidElement,
+  jsx,
+  jsxFn,
+  memo,
+  reactAPICompatVersion,
+  shallowEqual
+});

_node_modules/hono/dist/cjs/jsx/children.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var children_exports = {};
+__export(children_exports, {
+  Children: () => Children,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(children_exports);
+const toArray = (children) => Array.isArray(children) ? children : [children];
+const Children = {
+  map: (children, fn) => toArray(children).map(fn),
+  forEach: (children, fn) => {
+    toArray(children).forEach(fn);
+  },
+  count: (children) => toArray(children).length,
+  only: (_children) => {
+    const children = toArray(_children);
+    if (children.length !== 1) {
+      throw new Error("Children.only() expects only one child");
+    }
+    return children[0];
+  },
+  toArray
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Children,
+  toArray
+});

_node_modules/hono/dist/cjs/jsx/components.js

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var components_exports = {};
+__export(components_exports, {
+  ErrorBoundary: () => ErrorBoundary,
+  childrenToString: () => childrenToString
+});
+module.exports = __toCommonJS(components_exports);
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_constants = require("./constants");
+var import_context = require("./context");
+var import_components = require("./dom/components");
+var import_streaming = require("./streaming");
+let errorBoundaryCounter = 0;
+const childrenToString = async (children) => {
+  try {
+    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
+  } catch (e) {
+    if (e instanceof Promise) {
+      await e;
+      return childrenToString(children);
+    } else {
+      throw e;
+    }
+  }
+};
+const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
+  if (!children) {
+    return (0, import_html.raw)("");
+  }
+  if (!Array.isArray(children)) {
+    children = [children];
+  }
+  const nonce = (0, import_context.useContext)(import_streaming.StreamingContext)?.scriptNonce;
+  let fallbackStr;
+  const fallbackRes = (error) => {
+    onError?.(error);
+    return (fallbackStr || fallbackRender?.(error) || "").toString();
+  };
+  let resArray = [];
+  try {
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
+  } catch (e) {
+    fallbackStr = await fallback?.toString();
+    if (e instanceof Promise) {
+      resArray = [
+        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
+      ];
+    } else {
+      resArray = [fallbackRes(e)];
+    }
+  }
+  if (resArray.some((res) => res instanceof Promise)) {
+    fallbackStr ||= await fallback?.toString();
+    const index = errorBoundaryCounter++;
+    const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
+    const caught = false;
+    const catchCallback = ({ error: error2, buffer }) => {
+      if (caught) {
+        return "";
+      }
+      const fallbackResString = fallbackRes(error2);
+      if (buffer) {
+        buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+      }
+      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
+d.replaceWith(c.content)
+})(document)
+</script>`;
+    };
+    let error;
+    const promiseAll = Promise.all(resArray).catch((e) => error = e);
+    return (0, import_html.raw)(`<template id="E:${index}"></template><!--E:${index}-->`, [
+      ({ phase, buffer, context }) => {
+        if (phase === import_html2.HtmlEscapedCallbackPhase.BeforeStream) {
+          return;
+        }
+        return promiseAll.then(async (htmlArray) => {
+          if (error) {
+            throw error;
+          }
+          htmlArray = htmlArray.flat();
+          const content = htmlArray.join("");
+          let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+d.parentElement.insertBefore(c.content,d.nextSibling)
+})(document)
+</script>`;
+          if (htmlArray.every((html2) => !html2.callbacks?.length)) {
+            if (buffer) {
+              buffer[0] = buffer[0].replace(replaceRe, content);
+            }
+            return html;
+          }
+          if (buffer) {
+            buffer[0] = buffer[0].replace(
+              replaceRe,
+              (_all, pre, _, post) => `${pre}${content}${post}`
+            );
+          }
+          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
+          if (phase === import_html2.HtmlEscapedCallbackPhase.Stream) {
+            html = await (0, import_html2.resolveCallback)(
+              html,
+              import_html2.HtmlEscapedCallbackPhase.BeforeStream,
+              true,
+              context
+            );
+          }
+          let resolvedCount = 0;
+          const promises = callbacks.map(
+            (c) => (...args) => c(...args)?.then((content2) => {
+              resolvedCount++;
+              if (buffer) {
+                if (resolvedCount === callbacks.length) {
+                  buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content3) => content3);
+                }
+                buffer[0] += content2;
+                return (0, import_html.raw)("", content2.callbacks);
+              }
+              return (0, import_html.raw)(
+                content2 + (resolvedCount !== callbacks.length ? "" : `<script>
+((d,c,n) => {
+d=d.getElementById('E:${index}')
+if(!d)return
+n=d.nextSibling
+while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
+n.remove()
+d.remove()
+})(document)
+</script>`),
+                content2.callbacks
+              );
+            }).catch((error2) => catchCallback({ error: error2, buffer }))
+          );
+          return (0, import_html.raw)(html, promises);
+        }).catch((error2) => catchCallback({ error: error2, buffer }));
+      }
+    ]);
+  } else {
+    return (0, import_html.raw)(resArray.join(""));
+  }
+};
+ErrorBoundary[import_constants.DOM_RENDERER] = import_components.ErrorBoundary;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorBoundary,
+  childrenToString
+});

_node_modules/hono/dist/cjs/jsx/constants.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DOM_ERROR_HANDLER: () => DOM_ERROR_HANDLER,
+  DOM_INTERNAL_TAG: () => DOM_INTERNAL_TAG,
+  DOM_MEMO: () => DOM_MEMO,
+  DOM_RENDERER: () => DOM_RENDERER,
+  DOM_STASH: () => DOM_STASH,
+  PERMALINK: () => PERMALINK
+});
+module.exports = __toCommonJS(constants_exports);
+const DOM_RENDERER = /* @__PURE__ */ Symbol("RENDERER");
+const DOM_ERROR_HANDLER = /* @__PURE__ */ Symbol("ERROR_HANDLER");
+const DOM_STASH = /* @__PURE__ */ Symbol("STASH");
+const DOM_INTERNAL_TAG = /* @__PURE__ */ Symbol("INTERNAL");
+const DOM_MEMO = /* @__PURE__ */ Symbol("MEMO");
+const PERMALINK = /* @__PURE__ */ Symbol("PERMALINK");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOM_ERROR_HANDLER,
+  DOM_INTERNAL_TAG,
+  DOM_MEMO,
+  DOM_RENDERER,
+  DOM_STASH,
+  PERMALINK
+});

_node_modules/hono/dist/cjs/jsx/context.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  createContext: () => createContext,
+  globalContexts: () => globalContexts,
+  useContext: () => useContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_html = require("../helper/html");
+var import_base = require("./base");
+var import_constants = require("./constants");
+var import_context = require("./dom/context");
+const globalContexts = [];
+const createContext = (defaultValue) => {
+  const values = [defaultValue];
+  const context = ((props) => {
+    values.push(props.value);
+    let string;
+    try {
+      string = props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
+    } finally {
+      values.pop();
+    }
+    if (string instanceof Promise) {
+      return string.then((resString) => (0, import_html.raw)(resString, resString.callbacks));
+    } else {
+      return (0, import_html.raw)(string);
+    }
+  });
+  context.values = values;
+  context.Provider = context;
+  context[import_constants.DOM_RENDERER] = (0, import_context.createContextProviderFunction)(values);
+  globalContexts.push(context);
+  return context;
+};
+const useContext = (context) => {
+  return context.values.at(-1);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  globalContexts,
+  useContext
+});

_node_modules/hono/dist/cjs/jsx/dom/client.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  createRoot: () => createRoot,
+  default: () => client_default,
+  hydrateRoot: () => hydrateRoot
+});
+module.exports = __toCommonJS(client_exports);
+var import_hooks = require("../hooks");
+var import_render = require("./render");
+const createRoot = (element, options = {}) => {
+  let setJsxNode = (
+    // unmounted
+    void 0
+  );
+  if (Object.keys(options).length > 0) {
+    console.warn("createRoot options are not supported yet");
+  }
+  return {
+    render(jsxNode) {
+      if (setJsxNode === null) {
+        throw new Error("Cannot update an unmounted root");
+      }
+      if (setJsxNode) {
+        setJsxNode(jsxNode);
+      } else {
+        (0, import_render.renderNode)(
+          (0, import_render.buildNode)({
+            tag: () => {
+              const [_jsxNode, _setJsxNode] = (0, import_hooks.useState)(jsxNode);
+              setJsxNode = _setJsxNode;
+              return _jsxNode;
+            },
+            props: {}
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          }),
+          element
+        );
+      }
+    },
+    unmount() {
+      setJsxNode?.(null);
+      setJsxNode = null;
+    }
+  };
+};
+const hydrateRoot = (element, reactNode, options = {}) => {
+  const root = createRoot(element, options);
+  root.render(reactNode);
+  return root;
+};
+var client_default = {
+  createRoot,
+  hydrateRoot
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRoot,
+  hydrateRoot
+});

_node_modules/hono/dist/cjs/jsx/dom/components.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var components_exports = {};
+__export(components_exports, {
+  ErrorBoundary: () => ErrorBoundary,
+  Suspense: () => Suspense
+});
+module.exports = __toCommonJS(components_exports);
+var import_constants = require("../constants");
+var import_jsx_runtime = require("./jsx-runtime");
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+  const res = (0, import_jsx_runtime.Fragment)({ children });
+  res[import_constants.DOM_ERROR_HANDLER] = (err) => {
+    if (err instanceof Promise) {
+      throw err;
+    }
+    onError?.(err);
+    return fallbackRender?.(err) || fallback;
+  };
+  return res;
+});
+const Suspense = (({
+  children,
+  fallback
+}) => {
+  const res = (0, import_jsx_runtime.Fragment)({ children });
+  res[import_constants.DOM_ERROR_HANDLER] = (err, retry) => {
+    if (!(err instanceof Promise)) {
+      throw err;
+    }
+    err.finally(retry);
+    return fallback;
+  };
+  return res;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorBoundary,
+  Suspense
+});

_node_modules/hono/dist/cjs/jsx/dom/context.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  createContext: () => createContext,
+  createContextProviderFunction: () => createContextProviderFunction
+});
+module.exports = __toCommonJS(context_exports);
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_utils = require("./utils");
+const createContextProviderFunction = (values) => ({ value, children }) => {
+  if (!children) {
+    return void 0;
+  }
+  const props = {
+    children: [
+      {
+        tag: (0, import_utils.setInternalTagFlag)(() => {
+          values.push(value);
+        }),
+        props: {}
+      }
+    ]
+  };
+  if (Array.isArray(children)) {
+    props.children.push(...children.flat());
+  } else {
+    props.children.push(children);
+  }
+  props.children.push({
+    tag: (0, import_utils.setInternalTagFlag)(() => {
+      values.pop();
+    }),
+    props: {}
+  });
+  const res = { tag: "", props, type: "" };
+  res[import_constants.DOM_ERROR_HANDLER] = (err) => {
+    values.pop();
+    throw err;
+  };
+  return res;
+};
+const createContext = (defaultValue) => {
+  const values = [defaultValue];
+  const context = createContextProviderFunction(values);
+  context.values = values;
+  context.Provider = context;
+  import_context.globalContexts.push(context);
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  createContextProviderFunction
+});

_node_modules/hono/dist/cjs/jsx/dom/css.js

@@ -0,0 +1,162 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_exports = {};
+__export(css_exports, {
+  Style: () => Style,
+  createCssContext: () => createCssContext,
+  createCssJsxDomObjects: () => createCssJsxDomObjects,
+  css: () => css,
+  cx: () => cx,
+  keyframes: () => keyframes,
+  rawCssString: () => import_common2.rawCssString,
+  viewTransition: () => viewTransition
+});
+module.exports = __toCommonJS(css_exports);
+var import_common = require("../../helper/css/common");
+var import_common2 = require("../../helper/css/common");
+const splitRule = (rule) => {
+  const result = [];
+  let startPos = 0;
+  let depth = 0;
+  for (let i = 0, len = rule.length; i < len; i++) {
+    const char = rule[i];
+    if (char === "'" || char === '"') {
+      const quote = char;
+      i++;
+      for (; i < len; i++) {
+        if (rule[i] === "\\") {
+          i++;
+          continue;
+        }
+        if (rule[i] === quote) {
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        result.push(rule.slice(startPos, i + 1));
+        startPos = i + 1;
+      }
+      continue;
+    }
+  }
+  return result;
+};
+const createCssJsxDomObjects = ({ id }) => {
+  let styleSheet = void 0;
+  const findStyleSheet = () => {
+    if (!styleSheet) {
+      styleSheet = document.querySelector(`style#${id}`)?.sheet;
+      if (styleSheet) {
+        ;
+        styleSheet.addedStyles = /* @__PURE__ */ new Set();
+      }
+    }
+    return styleSheet ? [styleSheet, styleSheet.addedStyles] : [];
+  };
+  const insertRule = (className, styleString) => {
+    const [sheet, addedStyles] = findStyleSheet();
+    if (!sheet || !addedStyles) {
+      Promise.resolve().then(() => {
+        if (!findStyleSheet()[0]) {
+          throw new Error("style sheet not found");
+        }
+        insertRule(className, styleString);
+      });
+      return;
+    }
+    if (!addedStyles.has(className)) {
+      addedStyles.add(className);
+      (className.startsWith(import_common.PSEUDO_GLOBAL_SELECTOR) ? splitRule(styleString) : [`${className[0] === "@" ? "" : "."}${className}{${styleString}}`]).forEach((rule) => {
+        sheet.insertRule(rule, sheet.cssRules.length);
+      });
+    }
+  };
+  const cssObject = {
+    toString() {
+      const selector = this[import_common.SELECTOR];
+      insertRule(selector, this[import_common.STYLE_STRING]);
+      this[import_common.SELECTORS].forEach(({ [import_common.CLASS_NAME]: className, [import_common.STYLE_STRING]: styleString }) => {
+        insertRule(className, styleString);
+      });
+      return this[import_common.CLASS_NAME];
+    }
+  };
+  const Style2 = ({ children, nonce }) => ({
+    tag: "style",
+    props: {
+      id,
+      nonce,
+      children: children && (Array.isArray(children) ? children : [children]).map(
+        (c) => c[import_common.STYLE_STRING]
+      )
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  return [cssObject, Style2];
+};
+const createCssContext = ({ id }) => {
+  const [cssObject, Style2] = createCssJsxDomObjects({ id });
+  const newCssClassNameObject = (cssClassName) => {
+    cssClassName.toString = cssObject.toString;
+    return cssClassName;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+  };
+  const cx2 = (...args) => {
+    args = (0, import_common.cxCommon)(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = import_common.keyframesCommon;
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+  });
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+const defaultContext = createCssContext({ id: import_common.DEFAULT_STYLE_ID });
+const css = defaultContext.css;
+const cx = defaultContext.cx;
+const keyframes = defaultContext.keyframes;
+const viewTransition = defaultContext.viewTransition;
+const Style = defaultContext.Style;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Style,
+  createCssContext,
+  createCssJsxDomObjects,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+});

_node_modules/hono/dist/cjs/jsx/dom/hooks/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  FormContext: () => FormContext,
+  registerAction: () => registerAction,
+  useActionState: () => useActionState,
+  useFormStatus: () => useFormStatus,
+  useOptimistic: () => useOptimistic
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_constants = require("../../constants");
+var import_context = require("../../context");
+var import_hooks = require("../../hooks");
+var import_context2 = require("../context");
+const FormContext = (0, import_context2.createContext)({
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+});
+const actions = /* @__PURE__ */ new Set();
+const registerAction = (action) => {
+  actions.add(action);
+  action.finally(() => actions.delete(action));
+};
+const useFormStatus = () => {
+  return (0, import_context.useContext)(FormContext);
+};
+const useOptimistic = (state, updateState) => {
+  const [optimisticState, setOptimisticState] = (0, import_hooks.useState)(state);
+  if (actions.size > 0) {
+    Promise.all(actions).finally(() => {
+      setOptimisticState(state);
+    });
+  } else {
+    setOptimisticState(state);
+  }
+  const cb = (0, import_hooks.useCallback)((newData) => {
+    setOptimisticState((currentState) => updateState(currentState, newData));
+  }, []);
+  return [optimisticState, cb];
+};
+const useActionState = (fn, initialState, permalink) => {
+  const [state, setState] = (0, import_hooks.useState)(initialState);
+  const actionState = async (data) => {
+    setState(await fn(state, data));
+  };
+  actionState[import_constants.PERMALINK] = permalink;
+  return [state, actionState];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormContext,
+  registerAction,
+  useActionState,
+  useFormStatus,
+  useOptimistic
+});

_node_modules/hono/dist/cjs/jsx/dom/index.js

@@ -0,0 +1,182 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dom_exports = {};
+__export(dom_exports, {
+  Children: () => import_children.Children,
+  ErrorBoundary: () => import_components.ErrorBoundary,
+  Fragment: () => import_jsx_runtime.Fragment,
+  StrictMode: () => import_jsx_runtime.Fragment,
+  Suspense: () => import_components.Suspense,
+  cloneElement: () => cloneElement,
+  createContext: () => import_context2.createContext,
+  createElement: () => createElement,
+  createPortal: () => import_render.createPortal,
+  createRef: () => import_hooks.createRef,
+  default: () => dom_default,
+  flushSync: () => import_render.flushSync,
+  forwardRef: () => import_hooks.forwardRef,
+  isValidElement: () => import_base.isValidElement,
+  jsx: () => createElement,
+  memo: () => memo,
+  render: () => import_render2.render,
+  startTransition: () => import_hooks.startTransition,
+  startViewTransition: () => import_hooks.startViewTransition,
+  use: () => import_hooks.use,
+  useActionState: () => import_hooks2.useActionState,
+  useCallback: () => import_hooks.useCallback,
+  useContext: () => import_context.useContext,
+  useDebugValue: () => import_hooks.useDebugValue,
+  useDeferredValue: () => import_hooks.useDeferredValue,
+  useEffect: () => import_hooks.useEffect,
+  useFormStatus: () => import_hooks2.useFormStatus,
+  useId: () => import_hooks.useId,
+  useImperativeHandle: () => import_hooks.useImperativeHandle,
+  useInsertionEffect: () => import_hooks.useInsertionEffect,
+  useLayoutEffect: () => import_hooks.useLayoutEffect,
+  useMemo: () => import_hooks.useMemo,
+  useOptimistic: () => import_hooks2.useOptimistic,
+  useReducer: () => import_hooks.useReducer,
+  useRef: () => import_hooks.useRef,
+  useState: () => import_hooks.useState,
+  useSyncExternalStore: () => import_hooks.useSyncExternalStore,
+  useTransition: () => import_hooks.useTransition,
+  useViewTransition: () => import_hooks.useViewTransition,
+  version: () => import_base.reactAPICompatVersion
+});
+module.exports = __toCommonJS(dom_exports);
+var import_base = require("../base");
+var import_children = require("../children");
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_hooks = require("../hooks");
+var import_components = require("./components");
+var import_context2 = require("./context");
+var import_hooks2 = require("./hooks");
+var import_jsx_runtime = require("./jsx-runtime");
+var import_render = require("./render");
+var import_render2 = require("./render");
+const createElement = (tag, props, ...children) => {
+  const jsxProps = props ? { ...props } : {};
+  if (children.length) {
+    jsxProps.children = children.length === 1 ? children[0] : children;
+  }
+  let key = void 0;
+  if ("key" in jsxProps) {
+    key = jsxProps.key;
+    delete jsxProps.key;
+  }
+  return (0, import_jsx_runtime.jsx)(tag, jsxProps, key);
+};
+const cloneElement = (element, props, ...children) => {
+  return (0, import_jsx_runtime.jsx)(
+    element.tag,
+    {
+      ...element.props,
+      ...props,
+      children: children.length ? children : element.props.children
+    },
+    element.key
+  );
+};
+const memo = (component, propsAreEqual = import_base.shallowEqual) => {
+  const wrapper = ((props) => component(props));
+  wrapper[import_constants.DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
+var dom_default = {
+  version: import_base.reactAPICompatVersion,
+  useState: import_hooks.useState,
+  useEffect: import_hooks.useEffect,
+  useRef: import_hooks.useRef,
+  useCallback: import_hooks.useCallback,
+  use: import_hooks.use,
+  startTransition: import_hooks.startTransition,
+  useTransition: import_hooks.useTransition,
+  useDeferredValue: import_hooks.useDeferredValue,
+  startViewTransition: import_hooks.startViewTransition,
+  useViewTransition: import_hooks.useViewTransition,
+  useMemo: import_hooks.useMemo,
+  useLayoutEffect: import_hooks.useLayoutEffect,
+  useInsertionEffect: import_hooks.useInsertionEffect,
+  useReducer: import_hooks.useReducer,
+  useId: import_hooks.useId,
+  useDebugValue: import_hooks.useDebugValue,
+  createRef: import_hooks.createRef,
+  forwardRef: import_hooks.forwardRef,
+  useImperativeHandle: import_hooks.useImperativeHandle,
+  useSyncExternalStore: import_hooks.useSyncExternalStore,
+  useFormStatus: import_hooks2.useFormStatus,
+  useActionState: import_hooks2.useActionState,
+  useOptimistic: import_hooks2.useOptimistic,
+  Suspense: import_components.Suspense,
+  ErrorBoundary: import_components.ErrorBoundary,
+  createContext: import_context2.createContext,
+  useContext: import_context.useContext,
+  memo,
+  isValidElement: import_base.isValidElement,
+  createElement,
+  cloneElement,
+  Children: import_children.Children,
+  Fragment: import_jsx_runtime.Fragment,
+  StrictMode: import_jsx_runtime.Fragment,
+  flushSync: import_render.flushSync,
+  createPortal: import_render.createPortal
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Children,
+  ErrorBoundary,
+  Fragment,
+  StrictMode,
+  Suspense,
+  cloneElement,
+  createContext,
+  createElement,
+  createPortal,
+  createRef,
+  flushSync,
+  forwardRef,
+  isValidElement,
+  jsx,
+  memo,
+  render,
+  startTransition,
+  startViewTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+  version
+});

_node_modules/hono/dist/cjs/jsx/dom/intrinsic-element/components.js

@@ -0,0 +1,369 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var components_exports = {};
+__export(components_exports, {
+  button: () => button,
+  clearCache: () => clearCache,
+  composeRef: () => composeRef,
+  form: () => form,
+  input: () => input,
+  link: () => link,
+  meta: () => meta,
+  script: () => script,
+  style: () => style,
+  title: () => title
+});
+module.exports = __toCommonJS(components_exports);
+var import_context = require("../../context");
+var import_hooks = require("../../hooks");
+var import_common = require("../../intrinsic-element/common");
+var import_hooks2 = require("../hooks");
+var import_render = require("../render");
+const clearCache = () => {
+  blockingPromiseMap = /* @__PURE__ */ Object.create(null);
+  createdElements = /* @__PURE__ */ Object.create(null);
+};
+const composeRef = (ref, cb) => {
+  return (0, import_hooks.useMemo)(
+    () => (e) => {
+      let refCleanup;
+      if (ref) {
+        if (typeof ref === "function") {
+          refCleanup = ref(e) || (() => {
+            ref(null);
+          });
+        } else if (ref && "current" in ref) {
+          ref.current = e;
+          refCleanup = () => {
+            ref.current = null;
+          };
+        }
+      }
+      const cbCleanup = cb(e);
+      return () => {
+        cbCleanup?.();
+        refCleanup?.();
+      };
+    },
+    [ref]
+  );
+};
+let blockingPromiseMap = /* @__PURE__ */ Object.create(null);
+let createdElements = /* @__PURE__ */ Object.create(null);
+const documentMetadataTag = (tag, props, preserveNodeType, supportSort, supportBlocking) => {
+  if (props?.itemProp) {
+    return {
+      tag,
+      props,
+      type: tag,
+      ref: props.ref
+    };
+  }
+  const head = document.head;
+  let { onLoad, onError, precedence, blocking, ...restProps } = props;
+  let element = null;
+  let created = false;
+  const deDupeKeys = import_common.deDupeKeyMap[tag];
+  let existingElements = void 0;
+  if (deDupeKeys.length > 0) {
+    const tags = head.querySelectorAll(tag);
+    LOOP: for (const e of tags) {
+      for (const key of import_common.deDupeKeyMap[tag]) {
+        if (e.getAttribute(key) === props[key]) {
+          element = e;
+          break LOOP;
+        }
+      }
+    }
+    if (!element) {
+      const cacheKey = deDupeKeys.reduce(
+        (acc, key) => props[key] === void 0 ? acc : `${acc}-${key}-${props[key]}`,
+        tag
+      );
+      created = !createdElements[cacheKey];
+      element = createdElements[cacheKey] ||= (() => {
+        const e = document.createElement(tag);
+        for (const key of deDupeKeys) {
+          if (props[key] !== void 0) {
+            e.setAttribute(key, props[key]);
+          }
+          if (props.rel) {
+            e.setAttribute("rel", props.rel);
+          }
+        }
+        return e;
+      })();
+    }
+  } else {
+    existingElements = head.querySelectorAll(tag);
+  }
+  precedence = supportSort ? precedence ?? "" : void 0;
+  if (supportSort) {
+    restProps[import_common.dataPrecedenceAttr] = precedence;
+  }
+  const insert = (0, import_hooks.useCallback)(
+    (e) => {
+      if (deDupeKeys.length > 0) {
+        let found = false;
+        for (const existingElement of head.querySelectorAll(tag)) {
+          if (found && existingElement.getAttribute(import_common.dataPrecedenceAttr) !== precedence) {
+            head.insertBefore(e, existingElement);
+            return;
+          }
+          if (existingElement.getAttribute(import_common.dataPrecedenceAttr) === precedence) {
+            found = true;
+          }
+        }
+        head.appendChild(e);
+      } else if (existingElements) {
+        let found = false;
+        for (const existingElement of existingElements) {
+          if (existingElement === e) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          head.insertBefore(
+            e,
+            head.contains(existingElements[0]) ? existingElements[0] : head.querySelector(tag)
+          );
+        }
+        existingElements = void 0;
+      }
+    },
+    [precedence]
+  );
+  const ref = composeRef(props.ref, (e) => {
+    const key = deDupeKeys[0];
+    if (preserveNodeType === 2) {
+      e.innerHTML = "";
+    }
+    if (created || existingElements) {
+      insert(e);
+    }
+    if (!onError && !onLoad) {
+      return;
+    }
+    let promise = blockingPromiseMap[e.getAttribute(key)] ||= new Promise(
+      (resolve, reject) => {
+        e.addEventListener("load", resolve);
+        e.addEventListener("error", reject);
+      }
+    );
+    if (onLoad) {
+      promise = promise.then(onLoad);
+    }
+    if (onError) {
+      promise = promise.catch(onError);
+    }
+    promise.catch(() => {
+    });
+  });
+  if (supportBlocking && blocking === "render") {
+    const key = import_common.deDupeKeyMap[tag][0];
+    if (props[key]) {
+      const value = props[key];
+      const promise = blockingPromiseMap[value] ||= new Promise((resolve, reject) => {
+        insert(element);
+        element.addEventListener("load", resolve);
+        element.addEventListener("error", reject);
+      });
+      (0, import_hooks.use)(promise);
+    }
+  }
+  const jsxNode = {
+    tag,
+    type: tag,
+    props: {
+      ...restProps,
+      ref
+    },
+    ref
+  };
+  jsxNode.p = preserveNodeType;
+  if (element) {
+    jsxNode.e = element;
+  }
+  return (0, import_render.createPortal)(
+    jsxNode,
+    head
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  );
+};
+const title = (props) => {
+  const nameSpaceContext = (0, import_render.getNameSpaceContext)();
+  const ns = nameSpaceContext && (0, import_context.useContext)(nameSpaceContext);
+  if (ns?.endsWith("svg")) {
+    return {
+      tag: "title",
+      props,
+      type: "title",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ref: props.ref
+    };
+  }
+  return documentMetadataTag("title", props, void 0, false, false);
+};
+const script = (props) => {
+  if (!props || ["src", "async"].some((k) => !props[k])) {
+    return {
+      tag: "script",
+      props,
+      type: "script",
+      ref: props.ref
+    };
+  }
+  return documentMetadataTag("script", props, 1, false, true);
+};
+const style = (props) => {
+  if (!props || !["href", "precedence"].every((k) => k in props)) {
+    return {
+      tag: "style",
+      props,
+      type: "style",
+      ref: props.ref
+    };
+  }
+  props["data-href"] = props.href;
+  delete props.href;
+  return documentMetadataTag("style", props, 2, true, true);
+};
+const link = (props) => {
+  if (!props || ["onLoad", "onError"].some((k) => k in props) || props.rel === "stylesheet" && (!("precedence" in props) || "disabled" in props)) {
+    return {
+      tag: "link",
+      props,
+      type: "link",
+      ref: props.ref
+    };
+  }
+  return documentMetadataTag("link", props, 1, "precedence" in props, true);
+};
+const meta = (props) => {
+  return documentMetadataTag("meta", props, void 0, false, false);
+};
+const customEventFormAction = /* @__PURE__ */ Symbol();
+const form = (props) => {
+  const { action, ...restProps } = props;
+  if (typeof action !== "function") {
+    ;
+    restProps.action = action;
+  }
+  const [state, setState] = (0, import_hooks.useState)([null, false]);
+  const onSubmit = (0, import_hooks.useCallback)(
+    async (ev) => {
+      const currentAction = ev.isTrusted ? action : ev.detail[customEventFormAction];
+      if (typeof currentAction !== "function") {
+        return;
+      }
+      ev.preventDefault();
+      const formData = new FormData(ev.target);
+      setState([formData, true]);
+      const actionRes = currentAction(formData);
+      if (actionRes instanceof Promise) {
+        (0, import_hooks2.registerAction)(actionRes);
+        await actionRes;
+      }
+      setState([null, true]);
+    },
+    []
+  );
+  const ref = composeRef(props.ref, (el) => {
+    el.addEventListener("submit", onSubmit);
+    return () => {
+      el.removeEventListener("submit", onSubmit);
+    };
+  });
+  const [data, isDirty] = state;
+  state[1] = false;
+  return {
+    tag: import_hooks2.FormContext,
+    props: {
+      value: {
+        pending: data !== null,
+        data,
+        method: data ? "post" : null,
+        action: data ? action : null
+      },
+      children: {
+        tag: "form",
+        props: {
+          ...restProps,
+          ref
+        },
+        type: "form",
+        ref
+      }
+    },
+    f: isDirty
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
+};
+const formActionableElement = (tag, {
+  formAction,
+  ...props
+}) => {
+  if (typeof formAction === "function") {
+    const onClick = (0, import_hooks.useCallback)((ev) => {
+      ev.preventDefault();
+      ev.currentTarget.form.dispatchEvent(
+        new CustomEvent("submit", { detail: { [customEventFormAction]: formAction } })
+      );
+    }, []);
+    props.ref = composeRef(props.ref, (el) => {
+      el.addEventListener("click", onClick);
+      return () => {
+        el.removeEventListener("click", onClick);
+      };
+    });
+  }
+  return {
+    tag,
+    props,
+    type: tag,
+    ref: props.ref
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
+};
+const input = (props) => formActionableElement("input", props);
+const button = (props) => formActionableElement("button", props);
+Object.assign(import_common.domRenderers, {
+  title,
+  script,
+  style,
+  link,
+  meta,
+  form,
+  input,
+  button
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  button,
+  clearCache,
+  composeRef,
+  form,
+  input,
+  link,
+  meta,
+  script,
+  style,
+  title
+});

_node_modules/hono/dist/cjs/jsx/dom/jsx-dev-runtime.js

@@ -0,0 +1,53 @@
+"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 __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 jsx_dev_runtime_exports = {};
+__export(jsx_dev_runtime_exports, {
+  Fragment: () => Fragment,
+  jsxDEV: () => jsxDEV
+});
+module.exports = __toCommonJS(jsx_dev_runtime_exports);
+var intrinsicElementTags = __toESM(require("./intrinsic-element/components"), 1);
+const jsxDEV = (tag, props, key) => {
+  if (typeof tag === "string" && intrinsicElementTags[tag]) {
+    tag = intrinsicElementTags[tag];
+  }
+  return {
+    tag,
+    type: tag,
+    props,
+    key,
+    ref: props.ref
+  };
+};
+const Fragment = (props) => jsxDEV("", props, void 0);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsxDEV
+});

_node_modules/hono/dist/cjs/jsx/dom/jsx-runtime.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_runtime_exports = {};
+__export(jsx_runtime_exports, {
+  Fragment: () => import_jsx_dev_runtime.Fragment,
+  jsx: () => import_jsx_dev_runtime.jsxDEV,
+  jsxs: () => import_jsx_dev_runtime2.jsxDEV
+});
+module.exports = __toCommonJS(jsx_runtime_exports);
+var import_jsx_dev_runtime = require("./jsx-dev-runtime");
+var import_jsx_dev_runtime2 = require("./jsx-dev-runtime");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsx,
+  jsxs
+});

_node_modules/hono/dist/cjs/jsx/dom/render.js

@@ -0,0 +1,622 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+__export(render_exports, {
+  build: () => build,
+  buildDataStack: () => buildDataStack,
+  buildNode: () => buildNode,
+  createPortal: () => createPortal,
+  flushSync: () => flushSync,
+  getNameSpaceContext: () => getNameSpaceContext,
+  render: () => render,
+  renderNode: () => renderNode,
+  update: () => update
+});
+module.exports = __toCommonJS(render_exports);
+var import_children = require("../children");
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_hooks = require("../hooks");
+var import_utils = require("../utils");
+var import_context2 = require("./context");
+const HONO_PORTAL_ELEMENT = "_hp";
+const eventAliasMap = {
+  Change: "Input",
+  DoubleClick: "DblClick"
+};
+const nameSpaceMap = {
+  svg: "2000/svg",
+  math: "1998/Math/MathML"
+};
+const buildDataStack = [];
+const refCleanupMap = /* @__PURE__ */ new WeakMap();
+let nameSpaceContext = void 0;
+const getNameSpaceContext = () => nameSpaceContext;
+const isNodeString = (node) => "t" in node;
+const eventCache = {
+  // pre-define events that are used very frequently
+  onClick: ["click", false]
+};
+const getEventSpec = (key) => {
+  if (!key.startsWith("on")) {
+    return void 0;
+  }
+  if (eventCache[key]) {
+    return eventCache[key];
+  }
+  const match = key.match(/^on([A-Z][a-zA-Z]+?(?:PointerCapture)?)(Capture)?$/);
+  if (match) {
+    const [, eventName, capture] = match;
+    return eventCache[key] = [(eventAliasMap[eventName] || eventName).toLowerCase(), !!capture];
+  }
+  return void 0;
+};
+const toAttributeName = (element, key) => nameSpaceContext && element instanceof SVGElement && /[A-Z]/.test(key) && (key in element.style || // Presentation attributes are findable in style object. "clip-path", "font-size", "stroke-width", etc.
+key.match(/^(?:o|pai|str|u|ve)/)) ? key.replace(/([A-Z])/g, "-$1").toLowerCase() : key;
+const applyProps = (container, attributes, oldAttributes) => {
+  attributes ||= {};
+  for (let key in attributes) {
+    const value = attributes[key];
+    if (key !== "children" && (!oldAttributes || oldAttributes[key] !== value)) {
+      key = (0, import_utils.normalizeIntrinsicElementKey)(key);
+      const eventSpec = getEventSpec(key);
+      if (eventSpec) {
+        if (oldAttributes?.[key] !== value) {
+          if (oldAttributes) {
+            container.removeEventListener(eventSpec[0], oldAttributes[key], eventSpec[1]);
+          }
+          if (value != null) {
+            if (typeof value !== "function") {
+              throw new Error(`Event handler for "${key}" is not a function`);
+            }
+            container.addEventListener(eventSpec[0], value, eventSpec[1]);
+          }
+        }
+      } else if (key === "dangerouslySetInnerHTML" && value) {
+        container.innerHTML = value.__html;
+      } else if (key === "ref") {
+        let cleanup;
+        if (typeof value === "function") {
+          cleanup = value(container) || (() => value(null));
+        } else if (value && "current" in value) {
+          value.current = container;
+          cleanup = () => value.current = null;
+        }
+        refCleanupMap.set(container, cleanup);
+      } else if (key === "style") {
+        const style = container.style;
+        if (typeof value === "string") {
+          style.cssText = value;
+        } else {
+          style.cssText = "";
+          if (value != null) {
+            (0, import_utils.styleObjectForEach)(value, style.setProperty.bind(style));
+          }
+        }
+      } else {
+        if (key === "value") {
+          const nodeName = container.nodeName;
+          if (nodeName === "INPUT" || nodeName === "TEXTAREA" || nodeName === "SELECT") {
+            ;
+            container.value = value === null || value === void 0 || value === false ? null : value;
+            if (nodeName === "TEXTAREA") {
+              container.textContent = value;
+              continue;
+            } else if (nodeName === "SELECT") {
+              if (container.selectedIndex === -1) {
+                ;
+                container.selectedIndex = 0;
+              }
+              continue;
+            }
+          }
+        } else if (key === "checked" && container.nodeName === "INPUT" || key === "selected" && container.nodeName === "OPTION") {
+          ;
+          container[key] = value;
+        }
+        const k = toAttributeName(container, key);
+        if (value === null || value === void 0 || value === false) {
+          container.removeAttribute(k);
+        } else if (value === true) {
+          container.setAttribute(k, "");
+        } else if (typeof value === "string" || typeof value === "number") {
+          container.setAttribute(k, value);
+        } else {
+          container.setAttribute(k, value.toString());
+        }
+      }
+    }
+  }
+  if (oldAttributes) {
+    for (let key in oldAttributes) {
+      const value = oldAttributes[key];
+      if (key !== "children" && !(key in attributes)) {
+        key = (0, import_utils.normalizeIntrinsicElementKey)(key);
+        const eventSpec = getEventSpec(key);
+        if (eventSpec) {
+          container.removeEventListener(eventSpec[0], value, eventSpec[1]);
+        } else if (key === "ref") {
+          refCleanupMap.get(container)?.();
+        } else {
+          container.removeAttribute(toAttributeName(container, key));
+        }
+      }
+    }
+  }
+};
+const invokeTag = (context, node) => {
+  node[import_constants.DOM_STASH][0] = 0;
+  buildDataStack.push([context, node]);
+  const func = node.tag[import_constants.DOM_RENDERER] || node.tag;
+  const props = func.defaultProps ? {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ...func.defaultProps,
+    ...node.props
+  } : node.props;
+  try {
+    return [func.call(null, props)];
+  } finally {
+    buildDataStack.pop();
+  }
+};
+const getNextChildren = (node, container, nextChildren, childrenToRemove, callbacks) => {
+  if (node.vR?.length) {
+    childrenToRemove.push(...node.vR);
+    delete node.vR;
+  }
+  if (typeof node.tag === "function") {
+    node[import_constants.DOM_STASH][1][import_hooks.STASH_EFFECT]?.forEach((data) => callbacks.push(data));
+  }
+  node.vC.forEach((child) => {
+    if (isNodeString(child)) {
+      nextChildren.push(child);
+    } else {
+      if (typeof child.tag === "function" || child.tag === "") {
+        child.c = container;
+        const currentNextChildrenIndex = nextChildren.length;
+        getNextChildren(child, container, nextChildren, childrenToRemove, callbacks);
+        if (child.s) {
+          for (let i = currentNextChildrenIndex; i < nextChildren.length; i++) {
+            nextChildren[i].s = true;
+          }
+          child.s = false;
+        }
+      } else {
+        nextChildren.push(child);
+        if (child.vR?.length) {
+          childrenToRemove.push(...child.vR);
+          delete child.vR;
+        }
+      }
+    }
+  });
+};
+const findInsertBefore = (node) => {
+  for (; ; node = node.tag === HONO_PORTAL_ELEMENT || !node.vC || !node.pP ? node.nN : node.vC[0]) {
+    if (!node) {
+      return null;
+    }
+    if (node.tag !== HONO_PORTAL_ELEMENT && node.e) {
+      return node.e;
+    }
+  }
+};
+const removeNode = (node) => {
+  if (!isNodeString(node)) {
+    node[import_constants.DOM_STASH]?.[1][import_hooks.STASH_EFFECT]?.forEach((data) => data[2]?.());
+    refCleanupMap.get(node.e)?.();
+    if (node.p === 2) {
+      node.vC?.forEach((n) => n.p = 2);
+    }
+    node.vC?.forEach(removeNode);
+  }
+  if (!node.p) {
+    node.e?.remove();
+    delete node.e;
+  }
+  if (typeof node.tag === "function") {
+    updateMap.delete(node);
+    fallbackUpdateFnArrayMap.delete(node);
+    delete node[import_constants.DOM_STASH][3];
+    node.a = true;
+  }
+};
+const apply = (node, container, isNew) => {
+  node.c = container;
+  applyNodeObject(node, container, isNew);
+};
+const findChildNodeIndex = (childNodes, child) => {
+  if (!child) {
+    return;
+  }
+  for (let i = 0, len = childNodes.length; i < len; i++) {
+    if (childNodes[i] === child) {
+      return i;
+    }
+  }
+  return;
+};
+const cancelBuild = /* @__PURE__ */ Symbol();
+const applyNodeObject = (node, container, isNew) => {
+  const next = [];
+  const remove = [];
+  const callbacks = [];
+  getNextChildren(node, container, next, remove, callbacks);
+  remove.forEach(removeNode);
+  const childNodes = isNew ? void 0 : container.childNodes;
+  let offset;
+  let insertBeforeNode = null;
+  if (isNew) {
+    offset = -1;
+  } else if (!childNodes.length) {
+    offset = 0;
+  } else {
+    const offsetByNextNode = findChildNodeIndex(childNodes, findInsertBefore(node.nN));
+    if (offsetByNextNode !== void 0) {
+      insertBeforeNode = childNodes[offsetByNextNode];
+      offset = offsetByNextNode;
+    } else {
+      offset = findChildNodeIndex(childNodes, next.find((n) => n.tag !== HONO_PORTAL_ELEMENT && n.e)?.e) ?? -1;
+    }
+    if (offset === -1) {
+      isNew = true;
+    }
+  }
+  for (let i = 0, len = next.length; i < len; i++, offset++) {
+    const child = next[i];
+    let el;
+    if (child.s && child.e) {
+      el = child.e;
+      child.s = false;
+    } else {
+      const isNewLocal = isNew || !child.e;
+      if (isNodeString(child)) {
+        if (child.e && child.d) {
+          child.e.textContent = child.t;
+        }
+        child.d = false;
+        el = child.e ||= document.createTextNode(child.t);
+      } else {
+        el = child.e ||= child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag);
+        applyProps(el, child.props, child.pP);
+        applyNodeObject(child, el, isNewLocal);
+      }
+    }
+    if (child.tag === HONO_PORTAL_ELEMENT) {
+      offset--;
+    } else if (isNew) {
+      if (!el.parentNode) {
+        container.appendChild(el);
+      }
+    } else if (childNodes[offset] !== el && childNodes[offset - 1] !== el) {
+      if (childNodes[offset + 1] === el) {
+        container.appendChild(childNodes[offset]);
+      } else {
+        container.insertBefore(el, insertBeforeNode || childNodes[offset] || null);
+      }
+    }
+  }
+  if (node.pP) {
+    delete node.pP;
+  }
+  if (callbacks.length) {
+    const useLayoutEffectCbs = [];
+    const useEffectCbs = [];
+    callbacks.forEach(([, useLayoutEffectCb, , useEffectCb, useInsertionEffectCb]) => {
+      if (useLayoutEffectCb) {
+        useLayoutEffectCbs.push(useLayoutEffectCb);
+      }
+      if (useEffectCb) {
+        useEffectCbs.push(useEffectCb);
+      }
+      useInsertionEffectCb?.();
+    });
+    useLayoutEffectCbs.forEach((cb) => cb());
+    if (useEffectCbs.length) {
+      requestAnimationFrame(() => {
+        useEffectCbs.forEach((cb) => cb());
+      });
+    }
+  }
+};
+const isSameContext = (oldContexts, newContexts) => !!(oldContexts && oldContexts.length === newContexts.length && oldContexts.every((ctx, i) => ctx[1] === newContexts[i][1]));
+const fallbackUpdateFnArrayMap = /* @__PURE__ */ new WeakMap();
+const build = (context, node, children) => {
+  const buildWithPreviousChildren = !children && node.pC;
+  if (children) {
+    node.pC ||= node.vC;
+  }
+  let foundErrorHandler;
+  try {
+    children ||= typeof node.tag == "function" ? invokeTag(context, node) : (0, import_children.toArray)(node.props.children);
+    if (children[0]?.tag === "" && children[0][import_constants.DOM_ERROR_HANDLER]) {
+      foundErrorHandler = children[0][import_constants.DOM_ERROR_HANDLER];
+      context[5].push([context, foundErrorHandler, node]);
+    }
+    const oldVChildren = buildWithPreviousChildren ? [...node.pC] : node.vC ? [...node.vC] : void 0;
+    const vChildren = [];
+    let prevNode;
+    for (let i = 0; i < children.length; i++) {
+      if (Array.isArray(children[i])) {
+        children.splice(i, 1, ...children[i].flat());
+      }
+      let child = buildNode(children[i]);
+      if (child) {
+        if (typeof child.tag === "function" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        !child.tag[import_constants.DOM_INTERNAL_TAG]) {
+          if (import_context.globalContexts.length > 0) {
+            child[import_constants.DOM_STASH][2] = import_context.globalContexts.map((c) => [c, c.values.at(-1)]);
+          }
+          if (context[5]?.length) {
+            child[import_constants.DOM_STASH][3] = context[5].at(-1);
+          }
+        }
+        let oldChild;
+        if (oldVChildren && oldVChildren.length) {
+          const i2 = oldVChildren.findIndex(
+            isNodeString(child) ? (c) => isNodeString(c) : child.key !== void 0 ? (c) => c.key === child.key && c.tag === child.tag : (c) => c.tag === child.tag
+          );
+          if (i2 !== -1) {
+            oldChild = oldVChildren[i2];
+            oldVChildren.splice(i2, 1);
+          }
+        }
+        if (oldChild) {
+          if (isNodeString(child)) {
+            if (oldChild.t !== child.t) {
+              ;
+              oldChild.t = child.t;
+              oldChild.d = true;
+            }
+            child = oldChild;
+          } else {
+            const pP = oldChild.pP = oldChild.props;
+            oldChild.props = child.props;
+            oldChild.f ||= child.f || node.f;
+            if (typeof child.tag === "function") {
+              const oldContexts = oldChild[import_constants.DOM_STASH][2];
+              oldChild[import_constants.DOM_STASH][2] = child[import_constants.DOM_STASH][2] || [];
+              oldChild[import_constants.DOM_STASH][3] = child[import_constants.DOM_STASH][3];
+              if (!oldChild.f && ((oldChild.o || oldChild) === child.o || // The code generated by the react compiler is memoized under this condition.
+              oldChild.tag[import_constants.DOM_MEMO]?.(pP, oldChild.props)) && // The `memo` function is memoized under this condition.
+              isSameContext(oldContexts, oldChild[import_constants.DOM_STASH][2])) {
+                oldChild.s = true;
+              }
+            }
+            child = oldChild;
+          }
+        } else if (!isNodeString(child) && nameSpaceContext) {
+          const ns = (0, import_context.useContext)(nameSpaceContext);
+          if (ns) {
+            child.n = ns;
+          }
+        }
+        if (!isNodeString(child) && !child.s) {
+          build(context, child);
+          delete child.f;
+        }
+        vChildren.push(child);
+        if (prevNode && !prevNode.s && !child.s) {
+          for (let p = prevNode; p && !isNodeString(p); p = p.vC?.at(-1)) {
+            p.nN = child;
+          }
+        }
+        prevNode = child;
+      }
+    }
+    node.vR = buildWithPreviousChildren ? [...node.vC, ...oldVChildren || []] : oldVChildren || [];
+    node.vC = vChildren;
+    if (buildWithPreviousChildren) {
+      delete node.pC;
+    }
+  } catch (e) {
+    node.f = true;
+    if (e === cancelBuild) {
+      if (foundErrorHandler) {
+        return;
+      } else {
+        throw e;
+      }
+    }
+    const [errorHandlerContext, errorHandler, errorHandlerNode] = node[import_constants.DOM_STASH]?.[3] || [];
+    if (errorHandler) {
+      const fallbackUpdateFn = () => update([0, false, context[2]], errorHandlerNode);
+      const fallbackUpdateFnArray = fallbackUpdateFnArrayMap.get(errorHandlerNode) || [];
+      fallbackUpdateFnArray.push(fallbackUpdateFn);
+      fallbackUpdateFnArrayMap.set(errorHandlerNode, fallbackUpdateFnArray);
+      const fallback = errorHandler(e, () => {
+        const fnArray = fallbackUpdateFnArrayMap.get(errorHandlerNode);
+        if (fnArray) {
+          const i = fnArray.indexOf(fallbackUpdateFn);
+          if (i !== -1) {
+            fnArray.splice(i, 1);
+            return fallbackUpdateFn();
+          }
+        }
+      });
+      if (fallback) {
+        if (context[0] === 1) {
+          context[1] = true;
+        } else {
+          build(context, errorHandlerNode, [fallback]);
+          if ((errorHandler.length === 1 || context !== errorHandlerContext) && errorHandlerNode.c) {
+            apply(errorHandlerNode, errorHandlerNode.c, false);
+            return;
+          }
+        }
+        throw cancelBuild;
+      }
+    }
+    throw e;
+  } finally {
+    if (foundErrorHandler) {
+      context[5].pop();
+    }
+  }
+};
+const buildNode = (node) => {
+  if (node === void 0 || node === null || typeof node === "boolean") {
+    return void 0;
+  } else if (typeof node === "string" || typeof node === "number") {
+    return { t: node.toString(), d: true };
+  } else {
+    if ("vR" in node) {
+      node = {
+        tag: node.tag,
+        props: node.props,
+        key: node.key,
+        f: node.f,
+        type: node.tag,
+        ref: node.props.ref,
+        o: node.o || node
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      };
+    }
+    if (typeof node.tag === "function") {
+      ;
+      node[import_constants.DOM_STASH] = [0, []];
+    } else {
+      const ns = nameSpaceMap[node.tag];
+      if (ns) {
+        nameSpaceContext ||= (0, import_context2.createContext)("");
+        node.props.children = [
+          {
+            tag: nameSpaceContext,
+            props: {
+              value: node.n = `http://www.w3.org/${ns}`,
+              children: node.props.children
+            }
+          }
+        ];
+      }
+    }
+    return node;
+  }
+};
+const replaceContainer = (node, from, to) => {
+  if (node.c === from) {
+    node.c = to;
+    node.vC.forEach((child) => replaceContainer(child, from, to));
+  }
+};
+const updateSync = (context, node) => {
+  node[import_constants.DOM_STASH][2]?.forEach(([c, v]) => {
+    c.values.push(v);
+  });
+  try {
+    build(context, node, void 0);
+  } catch {
+    return;
+  }
+  if (node.a) {
+    delete node.a;
+    return;
+  }
+  node[import_constants.DOM_STASH][2]?.forEach(([c]) => {
+    c.values.pop();
+  });
+  if (context[0] !== 1 || !context[1]) {
+    apply(node, node.c, false);
+  }
+};
+const updateMap = /* @__PURE__ */ new WeakMap();
+const currentUpdateSets = [];
+const update = async (context, node) => {
+  context[5] ||= [];
+  const existing = updateMap.get(node);
+  if (existing) {
+    existing[0](void 0);
+  }
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  updateMap.set(node, [
+    resolve,
+    () => {
+      if (context[2]) {
+        context[2](context, node, (context2) => {
+          updateSync(context2, node);
+        }).then(() => resolve(node));
+      } else {
+        updateSync(context, node);
+        resolve(node);
+      }
+    }
+  ]);
+  if (currentUpdateSets.length) {
+    ;
+    currentUpdateSets.at(-1).add(node);
+  } else {
+    await Promise.resolve();
+    const latest = updateMap.get(node);
+    if (latest) {
+      updateMap.delete(node);
+      latest[1]();
+    }
+  }
+  return promise;
+};
+const renderNode = (node, container) => {
+  const context = [];
+  context[5] = [];
+  context[4] = true;
+  build(context, node, void 0);
+  context[4] = false;
+  const fragment = document.createDocumentFragment();
+  apply(node, fragment, true);
+  replaceContainer(node, fragment, container);
+  container.replaceChildren(fragment);
+};
+const render = (jsxNode, container) => {
+  renderNode(buildNode({ tag: "", props: { children: jsxNode } }), container);
+};
+const flushSync = (callback) => {
+  const set = /* @__PURE__ */ new Set();
+  currentUpdateSets.push(set);
+  callback();
+  set.forEach((node) => {
+    const latest = updateMap.get(node);
+    if (latest) {
+      updateMap.delete(node);
+      latest[1]();
+    }
+  });
+  currentUpdateSets.pop();
+};
+const createPortal = (children, container, key) => ({
+  tag: HONO_PORTAL_ELEMENT,
+  props: {
+    children
+  },
+  key,
+  e: container,
+  p: 1
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  buildDataStack,
+  buildNode,
+  createPortal,
+  flushSync,
+  getNameSpaceContext,
+  render,
+  renderNode,
+  update
+});

_node_modules/hono/dist/cjs/jsx/dom/server.js

@@ -0,0 +1,68 @@
+"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 __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 server_exports = {};
+__export(server_exports, {
+  default: () => server_default,
+  renderToReadableStream: () => renderToReadableStream,
+  renderToString: () => renderToString,
+  version: () => import__.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_streaming = require("../streaming");
+var import__ = __toESM(require("./"), 1);
+const renderToString = (element, options = {}) => {
+  if (Object.keys(options).length > 0) {
+    console.warn("options are not supported yet");
+  }
+  const res = element?.toString() ?? "";
+  if (typeof res !== "string") {
+    throw new Error("Async component is not supported in renderToString");
+  }
+  return res;
+};
+const renderToReadableStream = async (element, options = {}) => {
+  if (Object.keys(options).some((key) => key !== "onError")) {
+    console.warn("options are not supported yet, except onError");
+  }
+  if (!element || typeof element !== "object") {
+    element = element?.toString() ?? "";
+  }
+  return (0, import_streaming.renderToReadableStream)(element, options.onError);
+};
+var server_default = {
+  renderToString,
+  renderToReadableStream,
+  version: import__.default
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderToReadableStream,
+  renderToString,
+  version
+});

_node_modules/hono/dist/cjs/jsx/dom/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  setInternalTagFlag: () => setInternalTagFlag
+});
+module.exports = __toCommonJS(utils_exports);
+var import_constants = require("../constants");
+const setInternalTagFlag = (fn) => {
+  ;
+  fn[import_constants.DOM_INTERNAL_TAG] = true;
+  return fn;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setInternalTagFlag
+});

_node_modules/hono/dist/cjs/jsx/hooks/index.js

@@ -0,0 +1,371 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  STASH_EFFECT: () => STASH_EFFECT,
+  createRef: () => createRef,
+  forwardRef: () => forwardRef,
+  startTransition: () => startTransition,
+  startViewTransition: () => startViewTransition,
+  use: () => use,
+  useCallback: () => useCallback,
+  useDebugValue: () => useDebugValue,
+  useDeferredValue: () => useDeferredValue,
+  useEffect: () => useEffect,
+  useId: () => useId,
+  useImperativeHandle: () => useImperativeHandle,
+  useInsertionEffect: () => useInsertionEffect,
+  useLayoutEffect: () => useLayoutEffect,
+  useMemo: () => useMemo,
+  useReducer: () => useReducer,
+  useRef: () => useRef,
+  useState: () => useState,
+  useSyncExternalStore: () => useSyncExternalStore,
+  useTransition: () => useTransition,
+  useViewTransition: () => useViewTransition
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_constants = require("../constants");
+var import_render = require("../dom/render");
+const STASH_SATE = 0;
+const STASH_EFFECT = 1;
+const STASH_CALLBACK = 2;
+const STASH_MEMO = 3;
+const STASH_REF = 4;
+const resolvedPromiseValueMap = /* @__PURE__ */ new WeakMap();
+const isDepsChanged = (prevDeps, deps) => !prevDeps || !deps || prevDeps.length !== deps.length || deps.some((dep, i) => dep !== prevDeps[i]);
+let viewTransitionState = void 0;
+const documentStartViewTransition = (cb) => {
+  if (document?.startViewTransition) {
+    return document.startViewTransition(cb);
+  } else {
+    cb();
+    return { finished: Promise.resolve() };
+  }
+};
+let updateHook = void 0;
+const viewTransitionHook = (context, node, cb) => {
+  const state = [true, false];
+  let lastVC = node.vC;
+  return documentStartViewTransition(() => {
+    if (lastVC === node.vC) {
+      viewTransitionState = state;
+      cb(context);
+      viewTransitionState = void 0;
+      lastVC = node.vC;
+    }
+  }).finished.then(() => {
+    if (state[1] && lastVC === node.vC) {
+      state[0] = false;
+      viewTransitionState = state;
+      cb(context);
+      viewTransitionState = void 0;
+    }
+  });
+};
+const startViewTransition = (callback) => {
+  updateHook = viewTransitionHook;
+  try {
+    callback();
+  } finally {
+    updateHook = void 0;
+  }
+};
+const useViewTransition = () => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return [false, () => {
+    }];
+  }
+  if (viewTransitionState) {
+    viewTransitionState[1] = true;
+  }
+  return [!!viewTransitionState?.[0], startViewTransition];
+};
+const pendingStack = [];
+const runCallback = (type, callback) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  pendingStack.push([type, promise]);
+  try {
+    const res = callback();
+    if (res instanceof Promise) {
+      res.then(resolve, resolve);
+    } else {
+      resolve();
+    }
+  } finally {
+    pendingStack.pop();
+  }
+};
+const startTransition = (callback) => {
+  runCallback(1, callback);
+};
+const startTransitionHook = (callback) => {
+  runCallback(2, callback);
+};
+const useTransition = () => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return [false, () => {
+    }];
+  }
+  const [error, setError] = useState();
+  const [state, updateState] = useState();
+  if (error) {
+    throw error[0];
+  }
+  const startTransitionLocalHook = useCallback(
+    (callback) => {
+      startTransitionHook(() => {
+        updateState((state2) => !state2);
+        let res = callback();
+        if (res instanceof Promise) {
+          res = res.catch((e) => {
+            setError([e]);
+          });
+        }
+        return res;
+      });
+    },
+    [state]
+  );
+  const [context] = buildData;
+  return [context[0] === 2, startTransitionLocalHook];
+};
+const useDeferredValue = (value, ...rest) => {
+  const [values, setValues] = useState(
+    rest.length ? [rest[0], rest[0]] : [value, value]
+  );
+  if (Object.is(values[1], value)) {
+    return values[1];
+  }
+  pendingStack.push([3, Promise.resolve()]);
+  updateHook = async (context, _, cb) => {
+    cb(context);
+    values[0] = value;
+  };
+  setValues([values[0], value]);
+  updateHook = void 0;
+  pendingStack.pop();
+  return values[0];
+};
+const useState = (initialState) => {
+  const resolveInitialState = () => typeof initialState === "function" ? initialState() : initialState;
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return [resolveInitialState(), () => {
+    }];
+  }
+  const [, node] = buildData;
+  const stateArray = node[import_constants.DOM_STASH][1][STASH_SATE] ||= [];
+  const hookIndex = node[import_constants.DOM_STASH][0]++;
+  return stateArray[hookIndex] ||= [
+    resolveInitialState(),
+    (newState) => {
+      const localUpdateHook = updateHook;
+      const stateData = stateArray[hookIndex];
+      if (typeof newState === "function") {
+        newState = newState(stateData[0]);
+      }
+      if (!Object.is(newState, stateData[0])) {
+        stateData[0] = newState;
+        if (pendingStack.length) {
+          const [pendingType, pendingPromise] = pendingStack.at(-1);
+          Promise.all([
+            pendingType === 3 ? node : (0, import_render.update)([pendingType, false, localUpdateHook], node),
+            pendingPromise
+          ]).then(([node2]) => {
+            if (!node2 || !(pendingType === 2 || pendingType === 3)) {
+              return;
+            }
+            const lastVC = node2.vC;
+            const addUpdateTask = () => {
+              setTimeout(() => {
+                if (lastVC !== node2.vC) {
+                  return;
+                }
+                (0, import_render.update)([pendingType === 3 ? 1 : 0, false, localUpdateHook], node2);
+              });
+            };
+            requestAnimationFrame(addUpdateTask);
+          });
+        } else {
+          (0, import_render.update)([0, false, localUpdateHook], node);
+        }
+      }
+    }
+  ];
+};
+const useReducer = (reducer, initialArg, init) => {
+  const handler = useCallback(
+    (action) => {
+      setState((state2) => reducer(state2, action));
+    },
+    [reducer]
+  );
+  const [state, setState] = useState(() => init ? init(initialArg) : initialArg);
+  return [state, handler];
+};
+const useEffectCommon = (index, effect, deps) => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return;
+  }
+  const [, node] = buildData;
+  const effectDepsArray = node[import_constants.DOM_STASH][1][STASH_EFFECT] ||= [];
+  const hookIndex = node[import_constants.DOM_STASH][0]++;
+  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] ||= [];
+  if (isDepsChanged(prevDeps, deps)) {
+    if (prevCleanup) {
+      prevCleanup();
+    }
+    const runner = () => {
+      data[index] = void 0;
+      data[2] = effect();
+    };
+    const data = [deps, void 0, void 0, void 0, void 0];
+    data[index] = runner;
+    effectDepsArray[hookIndex] = data;
+  }
+};
+const useEffect = (effect, deps) => useEffectCommon(3, effect, deps);
+const useLayoutEffect = (effect, deps) => useEffectCommon(1, effect, deps);
+const useInsertionEffect = (effect, deps) => useEffectCommon(4, effect, deps);
+const useCallback = (callback, deps) => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return callback;
+  }
+  const [, node] = buildData;
+  const callbackArray = node[import_constants.DOM_STASH][1][STASH_CALLBACK] ||= [];
+  const hookIndex = node[import_constants.DOM_STASH][0]++;
+  const prevDeps = callbackArray[hookIndex];
+  if (isDepsChanged(prevDeps?.[1], deps)) {
+    callbackArray[hookIndex] = [callback, deps];
+  } else {
+    callback = callbackArray[hookIndex][0];
+  }
+  return callback;
+};
+const useRef = (initialValue) => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return { current: initialValue };
+  }
+  const [, node] = buildData;
+  const refArray = node[import_constants.DOM_STASH][1][STASH_REF] ||= [];
+  const hookIndex = node[import_constants.DOM_STASH][0]++;
+  return refArray[hookIndex] ||= { current: initialValue };
+};
+const use = (promise) => {
+  const cachedRes = resolvedPromiseValueMap.get(promise);
+  if (cachedRes) {
+    if (cachedRes.length === 2) {
+      throw cachedRes[1];
+    }
+    return cachedRes[0];
+  }
+  promise.then(
+    (res) => resolvedPromiseValueMap.set(promise, [res]),
+    (e) => resolvedPromiseValueMap.set(promise, [void 0, e])
+  );
+  throw promise;
+};
+const useMemo = (factory, deps) => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    return factory();
+  }
+  const [, node] = buildData;
+  const memoArray = node[import_constants.DOM_STASH][1][STASH_MEMO] ||= [];
+  const hookIndex = node[import_constants.DOM_STASH][0]++;
+  const prevDeps = memoArray[hookIndex];
+  if (isDepsChanged(prevDeps?.[1], deps)) {
+    memoArray[hookIndex] = [factory(), deps];
+  }
+  return memoArray[hookIndex][0];
+};
+let idCounter = 0;
+const useId = () => useMemo(() => `:r${(idCounter++).toString(32)}:`, []);
+const useDebugValue = (_value, _formatter) => {
+};
+const createRef = () => {
+  return { current: null };
+};
+const forwardRef = (Component) => {
+  return (props) => {
+    const { ref, ...rest } = props;
+    return Component(rest, ref);
+  };
+};
+const useImperativeHandle = (ref, createHandle, deps) => {
+  useEffect(() => {
+    ref.current = createHandle();
+    return () => {
+      ref.current = null;
+    };
+  }, deps);
+};
+const useSyncExternalStore = (subscribe, getSnapshot, getServerSnapshot) => {
+  const buildData = import_render.buildDataStack.at(-1);
+  if (!buildData) {
+    if (!getServerSnapshot) {
+      throw new Error("getServerSnapshot is required for server side rendering");
+    }
+    return getServerSnapshot();
+  }
+  const [serverSnapshotIsUsed] = useState(!!(buildData[0][4] && getServerSnapshot));
+  const [state, setState] = useState(
+    () => serverSnapshotIsUsed ? getServerSnapshot() : getSnapshot()
+  );
+  useEffect(() => {
+    if (serverSnapshotIsUsed) {
+      setState(getSnapshot());
+    }
+    return subscribe(() => {
+      setState(getSnapshot());
+    });
+  }, []);
+  return state;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STASH_EFFECT,
+  createRef,
+  forwardRef,
+  startTransition,
+  startViewTransition,
+  use,
+  useCallback,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition
+});

_node_modules/hono/dist/cjs/jsx/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_exports = {};
+__export(jsx_exports, {
+  Children: () => import_children.Children,
+  ErrorBoundary: () => import_components.ErrorBoundary,
+  Fragment: () => import_base.Fragment,
+  StrictMode: () => import_base.Fragment,
+  Suspense: () => import_streaming.Suspense,
+  cloneElement: () => import_base.cloneElement,
+  createContext: () => import_context.createContext,
+  createElement: () => import_base.jsx,
+  createRef: () => import_hooks2.createRef,
+  default: () => jsx_default,
+  forwardRef: () => import_hooks2.forwardRef,
+  isValidElement: () => import_base.isValidElement,
+  jsx: () => import_base.jsx,
+  memo: () => import_base.memo,
+  startTransition: () => import_hooks2.startTransition,
+  startViewTransition: () => import_hooks2.startViewTransition,
+  use: () => import_hooks2.use,
+  useActionState: () => import_hooks.useActionState,
+  useCallback: () => import_hooks2.useCallback,
+  useContext: () => import_context.useContext,
+  useDebugValue: () => import_hooks2.useDebugValue,
+  useDeferredValue: () => import_hooks2.useDeferredValue,
+  useEffect: () => import_hooks2.useEffect,
+  useId: () => import_hooks2.useId,
+  useImperativeHandle: () => import_hooks2.useImperativeHandle,
+  useInsertionEffect: () => import_hooks2.useInsertionEffect,
+  useLayoutEffect: () => import_hooks2.useLayoutEffect,
+  useMemo: () => import_hooks2.useMemo,
+  useOptimistic: () => import_hooks.useOptimistic,
+  useReducer: () => import_hooks2.useReducer,
+  useRef: () => import_hooks2.useRef,
+  useState: () => import_hooks2.useState,
+  useSyncExternalStore: () => import_hooks2.useSyncExternalStore,
+  useTransition: () => import_hooks2.useTransition,
+  useViewTransition: () => import_hooks2.useViewTransition,
+  version: () => import_base.reactAPICompatVersion
+});
+module.exports = __toCommonJS(jsx_exports);
+var import_base = require("./base");
+var import_children = require("./children");
+var import_components = require("./components");
+var import_context = require("./context");
+var import_hooks = require("./dom/hooks");
+var import_hooks2 = require("./hooks");
+var import_streaming = require("./streaming");
+var jsx_default = {
+  version: import_base.reactAPICompatVersion,
+  memo: import_base.memo,
+  Fragment: import_base.Fragment,
+  StrictMode: import_base.Fragment,
+  isValidElement: import_base.isValidElement,
+  createElement: import_base.jsx,
+  cloneElement: import_base.cloneElement,
+  ErrorBoundary: import_components.ErrorBoundary,
+  createContext: import_context.createContext,
+  useContext: import_context.useContext,
+  useState: import_hooks2.useState,
+  useEffect: import_hooks2.useEffect,
+  useRef: import_hooks2.useRef,
+  useCallback: import_hooks2.useCallback,
+  useReducer: import_hooks2.useReducer,
+  useId: import_hooks2.useId,
+  useDebugValue: import_hooks2.useDebugValue,
+  use: import_hooks2.use,
+  startTransition: import_hooks2.startTransition,
+  useTransition: import_hooks2.useTransition,
+  useDeferredValue: import_hooks2.useDeferredValue,
+  startViewTransition: import_hooks2.startViewTransition,
+  useViewTransition: import_hooks2.useViewTransition,
+  useMemo: import_hooks2.useMemo,
+  useLayoutEffect: import_hooks2.useLayoutEffect,
+  useInsertionEffect: import_hooks2.useInsertionEffect,
+  createRef: import_hooks2.createRef,
+  forwardRef: import_hooks2.forwardRef,
+  useImperativeHandle: import_hooks2.useImperativeHandle,
+  useSyncExternalStore: import_hooks2.useSyncExternalStore,
+  useActionState: import_hooks.useActionState,
+  useOptimistic: import_hooks.useOptimistic,
+  Suspense: import_streaming.Suspense,
+  Children: import_children.Children
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Children,
+  ErrorBoundary,
+  Fragment,
+  StrictMode,
+  Suspense,
+  cloneElement,
+  createContext,
+  createElement,
+  createRef,
+  forwardRef,
+  isValidElement,
+  jsx,
+  memo,
+  startTransition,
+  startViewTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+  version
+});

_node_modules/hono/dist/cjs/jsx/intrinsic-element/common.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+__export(common_exports, {
+  dataPrecedenceAttr: () => dataPrecedenceAttr,
+  deDupeKeyMap: () => deDupeKeyMap,
+  domRenderers: () => domRenderers
+});
+module.exports = __toCommonJS(common_exports);
+const deDupeKeyMap = {
+  title: [],
+  script: ["src"],
+  style: ["data-href"],
+  link: ["href"],
+  meta: ["name", "httpEquiv", "charset", "itemProp"]
+};
+const domRenderers = {};
+const dataPrecedenceAttr = "data-precedence";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dataPrecedenceAttr,
+  deDupeKeyMap,
+  domRenderers
+});

_node_modules/hono/dist/cjs/jsx/intrinsic-element/components.js

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var components_exports = {};
+__export(components_exports, {
+  button: () => button,
+  form: () => form,
+  input: () => input,
+  link: () => link,
+  meta: () => meta,
+  script: () => script,
+  style: () => style,
+  title: () => title
+});
+module.exports = __toCommonJS(components_exports);
+var import_html = require("../../helper/html");
+var import_base = require("../base");
+var import_children = require("../children");
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_common = require("./common");
+const metaTagMap = /* @__PURE__ */ new WeakMap();
+const insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }) => {
+  if (!buffer) {
+    return;
+  }
+  const map = metaTagMap.get(context) || {};
+  metaTagMap.set(context, map);
+  const tags = map[tagName] ||= [];
+  let duped = false;
+  const deDupeKeys = import_common.deDupeKeyMap[tagName];
+  if (deDupeKeys.length > 0) {
+    LOOP: for (const [, tagProps] of tags) {
+      for (const key of deDupeKeys) {
+        if ((tagProps?.[key] ?? null) === props?.[key]) {
+          duped = true;
+          break LOOP;
+        }
+      }
+    }
+  }
+  if (duped) {
+    buffer[0] = buffer[0].replaceAll(tag, "");
+  } else if (deDupeKeys.length > 0) {
+    tags.push([tag, props, precedence]);
+  } else {
+    tags.unshift([tag, props, precedence]);
+  }
+  if (buffer[0].indexOf("</head>") !== -1) {
+    let insertTags;
+    if (precedence === void 0) {
+      insertTags = tags.map(([tag2]) => tag2);
+    } else {
+      const precedences = [];
+      insertTags = tags.map(([tag2, , precedence2]) => {
+        let order = precedences.indexOf(precedence2);
+        if (order === -1) {
+          precedences.push(precedence2);
+          order = precedences.length - 1;
+        }
+        return [tag2, order];
+      }).sort((a, b) => a[1] - b[1]).map(([tag2]) => tag2);
+    }
+    insertTags.forEach((tag2) => {
+      buffer[0] = buffer[0].replaceAll(tag2, "");
+    });
+    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
+  }
+};
+const returnWithoutSpecialBehavior = (tag, children, props) => (0, import_html.raw)(new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? [])).toString());
+const documentMetadataTag = (tag, children, props, sort) => {
+  if ("itemProp" in props) {
+    return returnWithoutSpecialBehavior(tag, children, props);
+  }
+  let { precedence, blocking, ...restProps } = props;
+  precedence = sort ? precedence ?? "" : void 0;
+  if (sort) {
+    restProps[import_common.dataPrecedenceAttr] = precedence;
+  }
+  const string = new import_base.JSXNode(tag, restProps, (0, import_children.toArray)(children || [])).toString();
+  if (string instanceof Promise) {
+    return string.then(
+      (resString) => (0, import_html.raw)(string, [
+        ...resString.callbacks || [],
+        insertIntoHead(tag, resString, restProps, precedence)
+      ])
+    );
+  } else {
+    return (0, import_html.raw)(string, [insertIntoHead(tag, string, restProps, precedence)]);
+  }
+};
+const title = ({ children, ...props }) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (nameSpaceContext) {
+    const context = (0, import_context.useContext)(nameSpaceContext);
+    if (context === "svg" || context === "head") {
+      return new import_base.JSXNode(
+        "title",
+        props,
+        (0, import_children.toArray)(children ?? [])
+      );
+    }
+  }
+  return documentMetadataTag("title", children, props, false);
+};
+const script = ({
+  children,
+  ...props
+}) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (["src", "async"].some((k) => !props[k]) || nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("script", children, props);
+  }
+  return documentMetadataTag("script", children, props, false);
+};
+const style = ({
+  children,
+  ...props
+}) => {
+  if (!["href", "precedence"].every((k) => k in props)) {
+    return returnWithoutSpecialBehavior("style", children, props);
+  }
+  props["data-href"] = props.href;
+  delete props.href;
+  return documentMetadataTag("style", children, props, true);
+};
+const link = ({ children, ...props }) => {
+  if (["onLoad", "onError"].some((k) => k in props) || props.rel === "stylesheet" && (!("precedence" in props) || "disabled" in props)) {
+    return returnWithoutSpecialBehavior("link", children, props);
+  }
+  return documentMetadataTag("link", children, props, "precedence" in props);
+};
+const meta = ({ children, ...props }) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("meta", children, props);
+  }
+  return documentMetadataTag("meta", children, props, false);
+};
+const newJSXNode = (tag, { children, ...props }) => (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? []))
+);
+const form = (props) => {
+  if (typeof props.action === "function") {
+    props.action = import_constants.PERMALINK in props.action ? props.action[import_constants.PERMALINK] : void 0;
+  }
+  return newJSXNode("form", props);
+};
+const formActionableElement = (tag, props) => {
+  if (typeof props.formAction === "function") {
+    props.formAction = import_constants.PERMALINK in props.formAction ? props.formAction[import_constants.PERMALINK] : void 0;
+  }
+  return newJSXNode(tag, props);
+};
+const input = (props) => formActionableElement("input", props);
+const button = (props) => formActionableElement("button", props);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  button,
+  form,
+  input,
+  link,
+  meta,
+  script,
+  style,
+  title
+});

_node_modules/hono/dist/cjs/jsx/intrinsic-elements.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intrinsic_elements_exports = {};
+module.exports = __toCommonJS(intrinsic_elements_exports);

_node_modules/hono/dist/cjs/jsx/jsx-dev-runtime.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_dev_runtime_exports = {};
+__export(jsx_dev_runtime_exports, {
+  Fragment: () => import_base2.Fragment,
+  jsxDEV: () => jsxDEV
+});
+module.exports = __toCommonJS(jsx_dev_runtime_exports);
+var import_base = require("./base");
+var import_base2 = require("./base");
+function jsxDEV(tag, props, key) {
+  let node;
+  if (!props || !("children" in props)) {
+    node = (0, import_base.jsxFn)(tag, props, []);
+  } else {
+    const children = props.children;
+    node = Array.isArray(children) ? (0, import_base.jsxFn)(tag, props, children) : (0, import_base.jsxFn)(tag, props, [children]);
+  }
+  node.key = key;
+  return node;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsxDEV
+});

_node_modules/hono/dist/cjs/jsx/jsx-runtime.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_runtime_exports = {};
+__export(jsx_runtime_exports, {
+  Fragment: () => import_jsx_dev_runtime.Fragment,
+  jsx: () => import_jsx_dev_runtime.jsxDEV,
+  jsxAttr: () => jsxAttr,
+  jsxEscape: () => jsxEscape,
+  jsxTemplate: () => import_html.html,
+  jsxs: () => import_jsx_dev_runtime2.jsxDEV
+});
+module.exports = __toCommonJS(jsx_runtime_exports);
+var import_jsx_dev_runtime = require("./jsx-dev-runtime");
+var import_jsx_dev_runtime2 = require("./jsx-dev-runtime");
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_utils = require("./utils");
+const jsxAttr = (key, v) => {
+  const buffer = [`${key}="`];
+  if (key === "style" && typeof v === "object") {
+    let styleStr = "";
+    (0, import_utils.styleObjectForEach)(v, (property, value) => {
+      if (value != null) {
+        styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+      }
+    });
+    (0, import_html2.escapeToBuffer)(styleStr, buffer);
+    buffer[0] += '"';
+  } else if (typeof v === "string") {
+    (0, import_html2.escapeToBuffer)(v, buffer);
+    buffer[0] += '"';
+  } else if (v === null || v === void 0) {
+    return (0, import_html.raw)("");
+  } else if (typeof v === "number" || v.isEscaped) {
+    buffer[0] += `${v}"`;
+  } else if (v instanceof Promise) {
+    buffer.unshift('"', v);
+  } else {
+    (0, import_html2.escapeToBuffer)(v.toString(), buffer);
+    buffer[0] += '"';
+  }
+  return buffer.length === 1 ? (0, import_html.raw)(buffer[0]) : (0, import_html2.stringBufferToString)(buffer, void 0);
+};
+const jsxEscape = (value) => value;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsx,
+  jsxAttr,
+  jsxEscape,
+  jsxTemplate,
+  jsxs
+});

_node_modules/hono/dist/cjs/jsx/streaming.js

@@ -0,0 +1,168 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_exports = {};
+__export(streaming_exports, {
+  StreamingContext: () => StreamingContext,
+  Suspense: () => Suspense,
+  renderToReadableStream: () => renderToReadableStream
+});
+module.exports = __toCommonJS(streaming_exports);
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_base = require("./base");
+var import_components = require("./components");
+var import_constants = require("./constants");
+var import_context = require("./context");
+var import_components2 = require("./dom/components");
+var import_render = require("./dom/render");
+const StreamingContext = (0, import_context.createContext)(null);
+let suspenseCounter = 0;
+const Suspense = async ({
+  children,
+  fallback
+}) => {
+  if (!Array.isArray(children)) {
+    children = [children];
+  }
+  const nonce = (0, import_context.useContext)(StreamingContext)?.scriptNonce;
+  let resArray = [];
+  const stackNode = { [import_constants.DOM_STASH]: [0, []] };
+  const popNodeStack = (value) => {
+    import_render.buildDataStack.pop();
+    return value;
+  };
+  try {
+    stackNode[import_constants.DOM_STASH][0] = 0;
+    import_render.buildDataStack.push([[], stackNode]);
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
+  } catch (e) {
+    if (e instanceof Promise) {
+      resArray = [
+        e.then(() => {
+          stackNode[import_constants.DOM_STASH][0] = 0;
+          import_render.buildDataStack.push([[], stackNode]);
+          return (0, import_components.childrenToString)(children).then(popNodeStack);
+        })
+      ];
+    } else {
+      throw e;
+    }
+  } finally {
+    popNodeStack();
+  }
+  if (resArray.some((res) => res instanceof Promise)) {
+    const index = suspenseCounter++;
+    const fallbackStr = await fallback.toString();
+    return (0, import_html.raw)(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
+      ...fallbackStr.callbacks || [],
+      ({ phase, buffer, context }) => {
+        if (phase === import_html2.HtmlEscapedCallbackPhase.BeforeStream) {
+          return;
+        }
+        return Promise.all(resArray).then(async (htmlArray) => {
+          htmlArray = htmlArray.flat();
+          const content = htmlArray.join("");
+          if (buffer) {
+            buffer[0] = buffer[0].replace(
+              new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
+              content
+            );
+          }
+          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+</script>`;
+          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
+          if (!callbacks.length) {
+            return html;
+          }
+          if (phase === import_html2.HtmlEscapedCallbackPhase.Stream) {
+            html = await (0, import_html2.resolveCallback)(html, import_html2.HtmlEscapedCallbackPhase.BeforeStream, true, context);
+          }
+          return (0, import_html.raw)(html, callbacks);
+        });
+      }
+    ]);
+  } else {
+    return (0, import_html.raw)(resArray.join(""));
+  }
+};
+Suspense[import_constants.DOM_RENDERER] = import_components2.Suspense;
+const textEncoder = new TextEncoder();
+const renderToReadableStream = (content, onError = console.trace) => {
+  const reader = new ReadableStream({
+    async start(controller) {
+      try {
+        if (content instanceof import_base.JSXNode) {
+          content = content.toString();
+        }
+        const context = typeof content === "object" ? content : {};
+        const resolved = await (0, import_html2.resolveCallback)(
+          content,
+          import_html2.HtmlEscapedCallbackPhase.BeforeStream,
+          true,
+          context
+        );
+        controller.enqueue(textEncoder.encode(resolved));
+        let resolvedCount = 0;
+        const callbacks = [];
+        const then = (promise) => {
+          callbacks.push(
+            promise.catch((err) => {
+              console.log(err);
+              onError(err);
+              return "";
+            }).then(async (res) => {
+              res = await (0, import_html2.resolveCallback)(
+                res,
+                import_html2.HtmlEscapedCallbackPhase.BeforeStream,
+                true,
+                context
+              );
+              res.callbacks?.map((c) => c({ phase: import_html2.HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+              resolvedCount++;
+              controller.enqueue(textEncoder.encode(res));
+            })
+          );
+        };
+        resolved.callbacks?.map((c) => c({ phase: import_html2.HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+        while (resolvedCount !== callbacks.length) {
+          await Promise.all(callbacks);
+        }
+      } catch (e) {
+        onError(e);
+      }
+      controller.close();
+    }
+  });
+  return reader;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingContext,
+  Suspense,
+  renderToReadableStream
+});

_node_modules/hono/dist/cjs/jsx/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

_node_modules/hono/dist/cjs/jsx/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  normalizeIntrinsicElementKey: () => normalizeIntrinsicElementKey,
+  styleObjectForEach: () => styleObjectForEach
+});
+module.exports = __toCommonJS(utils_exports);
+const normalizeElementKeyMap = /* @__PURE__ */ new Map([
+  ["className", "class"],
+  ["htmlFor", "for"],
+  ["crossOrigin", "crossorigin"],
+  ["httpEquiv", "http-equiv"],
+  ["itemProp", "itemprop"],
+  ["fetchPriority", "fetchpriority"],
+  ["noModule", "nomodule"],
+  ["formAction", "formaction"]
+]);
+const normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
+const styleObjectForEach = (style, fn) => {
+  for (const [k, v] of Object.entries(style)) {
+    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    fn(
+      key,
+      v == null ? null : typeof v === "number" ? !key.match(
+        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+      ) ? `${v}px` : `${v}` : v
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeIntrinsicElementKey,
+  styleObjectForEach
+});

_node_modules/hono/dist/cjs/middleware/basic-auth/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_auth_exports = {};
+__export(basic_auth_exports, {
+  basicAuth: () => basicAuth
+});
+module.exports = __toCommonJS(basic_auth_exports);
+var import_http_exception = require("../../http-exception");
+var import_basic_auth = require("../../utils/basic-auth");
+var import_buffer = require("../../utils/buffer");
+const basicAuth = (options, ...users) => {
+  const usernamePasswordInOptions = "username" in options && "password" in options;
+  const verifyUserInOptions = "verifyUser" in options;
+  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
+    throw new Error(
+      'basic auth middleware requires options for "username and password" or "verifyUser"'
+    );
+  }
+  if (!options.realm) {
+    options.realm = "Secure Area";
+  }
+  if (!options.invalidUserMessage) {
+    options.invalidUserMessage = "Unauthorized";
+  }
+  if (usernamePasswordInOptions) {
+    users.unshift({ username: options.username, password: options.password });
+  }
+  return async function basicAuth2(ctx, next) {
+    const requestUser = (0, import_basic_auth.auth)(ctx.req.raw);
+    if (requestUser) {
+      if (verifyUserInOptions) {
+        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+          await next();
+          return;
+        }
+      } else {
+        for (const user of users) {
+          const [usernameEqual, passwordEqual] = await Promise.all([
+            (0, import_buffer.timingSafeEqual)(user.username, requestUser.username, options.hashFunction),
+            (0, import_buffer.timingSafeEqual)(user.password, requestUser.password, options.hashFunction)
+          ]);
+          if (usernameEqual && passwordEqual) {
+            await next();
+            return;
+          }
+        }
+      }
+    }
+    const status = 401;
+    const headers = {
+      "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
+    };
+    const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new import_http_exception.HTTPException(status, { res });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basicAuth
+});

_node_modules/hono/dist/cjs/middleware/bearer-auth/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bearer_auth_exports = {};
+__export(bearer_auth_exports, {
+  bearerAuth: () => bearerAuth
+});
+module.exports = __toCommonJS(bearer_auth_exports);
+var import_http_exception = require("../../http-exception");
+var import_buffer = require("../../utils/buffer");
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
+const HEADER = "Authorization";
+const bearerAuth = (options) => {
+  if (!("token" in options || "verifyToken" in options)) {
+    throw new Error('bearer auth middleware requires options for "token"');
+  }
+  if (!options.realm) {
+    options.realm = "";
+  }
+  if (options.prefix === void 0) {
+    options.prefix = PREFIX;
+  }
+  const realm = options.realm?.replace(/"/g, '\\"');
+  const prefixRegexStr = options.prefix === "" ? "" : `${options.prefix} +`;
+  const regexp = new RegExp(`^${prefixRegexStr}(${TOKEN_STRINGS}) *$`);
+  const wwwAuthenticatePrefix = options.prefix === "" ? "" : `${options.prefix} `;
+  const throwHTTPException = async (c, status, wwwAuthenticateHeader, messageOption) => {
+    const wwwAuthenticateHeaderValue = typeof wwwAuthenticateHeader === "function" ? await wwwAuthenticateHeader(c) : wwwAuthenticateHeader;
+    const headers = {
+      "WWW-Authenticate": typeof wwwAuthenticateHeaderValue === "string" ? wwwAuthenticateHeaderValue : `${wwwAuthenticatePrefix}${Object.entries(wwwAuthenticateHeaderValue).map(([key, value]) => `${key}="${value}"`).join(",")}`
+    };
+    const responseMessage = typeof messageOption === "function" ? await messageOption(c) : messageOption;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new import_http_exception.HTTPException(status, { res });
+  };
+  return async function bearerAuth2(c, next) {
+    const headerToken = c.req.header(options.headerName || HEADER);
+    if (!headerToken) {
+      await throwHTTPException(
+        c,
+        401,
+        options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`,
+        options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized"
+      );
+    } else {
+      const match = regexp.exec(headerToken);
+      if (!match) {
+        await throwHTTPException(
+          c,
+          400,
+          options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`,
+          options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request"
+        );
+      } else {
+        let equal = false;
+        if ("verifyToken" in options) {
+          equal = await options.verifyToken(match[1], c);
+        } else if (typeof options.token === "string") {
+          equal = await (0, import_buffer.timingSafeEqual)(options.token, match[1], options.hashFunction);
+        } else if (Array.isArray(options.token) && options.token.length > 0) {
+          for (const token of options.token) {
+            if (await (0, import_buffer.timingSafeEqual)(token, match[1], options.hashFunction)) {
+              equal = true;
+              break;
+            }
+          }
+        }
+        if (!equal) {
+          await throwHTTPException(
+            c,
+            401,
+            options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`,
+            options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized"
+          );
+        }
+      }
+    }
+    await next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bearerAuth
+});

_node_modules/hono/dist/cjs/middleware/body-limit/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var body_limit_exports = {};
+__export(body_limit_exports, {
+  bodyLimit: () => bodyLimit
+});
+module.exports = __toCommonJS(body_limit_exports);
+var import_http_exception = require("../../http-exception");
+const ERROR_MESSAGE = "Payload Too Large";
+class BodyLimitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BodyLimitError";
+  }
+}
+const bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new import_http_exception.HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+    const hasContentLength = c.req.raw.headers.has("content-length");
+    if (hasTransferEncoding && hasContentLength) {
+    }
+    if (hasContentLength && !hasTransferEncoding) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const rawReader = c.req.raw.body.getReader();
+    const reader = new ReadableStream({
+      async start(controller) {
+        try {
+          for (; ; ) {
+            const { done, value } = await rawReader.read();
+            if (done) {
+              break;
+            }
+            size += value.length;
+            if (size > maxSize) {
+              controller.error(new BodyLimitError(ERROR_MESSAGE));
+              break;
+            }
+            controller.enqueue(value);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    const requestInit = { body: reader, duplex: "half" };
+    c.req.raw = new Request(c.req.raw, requestInit);
+    await next();
+    if (c.error instanceof BodyLimitError) {
+      c.res = await onError(c);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bodyLimit
+});