hono 4.7.11 → 4.8.0

package/dist/adapter/cloudflare-pages/handler.js

@@ -7,7 +7,8 @@ var handle = (app) => (eventContext) => {
     { ...eventContext.env, eventContext },
     {
       waitUntil: eventContext.waitUntil,
-      passThroughOnException: eventContext.passThroughOnException
+      passThroughOnException: eventContext.passThroughOnException,
+      props: {}
     }
   );
 };

package/dist/adapter/service-worker/index.js

@@ -1,5 +1,11 @@
 // src/adapter/service-worker/index.ts
 import { handle } from "./handler.js";
+var fire = (app, options = {
+  fetch: void 0
+}) => {
+  addEventListener("fetch", handle(app, options));
+};
 export {
+  fire,
   handle
 };

package/dist/cjs/adapter/cloudflare-pages/handler.js

@@ -31,7 +31,8 @@ const handle = (app) => (eventContext) => {
     { ...eventContext.env, eventContext },
     {
       waitUntil: eventContext.waitUntil,
-      passThroughOnException: eventContext.passThroughOnException
+      passThroughOnException: eventContext.passThroughOnException,
+      props: {}
     }
   );
 };

package/dist/cjs/adapter/service-worker/index.js

@@ -18,11 +18,18 @@ var __copyProps = (to, from, except, desc) => {
 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
 });

package/dist/cjs/context.js

@@ -25,11 +25,11 @@ 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 setHeaders = (headers, map = {}) => {
-  for (const key of Object.keys(map)) {
-    headers.set(key, map[key]);
-  }
-  return headers;
+const setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
 };
 class Context {
   #rawRequest;
@@ -38,15 +38,13 @@ class Context {
   #var;
   finalized = false;
   error;
-  #status = 200;
+  #status;
   #executionCtx;
-  #headers;
-  #preparedHeaders;
   #res;
-  #isFresh = true;
   #layout;
   #renderer;
   #notFoundHandler;
+  #preparedHeaders;
   #matchResult;
   #path;
   constructor(req, options) {
@@ -78,11 +76,11 @@ class Context {
     }
   }
   get res() {
-    this.#isFresh = false;
-    return this.#res ||= new Response("404 Not Found", { status: 404 });
+    return this.#res ||= new Response(null, {
+      headers: this.#preparedHeaders ??= new Headers()
+    });
   }
   set res(_res) {
-    this.#isFresh = false;
     if (this.#res && _res) {
       _res = new Response(_res.body, _res);
       for (const [k, v] of this.#res.headers.entries()) {
@@ -116,42 +114,16 @@ class Context {
     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) {
-      if (this.#headers) {
-        this.#headers.delete(name);
-      } else if (this.#preparedHeaders) {
-        delete this.#preparedHeaders[name.toLocaleLowerCase()];
-      }
-      if (this.finalized) {
-        this.res.headers.delete(name);
-      }
-      return;
-    }
-    if (options?.append) {
-      if (!this.#headers) {
-        this.#isFresh = false;
-        this.#headers = new Headers(this.#preparedHeaders);
-        this.#preparedHeaders = {};
-      }
-      this.#headers.append(name, value);
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
     } else {
-      if (this.#headers) {
-        this.#headers.set(name, value);
-      } else {
-        this.#preparedHeaders ??= {};
-        this.#preparedHeaders[name.toLowerCase()] = value;
-      }
-    }
-    if (this.finalized) {
-      if (options?.append) {
-        this.res.headers.append(name, value);
-      } else {
-        this.res.headers.set(name, value);
-      }
+      headers.set(name, value);
     }
   };
   status = (status) => {
-    this.#isFresh = false;
     this.#status = status;
   };
   set = (key, value) => {
@@ -168,94 +140,54 @@ class Context {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    if (this.#isFresh && !headers && !arg && this.#status === 200) {
-      return new Response(data, {
-        headers: this.#preparedHeaders
-      });
-    }
-    if (arg && typeof arg !== "number") {
-      const header = new Headers(arg.headers);
-      if (this.#headers) {
-        this.#headers.forEach((v, k) => {
-          if (k === "set-cookie") {
-            header.append(k, v);
-          } else {
-            header.set(k, v);
-          }
-        });
-      }
-      const headers2 = setHeaders(header, this.#preparedHeaders);
-      return new Response(data, {
-        headers: headers2,
-        status: arg.status ?? this.#status
-      });
-    }
-    const status = typeof arg === "number" ? arg : this.#status;
-    this.#preparedHeaders ??= {};
-    this.#headers ??= new Headers();
-    setHeaders(this.#headers, this.#preparedHeaders);
-    if (this.#res) {
-      this.#res.headers.forEach((v, k) => {
-        if (k === "set-cookie") {
-          this.#headers?.append(k, v);
+    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 {
-          this.#headers?.set(k, v);
+          responseHeaders.set(key, value);
         }
-      });
-      setHeaders(this.#headers, this.#preparedHeaders);
+      }
     }
-    headers ??= {};
-    for (const [k, v] of Object.entries(headers)) {
-      if (typeof v === "string") {
-        this.#headers.set(k, v);
-      } else {
-        this.#headers.delete(k);
-        for (const v2 of v) {
-          this.#headers.append(k, v2);
+    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);
+          }
         }
       }
     }
-    return new Response(data, {
-      status,
-      headers: this.#headers
-    });
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return new Response(data, { status, headers: responseHeaders });
   }
   newResponse = (...args) => this.#newResponse(...args);
