hono 4.6.20 → 4.7.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;
 };

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/etag/digest.js

@@ -8,7 +8,7 @@ var mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
-var generateDigest = async (stream) => {
+var generateDigest = async (stream, generator) => {
   if (!stream || !crypto || !crypto.subtle) {
     return null;
   }
@@ -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

@@ -14,20 +14,25 @@ function etagMatches(etag2, ifNoneMatch) {
 var 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 generateDigest(res.clone().body);
+      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
+};

package/dist/middleware/jwk/jwk.js

@@ -0,0 +1,101 @@
+// src/middleware/jwk/jwk.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.js";
+import { Jwt } from "../../utils/jwt/index.js";
+import "../../context.js";
+var 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 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 = getCookie(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await getSignedCookie(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = getCookie(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await Jwt.verifyFromJwks(token, options, init);
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new 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}"`
+    }
+  });
+}
+export {
+  jwk
+};

package/dist/middleware/language/index.js

@@ -0,0 +1,15 @@
+// src/middleware/language/index.ts
+import {
+  languageDetector,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery
+} from "./language.js";
+export {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+};