hono 4.6.20 → 4.7.0

package/dist/cjs/helper/accepts/accepts.js

@@ -19,31 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var accepts_exports = {};
 __export(accepts_exports, {
   accepts: () => accepts,
-  defaultMatch: () => defaultMatch,
-  parseAccept: () => parseAccept
+  defaultMatch: () => defaultMatch
 });
 module.exports = __toCommonJS(accepts_exports);
-const parseAccept = (acceptHeader) => {
-  const accepts2 = acceptHeader.split(",");
-  return accepts2.map((accept) => {
-    const parts = accept.trim().split(";");
-    const type = parts[0];
-    const params = parts.slice(1);
-    const q = params.find((param) => param.startsWith("q="));
-    const paramsObject = params.reduce((acc, param) => {
-      const keyValue = param.split("=");
-      const key = keyValue[0].trim();
-      const value = keyValue[1].trim();
-      acc[key] = value;
-      return acc;
-    }, {});
-    return {
-      type,
-      params: paramsObject,
-      q: q ? parseFloat(q.split("=")[1]) : 1
-    };
-  });
-};
+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));
@@ -54,13 +33,12 @@ const accepts = (c, options) => {
   if (!acceptHeader) {
     return options.default;
   }
-  const accepts2 = parseAccept(acceptHeader);
+  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,
-  parseAccept
+  defaultMatch
 });

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

@@ -26,11 +26,15 @@ 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 = () => {
-    const app = new import_hono.Hono();
+  createApp = (options) => {
+    const app = new import_hono.Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
     if (this.initApp) {
       this.initApp(app);
     }

package/dist/cjs/helper/proxy/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 proxy_exports = {};
+__export(proxy_exports, {
+  proxy: () => proxy
+});
+module.exports = __toCommonJS(proxy_exports);
+const hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding"
+];
+const buildRequestInitFromRequest = (request) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers
+  };
+};
+const proxy = async (input, proxyInit) => {
+  const { raw, ...requestInit } = proxyInit ?? {};
+  const req = new Request(
+    input,
+    {
+      ...buildRequestInitFromRequest(raw),
+      ...requestInit
+    }
+  );
+  req.headers.delete("accept-encoding");
+  const res = await 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, {
+    ...res,
+    headers: resHeaders
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxy
+});

package/dist/cjs/middleware/etag/digest.js