-  body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
-  };
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
   text = (text, arg, headers) => {
-    if (!this.#preparedHeaders) {
-      if (this.#isFresh && !headers && !arg) {
-        return new Response(text);
-      }
-      this.#preparedHeaders = {};
-    }
-    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    if (typeof arg === "number") {
-      return this.#newResponse(text, arg, headers);
-    }
-    return this.#newResponse(text, arg);
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
+      text,
+      arg,
+      setDefaultContentType(TEXT_PLAIN, headers)
+    );
   };
   json = (object, arg, headers) => {
-    const body = JSON.stringify(object);
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "application/json";
-    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
+    return this.#newResponse(
+      JSON.stringify(object),
+      arg,
+      setDefaultContentType("application/json", headers)
+    );
   };
   html = (html, arg, headers) => {
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
-    if (typeof html === "object") {
-      return (0, import_html.resolveCallback)(html, import_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
-      });
-    }
-    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
+    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 = (location, status) => {
-    this.#headers ??= new Headers();
-    this.#headers.set("Location", String(location));
+    this.header("Location", String(location));
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {

package/dist/cjs/helper/route/index.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 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) => c.req[import_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route);
+const routePath = (c) => matchedRoutes(c)[c.req.routeIndex].path;
+const baseRoutePath = (c) => matchedRoutes(c)[c.req.routeIndex].basePath;
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c) => {
+  const routeIndex = c.req.routeIndex;
+  const cache = basePathCacheMap.get(c) || [];
+  if (typeof cache[routeIndex] === "string") {
+    return cache[routeIndex];
+  }
+  let result;
+  const rp = baseRoutePath(c);
+  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[routeIndex] = result;
+  basePathCacheMap.set(c, cache);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basePath,
+  baseRoutePath,
+  matchedRoutes,
+  routePath
+});

package/dist/cjs/helper/ssg/ssg.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 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,
@@ -34,6 +35,7 @@ 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}`)) {
@@ -110,13 +112,13 @@ const combineAfterResponseHooks = (hooks) => {
     return currentRes;
   };
 };
-const combineAfterGenerateHooks = (hooks) => {
+const combineAfterGenerateHooks = (hooks, fsModule, options) => {
   if (!Array.isArray(hooks)) {
     return hooks;
   }
   return async (result) => {
     for (const hook of hooks) {
-      await hook(result);
+      await hook(result, fsModule, options);
     }
   };
 };
@@ -218,14 +220,50 @@ const toSSG = async (app, fs, options) => {
   let result;
   const getInfoPromises = [];
   const savePromises = [];
+  const plugins = options?.plugins || [];
+  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 ?? "./static";
+    const outputDir = options?.dir ?? DEFAULT_OUTPUT_DIR;
     const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
     const combinedBeforeRequestHook = combineBeforeRequestHooks(
-      options?.beforeRequestHook || ((req) => req)
+      beforeRequestHooks.length > 0 ? beforeRequestHooks : [(req) => req]
     );
     const combinedAfterResponseHook = combineAfterResponseHooks(
-      options?.afterResponseHook || ((req) => req)
+      afterResponseHooks.length > 0 ? afterResponseHooks : [(req) => req]
     );
     const getInfoGen = fetchRoutesContent(
       app,
@@ -262,14 +300,15 @@ const toSSG = async (app, fs, options) => {
     const errorObj = error instanceof Error ? error : new Error(String(error));
     result = { success: false, files: [], error: errorObj };
   }
-  if (options?.afterGenerateHook) {
-    const combinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
-    await combinedAfterGenerateHooks(result);
+  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,

package/dist/cjs/helper/testing/index.js

@@ -22,11 +22,11 @@ __export(testing_exports, {
 });
 module.exports = __toCommonJS(testing_exports);
 var import_client = require("../../client");
-const testClient = (app, Env, executionCtx) => {
+const testClient = (app, Env, executionCtx, options) => {
   const customFetch = (input, init) => {
     return app.request(input, init, Env, executionCtx);
   };
-  return (0, import_client.hc)("http://localhost", { fetch: customFetch });
+  return (0, import_client.hc)("http://localhost", { ...options, fetch: customFetch });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/hono-base.js

@@ -181,7 +181,7 @@ class Hono {
   #addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);
-    const r = { path, method, handler };
+    const r = { basePath: this._basePath, path, method, handler };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }

package/dist/cjs/jsx/components.js

@@ -25,7 +25,9 @@ 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 {
@@ -46,6 +48,7 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
   if (!Array.isArray(children)) {
     children = [children];
   }
+  const nonce = (0, import_context.useContext)(import_streaming.StreamingContext)?.scriptNonce;
   let fallbackStr;
   const fallbackRes = (error) => {
     onError?.(error);
@@ -102,7 +105,7 @@ d.replaceWith(c.content)
           }
           htmlArray = htmlArray.flat();
           const content = htmlArray.join("");
-          let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script>
+          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}')

package/dist/cjs/jsx/streaming.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var streaming_exports = {};
 __export(streaming_exports, {
+  StreamingContext: () => StreamingContext,
   Suspense: () => Suspense,
   renderToReadableStream: () => renderToReadableStream
 });
@@ -27,8 +28,10 @@ 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,
@@ -40,6 +43,7 @@ const Suspense = async ({
   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) => {
@@ -85,7 +89,7 @@ const Suspense = async ({
               content
             );
           }
-          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script>
+          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}')
@@ -161,6 +165,7 @@ const renderToReadableStream = (content, onError = console.trace) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  StreamingContext,
   Suspense,
   renderToReadableStream
 });

package/dist/cjs/middleware/cache/index.js

@@ -21,6 +21,7 @@ __export(cache_exports, {
   cache: () => cache
 });
 module.exports = __toCommonJS(cache_exports);
+const defaultCacheableStatusCodes = [200];
 const cache = (options) => {
   if (!globalThis.caches) {
     console.log("Cache Middleware is not enabled because caches is not defined.");
@@ -36,6 +37,9 @@ const cache = (options) => {
       'Middleware vary configuration cannot include "*", as it disallows effective caching.'
     );
   }
+  const cacheableStatusCodes = new Set(
+    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
+  );
   const addHeader = (c) => {
     if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
@@ -73,7 +77,7 @@ const cache = (options) => {
       return new Response(response.body, response);
     }
     await next();
-    if (!c.res.ok) {
+    if (!cacheableStatusCodes.has(c.res.status)) {
       return;
     }
     addHeader(c);

package/dist/cjs/middleware/cors/index.js

@@ -45,6 +45,15 @@ const cors = (options) => {
       return (origin) => optsOrigin.includes(origin) ? origin : null;
     }
   })(opts.origin);
+  const findAllowMethods = ((optsAllowMethods) => {
+    if (typeof optsAllowMethods === "function") {
+      return optsAllowMethods;
+    } else if (Array.isArray(optsAllowMethods)) {
+      return () => optsAllowMethods;
+    } else {
+      return () => [];
+    }
+  })(opts.allowMethods);
   return async function cors2(c, next) {
     function set(key, value) {
       c.res.headers.set(key, value);
@@ -71,8 +80,9 @@ const cors = (options) => {
       if (opts.maxAge != null) {
         set("Access-Control-Max-Age", opts.maxAge.toString());
       }
-      if (opts.allowMethods?.length) {
-        set("Access-Control-Allow-Methods", opts.allowMethods.join(","));
+      const allowMethods = findAllowMethods(c.req.header("origin") || "", c);
+      if (allowMethods.length) {
+        set("Access-Control-Allow-Methods", allowMethods.join(","));
       }
       let headers = opts.allowHeaders;
       if (!headers?.length) {

package/dist/cjs/middleware/jwk/jwk.js

@@ -73,6 +73,9 @@ const jwk = (options, init) => {
       }
     }
     if (!token) {
+      if (options.allow_anon) {
+        return next();
+      }
       const errDescription = "no authorization included in request";
       throw new import_http_exception.HTTPException(401, {
         message: errDescription,
@@ -86,7 +89,9 @@ const jwk = (options, init) => {
     let payload;
     let cause;
     try {
-      payload = await import_jwt.Jwt.verifyFromJwks(token, options, init);
+      const keys = typeof options.keys === "function" ? await options.keys(ctx) : options.keys;
+      const jwks_uri = typeof options.jwks_uri === "function" ? await options.jwks_uri(ctx) : options.jwks_uri;
+      payload = await import_jwt.Jwt.verifyFromJwks(token, { keys, jwks_uri }, init);
     } catch (e) {
       cause = e;
     }

package/dist/cjs/middleware/jwt/jwt.js

@@ -36,7 +36,8 @@ const jwt = (options) => {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
   return async function jwt2(ctx, next) {
-    const credentials = ctx.req.raw.headers.get("Authorization");
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
     let token;
     if (credentials) {
       const parts = credentials.split(/\s+/);

package/dist/cjs/middleware/logger/index.js

@@ -37,8 +37,8 @@ const time = (start) => {
   const delta = Date.now() - start;
   return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
-const colorStatus = (status) => {
-  const colorEnabled = (0, import_color.getColorEnabled)();
+const colorStatus = async (status) => {
+  const colorEnabled = await (0, import_color.getColorEnabledAsync)();
   if (colorEnabled) {
     switch (status / 100 | 0) {
       case 5:
@@ -53,18 +53,18 @@ const colorStatus = (status) => {
   }
   return `${status}`;
 };
-function log(fn, prefix, method, path, status = 0, elapsed) {
-  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`;
   fn(out);
 }
 const logger = (fn = console.log) => {
   return async function logger2(c, next) {
     const { method, url } = c.req;
     const path = url.slice(url.indexOf("/", 8));
-    log(fn, "<--" /* Incoming */, method, path);
+    await log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();
-    log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
+    await log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
   };
 };
 // Annotate the CommonJS export names for ESM import in node: