hono 4.6.20 → 4.7.1

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) {

package/dist/cjs/router/trie-router/node.js

@@ -47,21 +47,23 @@ class Node {
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.#children).includes(p)) {
-        curNode = curNode.#children[p];
-        const pattern2 = (0, import_url.getPattern)(p);
+      const nextP = parts[i + 1];
+      const pattern = (0, import_url.getPattern)(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern2 = (0, import_url.getPattern)(p, nextP);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.#children[p] = new Node();
-      const pattern = (0, import_url.getPattern)(p);
+      curNode.#children[key] = new Node();
       if (pattern) {
         curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.#children[p];
+      curNode = curNode.#children[key];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
@@ -100,6 +102,7 @@ class Node {
     const curNode = this;
     let curNodes = [curNode];
     const parts = (0, import_url.splitPath)(path);
+    const curNodesQueue = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const part = parts[i];
       const isLast = i === len - 1;
@@ -127,6 +130,7 @@ class Node {
             const astNode = node.#children["*"];
             if (astNode) {
               handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
               tempNodes.push(astNode);
             }
             continue;
@@ -137,10 +141,19 @@ class Node {
           const [key, name, matcher] = pattern;
           const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp && matcher.test(restPathString)) {
-            params[name] = restPathString;
-            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-            continue;
+          if (matcher instanceof RegExp) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
           }
           if (matcher === true || matcher.test(part)) {
             params[name] = part;
@@ -158,7 +171,7 @@ class Node {
           }
         }
       }
-      curNodes = tempNodes;
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
     }
     if (handlerSets.length > 1) {
       handlerSets.sort((a, b) => {

package/dist/cjs/utils/accept.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 accept_exports = {};
+__export(accept_exports, {
+  parseAccept: () => parseAccept
+});
+module.exports = __toCommonJS(accept_exports);
+const parseAccept = (acceptHeader) => {
+  if (!acceptHeader) {
+    return [];
+  }
+  const acceptValues = acceptHeader.split(",").map((value, index) => ({ value, index }));
+  return acceptValues.map(parseAcceptValue).filter((item) => Boolean(item)).sort(sortByQualityAndIndex).map(({ type, params, q }) => ({ type, params, q }));
+};
+const parseAcceptValueRegex = /;(?=(?:(?:[^"]*"){2})*[^"]*$)/;
+const parseAcceptValue = ({ value, index }) => {
+  const parts = value.trim().split(parseAcceptValueRegex).map((s) => s.trim());
+  const type = parts[0];
+  if (!type) {
+    return null;
+  }
+  const params = parseParams(parts.slice(1));
+  const q = parseQuality(params.q);
+  return { type, params, q, index };
+};
+const parseParams = (paramParts) => {
+  return paramParts.reduce((acc, param) => {
+    const [key, val] = param.split("=").map((s) => s.trim());
+    if (key && val) {
+      acc[key] = val;
+    }
+    return acc;
+  }, {});
+};
+const parseQuality = (qVal) => {
+  if (qVal === void 0) {
+    return 1;
+  }
+  if (qVal === "") {
+    return 1;
+  }
+  if (qVal === "NaN") {
+    return 0;
+  }
+  const num = Number(qVal);
+  if (num === Infinity) {
+    return 1;
+  }
+  if (num === -Infinity) {
+    return 0;
+  }
+  if (Number.isNaN(num)) {
+    return 1;
+  }
+  if (num < 0 || num > 1) {
+    return 1;
+  }
+  return num;
+};
+const sortByQualityAndIndex = (a, b) => {
+  const qDiff = b.q - a.q;
+  if (qDiff !== 0) {
+    return qDiff;
+  }
+  return a.index - b.index;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseAccept
+});

package/dist/cjs/utils/jwt/index.js

@@ -22,7 +22,7 @@ __export(jwt_exports, {
 });
 module.exports = __toCommonJS(jwt_exports);
 var import_jwt = require("./jwt");
-const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode };
+const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode, verifyFromJwks: import_jwt.verifyFromJwks };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Jwt

package/dist/cjs/utils/jwt/jwt.js

@@ -19,9 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var jwt_exports = {};
 __export(jwt_exports, {
   decode: () => decode,
+  decodeHeader: () => decodeHeader,
   isTokenHeader: () => isTokenHeader,
   sign: () => sign,
-  verify: () => verify
+  verify: () => verify,
+  verifyFromJwks: () => verifyFromJwks
 });
 module.exports = __toCommonJS(jwt_exports);
 var import_encode = require("../../utils/encode");
@@ -41,7 +43,13 @@ function isTokenHeader(obj) {
 }
 const sign = async (payload, privateKey, alg = "HS256") => {
   const encodedPayload = encodeJwtPart(payload);
-  const encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  let encodedHeader;
+  if (typeof privateKey === "object" && "alg" in privateKey) {
+    alg = privateKey.alg;
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT", kid: privateKey.kid });
+  } else {
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  }
   const partialToken = `${encodedHeader}.${encodedPayload}`;
   const signaturePart = await (0, import_jws.signing)(privateKey, alg, import_utf8.utf8Encoder.encode(partialToken));
   const signature = encodeSignaturePart(signaturePart);
@@ -78,6 +86,41 @@ const verify = async (token, publicKey, alg = "HS256") => {
   }
   return payload;
 };
+const verifyFromJwks = async (token, options, init) => {
+  const header = decodeHeader(token);
+  if (!isTokenHeader(header)) {
+    throw new import_types.JwtHeaderInvalid(header);
+  }
+  if (!header.kid) {
+    throw new import_types.JwtHeaderRequiresKid(header);
+  }
+  let keys = typeof options.keys === "function" ? await options.keys() : options.keys;
+  if (options.jwks_uri) {
+    const response = await fetch(options.jwks_uri, init);
+    if (!response.ok) {
+      throw new Error(`failed to fetch JWKS from ${options.jwks_uri}`);
+    }
+    const data = await response.json();
+    if (!data.keys) {
+      throw new Error('invalid JWKS response. "keys" field is missing');
+    }
+    if (!Array.isArray(data.keys)) {
+      throw new Error('invalid JWKS response. "keys" field is not an array');
+    }
+    if (keys) {
+      keys.push(...data.keys);
+    } else {
+      keys = data.keys;
+    }
+  } else if (!keys) {
+    throw new Error('verifyFromJwks requires options for either "keys" or "jwks_uri" or both');
+  }
+  const matchingKey = keys.find((key) => key.kid === header.kid);
+  if (!matchingKey) {
+    throw new import_types.JwtTokenInvalid(token);
+  }
+  return await verify(token, matchingKey, matchingKey.alg);
+};
 const decode = (token) => {
   try {
     const [h, p] = token.split(".");
@@ -91,10 +134,20 @@ const decode = (token) => {
     throw new import_types.JwtTokenInvalid(token);
   }
 };
+const decodeHeader = (token) => {
+  try {
+    const [h] = token.split(".");
+    return decodeJwtPart(h);
+  } catch {
+    throw new import_types.JwtTokenInvalid(token);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   decode,
+  decodeHeader,
   isTokenHeader,
   sign,
-  verify
+  verify,
+  verifyFromJwks
 });

package/dist/cjs/utils/jwt/types.js

@@ -21,6 +21,7 @@ __export(types_exports, {
   CryptoKeyUsage: () => CryptoKeyUsage,
   JwtAlgorithmNotImplemented: () => JwtAlgorithmNotImplemented,
   JwtHeaderInvalid: () => JwtHeaderInvalid,
+  JwtHeaderRequiresKid: () => JwtHeaderRequiresKid,
   JwtTokenExpired: () => JwtTokenExpired,
   JwtTokenInvalid: () => JwtTokenInvalid,
   JwtTokenIssuedAt: () => JwtTokenIssuedAt,
@@ -64,6 +65,12 @@ class JwtHeaderInvalid extends Error {
     this.name = "JwtHeaderInvalid";
   }
 }
+class JwtHeaderRequiresKid extends Error {
+  constructor(header) {
+    super(`required "kid" in jwt header: ${JSON.stringify(header)}`);
+    this.name = "JwtHeaderRequiresKid";
+  }
+}
 class JwtTokenSignatureMismatched extends Error {
   constructor(token) {
     super(`token(${token}) signature mismatched`);
@@ -86,6 +93,7 @@ var CryptoKeyUsage = /* @__PURE__ */ ((CryptoKeyUsage2) => {
   CryptoKeyUsage,
   JwtAlgorithmNotImplemented,
   JwtHeaderInvalid,
+  JwtHeaderRequiresKid,
   JwtTokenExpired,
   JwtTokenInvalid,
   JwtTokenIssuedAt,

package/dist/cjs/utils/url.js

@@ -66,20 +66,21 @@ const replaceGroupMarks = (paths, groups) => {
   return paths;
 };
 const patternCache = {};
-const getPattern = (label) => {
+const getPattern = (label, next) => {
   if (label === "*") {
     return "*";
   }
   const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
   if (match) {
-    if (!patternCache[label]) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
       if (match[2]) {
-        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
       } else {
-        patternCache[label] = [label, match[1], true];
+        patternCache[cacheKey] = [label, match[1], true];
       }
     }
-    return patternCache[label];
+    return patternCache[cacheKey];
   }
   return null;
 };
@@ -121,27 +122,11 @@ const getPathNoStrict = (request) => {
   const result = getPath(request);
   return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
 };
-const mergePath = (...paths) => {
-  let p = "";
-  let endsWithSlash = false;
-  for (let path of paths) {
-    if (p.at(-1) === "/") {
-      p = p.slice(0, -1);
-      endsWithSlash = true;
-    }
-    if (path[0] !== "/") {
-      path = `/${path}`;
-    }
-    if (path === "/" && endsWithSlash) {
-      p = `${p}/`;
-    } else if (path !== "/") {
-      p = `${p}${path}`;
-    }
-    if (path === "/" && p === "") {
-      p = "/";
-    }
+const mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
   }
-  return p;
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
 const checkOptionalParameter = (path) => {
   if (!path.match(/\:.+\?$/)) {

package/dist/helper/accepts/accepts.js

@@ -1,25 +1,5 @@
 // src/helper/accepts/accepts.ts
-var 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
-    };
-  });
-};
+import { parseAccept } from "../../utils/accept.js";
 var defaultMatch = (accepts2, config) => {
   const { supports, default: defaultSupport } = config;
   const accept = accepts2.sort((a, b) => b.q - a.q).find((accept2) => supports.includes(accept2.type));
@@ -36,6 +16,5 @@ var accepts = (c, options) => {
 };
 export {
   accepts,
-  defaultMatch,
-  parseAccept
+  defaultMatch
 };

package/dist/helper/factory/index.js

@@ -2,11 +2,15 @@
 import { Hono } from "../../hono.js";
 var Factory = class {
   initApp;
+  #defaultAppOptions;
   constructor(init) {
     this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
   }
-  createApp = () => {
-    const app = new Hono();
+  createApp = (options) => {
+    const app = new Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
     if (this.initApp) {
       this.initApp(app);
     }

package/dist/helper/proxy/index.js

@@ -0,0 +1,52 @@
+// src/helper/proxy/index.ts
+var hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding"
+];
+var 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
+  };
+};
+var 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
+  });
+};
+export {
+  proxy
+};

package/dist/middleware/combine/index.js

@@ -4,12 +4,17 @@ import { METHOD_NAME_ALL } from "../../router.js";
 import { TrieRouter } from "../../router/trie-router/index.js";
 var some = (...middleware) => {
   return async function some2(c, next) {
+    let isNextCalled = false;
+    const wrappedNext = () => {
+      isNextCalled = true;
+      return next();
+    };
     let lastError;
     for (const handler of middleware) {
       try {
-        const result = await handler(c, next);
+        const result = await handler(c, wrappedNext);
         if (result === true && !c.finalized) {
-          await next();
+          await wrappedNext();
         } else if (result === false) {
           lastError = new Error("No successful middleware found");
           continue;
@@ -18,7 +23,9 @@ var some = (...middleware) => {
         break;
       } catch (error) {
         lastError = error;
-        continue;
+        if (isNextCalled) {
+          break;
+        }
       }
     }
     if (lastError) {

package/dist/middleware/etag/digest.js

@@ -8,8 +8,8 @@ var mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
-var generateDigest = async (stream) => {
-  if (!stream || !crypto || !crypto.subtle) {
+var generateDigest = async (stream, generator) => {
+  if (!stream) {
     return null;
   }
   let result = void 0;
@@ -19,12 +19,7 @@ var 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/middleware/etag/index.js

@@ -11,23 +11,39 @@ var RETAINED_304_HEADERS = [
 function etagMatches(etag2, ifNoneMatch) {
   return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).indexOf(etag2) > -1;
 }
+function initializeGenerator(generator) {
+  if (!generator) {
+    if (crypto && crypto.subtle) {
+      generator = (body) => crypto.subtle.digest(
+        {
+          name: "SHA-1"
+        },
+        body
+      );
+    }
+  }
+  return generator;
+}
 var etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
+  const generator = initializeGenerator(options?.generateDigest);
   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 generateDigest(res.clone().body);
+      if (!generator) {
+        return;
+      }
+      const hash = await 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/middleware/jwk/index.js

@@ -0,0 +1,5 @@
+// src/middleware/jwk/index.ts
+import { jwk } from "./jwk.js";
+export {
+  jwk
+};