@@ -30,7 +30,7 @@ const mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
-const generateDigest = async (stream) => {
+const generateDigest = async (stream, generator) => {
   if (!stream || !crypto || !crypto.subtle) {
     return null;
   }
@@ -41,12 +41,7 @@ const generateDigest = async (stream) => {
     if (done) {
       break;
     }
-    result = await crypto.subtle.digest(
-      {
-        name: "SHA-1"
-      },
-      mergeBuffers(result, value)
-    );
+    result = await generator(mergeBuffers(result, value));
   }
   if (!result) {
     return null;

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

@@ -37,20 +37,25 @@ function etagMatches(etag2, ifNoneMatch) {
 const etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
+  const generator = options?.generateDigest ?? ((body) => crypto.subtle.digest(
+    {
+      name: "SHA-1"
+    },
+    body
+  ));
   return async function etag2(c, next) {
     const ifNoneMatch = c.req.header("If-None-Match") ?? null;
     await next();
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await (0, import_digest.generateDigest)(res.clone().body);
+      const hash = await (0, import_digest.generateDigest)(res.clone().body, generator);
       if (hash === null) {
         return;
       }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {
-      await c.res.blob();
       c.res = new Response(null, {
         status: 304,
         statusText: "Not Modified",

package/dist/cjs/middleware/jwk/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 jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => import_jwk.jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_jwk = require("./jwk");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

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

@@ -0,0 +1,124 @@
+"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 jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_cookie = require("../../helper/cookie");
+var import_http_exception = require("../../http-exception");
+var import_jwt = require("../../utils/jwt");
+var import_context = require("../../context");
+const jwk = (options, init) => {
+  if (!options || !(options.keys || options.jwks_uri)) {
+    throw new Error('JWK auth middleware requires options for either "keys" or "jwks_uri" or both');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWK auth middleware requires it.");
+  }
+  return async function jwk2(ctx, next) {
+    const credentials = ctx.req.raw.headers.get("Authorization");
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2) {
+        const errDescription = "invalid credentials structure";
+        throw new import_http_exception.HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = (0, import_cookie.getCookie)(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await (0, import_cookie.getSignedCookie)(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await (0, import_cookie.getSignedCookie)(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new import_http_exception.HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await import_jwt.Jwt.verifyFromJwks(token, options, init);
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new import_http_exception.HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure"
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

package/dist/cjs/middleware/language/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 language_exports = {};
+__export(language_exports, {
+  detectFromCookie: () => import_language.detectFromCookie,
+  detectFromHeader: () => import_language.detectFromHeader,
+  detectFromPath: () => import_language.detectFromPath,
+  detectFromQuery: () => import_language.detectFromQuery,
+  languageDetector: () => import_language.languageDetector
+});
+module.exports = __toCommonJS(language_exports);
+var import_language = require("./language");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+});

package/dist/cjs/middleware/language/language.js

@@ -0,0 +1,210 @@
+"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 language_exports = {};
+__export(language_exports, {
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  detectFromCookie: () => detectFromCookie,
+  detectFromHeader: () => detectFromHeader,
+  detectFromPath: () => detectFromPath,
+  detectFromQuery: () => detectFromQuery,
+  detectors: () => detectors,
+  languageDetector: () => languageDetector,
+  normalizeLanguage: () => normalizeLanguage,
+  parseAcceptLanguage: () => parseAcceptLanguage,
+  validateOptions: () => validateOptions
+});
+module.exports = __toCommonJS(language_exports);
+var import_cookie = require("../../helper/cookie");
+var import_accept = require("../../utils/accept");
+const DEFAULT_OPTIONS = {
+  order: ["querystring", "cookie", "header"],
+  lookupQueryString: "lang",
+  lookupCookie: "language",
+  lookupFromHeaderKey: "accept-language",
+  lookupFromPathIndex: 0,
+  caches: ["cookie"],
+  ignoreCase: true,
+  fallbackLanguage: "en",
+  supportedLanguages: ["en"],
+  cookieOptions: {
+    sameSite: "Strict",
+    secure: true,
+    maxAge: 365 * 24 * 60 * 60,
+    httpOnly: true
+  },
+  debug: false
+};
+function parseAcceptLanguage(header) {
+  return (0, import_accept.parseAccept)(header).map(({ type, q }) => ({ lang: type, q }));
+}
+const normalizeLanguage = (lang, options) => {
+  if (!lang) {
+    return void 0;
+  }
+  try {
+    let normalizedLang = lang.trim();
+    if (options.convertDetectedLanguage) {
+      normalizedLang = options.convertDetectedLanguage(normalizedLang);
+    }
+    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+    const compSupported = options.supportedLanguages.map(
+      (l) => options.ignoreCase ? l.toLowerCase() : l
+    );
+    const matchedLang = compSupported.find((l) => l === compLang);
+    return matchedLang ? options.supportedLanguages[compSupported.indexOf(matchedLang)] : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const detectFromQuery = (c, options) => {
+  try {
+    const query = c.req.query(options.lookupQueryString);
+    return normalizeLanguage(query, options);
+  } catch {
+    return void 0;
+  }
+};
+const detectFromCookie = (c, options) => {
+  try {
+    const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
+    return normalizeLanguage(cookie, options);
+  } catch {
+    return void 0;
+  }
+};
+function detectFromHeader(c, options) {
+  try {
+    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+    if (!acceptLanguage) {
+      return void 0;
+    }
+    const languages = parseAcceptLanguage(acceptLanguage);
+    for (const { lang } of languages) {
+      const normalizedLang = normalizeLanguage(lang, options);
+      if (normalizedLang) {
+        return normalizedLang;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectFromPath(c, options) {
+  try {
+    const pathSegments = c.req.path.split("/").filter(Boolean);
+    const langSegment = pathSegments[options.lookupFromPathIndex];
+    return normalizeLanguage(langSegment, options);
+  } catch {
+    return void 0;
+  }
+}
+const detectors = {
+  querystring: detectFromQuery,
+  cookie: detectFromCookie,
+  header: detectFromHeader,
+  path: detectFromPath
+};
+function validateOptions(options) {
+  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
+    throw new Error("Fallback language must be included in supported languages");
+  }
+  if (options.lookupFromPathIndex < 0) {
+    throw new Error("Path index must be non-negative");
+  }
+  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
+    throw new Error("Invalid detector type in order array");
+  }
+}
+function cacheLanguage(c, language, options) {
+  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
+    return;
+  }
+  try {
+    (0, import_cookie.setCookie)(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+const detectLanguage = (c, options) => {
+  let detectedLang;
+  for (const detectorName of options.order) {
+    const detector = detectors[detectorName];
+    if (!detector) {
+      continue;
+    }
+    try {
+      detectedLang = detector(c, options);
+      if (detectedLang) {
+        if (options.debug) {
+          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+        }
+        break;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error in ${detectorName} detector:`, error);
+      }
+      continue;
+    }
+  }
+  const finalLang = detectedLang || options.fallbackLanguage;
+  if (detectedLang && options.caches) {
+    cacheLanguage(c, finalLang, options);
+  }
+  return finalLang;
+};
+const languageDetector = (userOptions) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions,
+    cookieOptions: {
+      ...DEFAULT_OPTIONS.cookieOptions,
+      ...userOptions.cookieOptions
+    }
+  };
+  validateOptions(options);
+  return async function languageDetector2(ctx, next) {
+    try {
+      const lang = detectLanguage(ctx, options);
+      ctx.set("language", lang);
+    } catch (error) {
+      if (options.debug) {
+        console.error("Language detection failed:", error);
+      }
+      ctx.set("language", options.fallbackLanguage);
+    }
+    await next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+});

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

@@ -22,7 +22,6 @@ __export(logger_exports, {
 });
 module.exports = __toCommonJS(logger_exports);
 var import_color = require("../../utils/color");
-var import_url = require("../../utils/url");
 var LogPrefix = /* @__PURE__ */ ((LogPrefix2) => {
   LogPrefix2["Outgoing"] = "-->";
   LogPrefix2["Incoming"] = "<--";
@@ -60,8 +59,8 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
 }
 const logger = (fn = console.log) => {
   return async function logger2(c, next) {
-    const { method } = c.req;
-    const path = (0, import_url.getPath)(c.req.raw);
+    const { method, url } = c.req;
+    const path = url.slice(url.indexOf("/", 8));
     log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();

package/dist/cjs/request.js

@@ -67,7 +67,7 @@ class HonoRequest {
   }
   header(name) {
     if (name) {
-      return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+      return this.raw.headers.get(name) ?? void 0;
     }
     const headerData = {};
     this.raw.headers.forEach((value, key) => {

package/dist/cjs/router/linear-router/router.js

@@ -88,7 +88,9 @@ class LinearRouter {
                 let value;
                 if (name.charCodeAt(name.length - 1) === 125) {
                   const openBracePos = name.indexOf("{");
-                  const pattern = name.slice(openBracePos + 1, -1);
+                  const next = parts[j + 1];
+                  const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
+                  const pattern = name.slice(openBracePos + 1, -1) + lookahead;
                   const restPath = path.slice(pos + 1);
                   const match = new RegExp(pattern, "d").exec(restPath);
                   if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {