hono 4.6.20 → 4.7.1

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
+};

package/dist/middleware/language/language.js

@@ -0,0 +1,178 @@
+// src/middleware/language/language.ts
+import { setCookie, getCookie } from "../../helper/cookie/index.js";
+import { parseAccept } from "../../utils/accept.js";
+var 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 parseAccept(header).map(({ type, q }) => ({ lang: type, q }));
+}
+var 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;
+  }
+};
+var detectFromQuery = (c, options) => {
+  try {
+    const query = c.req.query(options.lookupQueryString);
+    return normalizeLanguage(query, options);
+  } catch {
+    return void 0;
+  }
+};
+var detectFromCookie = (c, options) => {
+  try {
+    const 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;
+  }
+}
+var 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 {
+    setCookie(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+var 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;
+};
+var 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();
+  };
+};
+export {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+};

package/dist/middleware/logger/index.js

@@ -1,6 +1,5 @@
 // src/middleware/logger/index.ts
 import { getColorEnabled } from "../../utils/color.js";
-import { getPath } from "../../utils/url.js";
 var humanize = (times) => {
   const [delimiter, separator] = [",", "."];
   const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
@@ -32,8 +31,8 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
 }
 var logger = (fn = console.log) => {
   return async function logger2(c, next) {
-    const { method } = c.req;
-    const path = 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/request.js

@@ -45,7 +45,7 @@ var HonoRequest = class {
   }
   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/router/linear-router/router.js

@@ -66,7 +66,9 @@ var LinearRouter = class {
                 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/router/trie-router/node.js

@@ -25,21 +25,23 @@ var Node = class {
     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 = getPattern(p);
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern2 = getPattern(p, nextP);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.#children[p] = new Node();
-      const pattern = 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 = {
@@ -78,6 +80,7 @@ var Node = class {
     const curNode = this;
     let curNodes = [curNode];
     const parts = splitPath(path);
+    const curNodesQueue = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const part = parts[i];
       const isLast = i === len - 1;
@@ -105,6 +108,7 @@ var Node = class {
             const astNode = node.#children["*"];
             if (astNode) {
               handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
               tempNodes.push(astNode);
             }
             continue;
@@ -115,10 +119,19 @@ var Node = class {
           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;
@@ -136,7 +149,7 @@ var Node = class {
           }
         }
       }
-      curNodes = tempNodes;
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
     }
     if (handlerSets.length > 1) {
       handlerSets.sort((a, b) => {

package/dist/types/adapter/cloudflare-pages/handler.d.ts

@@ -21,7 +21,7 @@ export declare function handleMiddleware<E extends Env = {}, P extends string =
     Bindings: {
         eventContext: EventContext;
     };
-}, P, I>): PagesFunction<E['Bindings']>;
+}, P, I>): PagesFunction<E["Bindings"]>;
 /**
  *
  * @description `serveStatic()` is for advanced mode:

package/dist/types/adapter/cloudflare-workers/websocket.d.ts

@@ -1,2 +1,2 @@
 import type { UpgradeWebSocket, WSEvents } from '../../helper/websocket';
-export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, 'onOpen'>>;
+export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, "onOpen">>;

package/dist/types/adapter/lambda-edge/handler.d.ts

@@ -17,7 +17,7 @@ interface CloudFrontCustomOrigin {
     sslProtocols: string[];
 }
 interface CloudFrontS3Origin {
-    authMethod: 'origin-access-identity' | 'none';
+    authMethod: "origin-access-identity" | "none";
     customHeaders: CloudFrontHeaders;
     domainName: string;
     path: string;
@@ -79,7 +79,7 @@ interface CloudFrontResult {
         }[];
     };
     body?: string;
-    bodyEncoding?: 'text' | 'base64';
+    bodyEncoding?: "text" | "base64";
 }
 export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult>);
 export declare const createBody: (method: string, requestBody: CloudFrontRequest["body"]) => string | Uint8Array | undefined;

package/dist/types/client/types.d.ts

@@ -3,7 +3,7 @@ import type { HonoBase } from '../hono-base';
 import type { Endpoint, ResponseFormat, Schema } from '../types';
 import type { StatusCode, SuccessStatusCode } from '../utils/http-status';
 import type { HasRequiredKeys } from '../utils/types';
-type HonoRequest = (typeof Hono.prototype)['request'];
+type HonoRequest = (typeof Hono.prototype)["request"];
 export type ClientRequestOptions<T = unknown> = {
     fetch?: typeof fetch | HonoRequest;
     webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
@@ -40,14 +40,13 @@ export type ClientRequest<S extends Schema> = {
     } ? {
         query: Q;
     } : {} : {}) => URL;
-} & (S['$get'] extends {
-    outputFormat: 'ws';
-} ? S['$get'] extends {
+} & (S["$get"] extends {
+    outputFormat: "ws";
+} ? S["$get"] extends {
     input: infer I;
 } ? {
     $ws: (args?: I) => WebSocket;
 } : {} : {});
-type BlankRecordToNever<T> = T extends any ? T extends null ? null : keyof T extends never ? never : T : never;
 type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
     output: infer O;
     outputFormat: infer F;
@@ -63,8 +62,8 @@ export interface ClientResponse<T, U extends number = StatusCode, F extends Resp
     url: string;
     redirect(url: string, status: number): Response;
     clone(): Response;
-    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<BlankRecordToNever<T>> : Promise<unknown>;
-    text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
+    json(): F extends "text" ? Promise<never> : F extends "json" ? Promise<T> : Promise<unknown>;
+    text(): F extends "text" ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
     blob(): Promise<Blob>;
     formData(): Promise<FormData>;
     arrayBuffer(): Promise<ArrayBuffer>;
@@ -93,7 +92,7 @@ export type InferRequestOptionsType<T> = T extends (args: any, options: infer R)
 type PathToChain<Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
     [K in P]: PathToChain<R, E, Original>;
 } : {
-    [K in Path extends '' ? 'index' : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;
+    [K in Path extends "" ? "index" : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;
 };
 export type Client<T> = T extends HonoBase<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<K, S> : never : never : never;
 export type Callback = (opts: CallbackOptions) => unknown;

package/dist/types/compose.d.ts

@@ -25,5 +25,15 @@ interface ComposeContext {
  *
  * @returns {(context: C, next?: Function) => Promise<C>} - A composed middleware function.
  */
-export declare const compose: <C extends ComposeContext, E extends Env = Env>(middleware: [[Function, unknown], unknown][] | [[Function]][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: C, next?: Function) => Promise<C>);
+export declare const compose: <C extends ComposeContext, E extends Env = Env>(middleware: [
+    [
+        Function,
+        unknown
+    ],
+    unknown
+][] | [
+    [
+        Function
+    ]
+][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: C, next?: Function) => Promise<C>);
 export {};

package/dist/types/context.d.ts

@@ -5,11 +5,11 @@ import type { ResponseHeader } from './utils/headers';
 import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from './utils/http-status';
 import type { BaseMime } from './utils/mime';
 import type { InvalidJSONValue, IsAny, JSONParsed, JSONValue, SimplifyDeepArray } from './utils/types';
-type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
+type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
 /**
- * Data type can be a string, ArrayBuffer, or ReadableStream.
+ * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
  */
-export type Data = string | ArrayBuffer | ReadableStream;
+export type Data = string | ArrayBuffer | ReadableStream | Uint8Array;
 /**
  * Interface for the execution context in a web worker or similar environment.
  */
@@ -52,7 +52,12 @@ export type Renderer = ContextRenderer extends Function ? ContextRenderer : Defa
 /**
  * Extracts the props for the renderer.
  */
-export type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
+export type PropsForRenderer = [
+    ...Required<Parameters<Renderer>>
+] extends [
+    unknown,
+    infer Props
+] ? Props : unknown;
 export type Layout<T = Record<string, any>> = (props: T) => any;
 /**
  * Interface for getting context variables.
@@ -60,7 +65,7 @@ export type Layout<T = Record<string, any>> = (props: T) => any;
  * @template E - Environment type.
  */
 interface Get<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
+    <Key extends keyof E["Variables"]>(key: Key): E["Variables"][Key];
     <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
 }
 /**
@@ -69,7 +74,7 @@ interface Get<E extends Env> {
  * @template E - Environment type.
  */
 interface Set<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
+    <Key extends keyof E["Variables"]>(key: Key, value: E["Variables"][Key]): void;
     <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
 }
 /**
@@ -83,10 +88,10 @@ interface NewResponse {
  * Interface for responding with a body.
  */
 interface BodyRespond {
-    <U extends ContentfulStatusCode>(data: Data, status?: U, headers?: HeaderRecord): Response & TypedResponse<unknown, U, 'body'>;
-    <U extends StatusCode>(data: null, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
-    <U extends ContentfulStatusCode>(data: Data, init?: ResponseOrInit<U>): Response & TypedResponse<unknown, U, 'body'>;
-    <U extends StatusCode>(data: null, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
+    <U extends ContentfulStatusCode>(data: Data, status?: U, headers?: HeaderRecord): Response & TypedResponse<unknown, U, "body">;
+    <U extends StatusCode>(data: null, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, "body">;
+    <U extends ContentfulStatusCode>(data: Data, init?: ResponseOrInit<U>): Response & TypedResponse<unknown, U, "body">;
+    <U extends StatusCode>(data: null, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, "body">;
 }
 /**
  * Interface for responding with text.
@@ -102,8 +107,8 @@ interface BodyRespond {
  * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
  */
 interface TextRespond {
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
+    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, "text">;
+    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, "text">;
 }
 /**
  * Interface for responding with JSON.
@@ -128,7 +133,7 @@ interface JSONRespond {
  *
  * @returns {Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? (JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
  */
-type JSONRespondReturn<T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T> : never, U, 'json'>;
+type JSONRespondReturn<T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T> : never, U, "json">;
 /**
  * Interface representing a function that responds with HTML content.
  *
@@ -152,7 +157,7 @@ type ContextOptions<E extends Env> = {
     /**
      * Bindings for the environment.
      */
-    env: E['Bindings'];
+    env: E["Bindings"];
     /**
      * Execution context for the request.
      */
@@ -161,18 +166,24 @@ type ContextOptions<E extends Env> = {
      * Handler for not found responses.
      */
     notFoundHandler?: NotFoundHandler<E>;
-    matchResult?: Result<[H, RouterRoute]>;
+    matchResult?: Result<[
+        H,
+        RouterRoute
+    ]>;
     path?: string;
 };
 interface SetHeadersOptions {
     append?: boolean;
 }
 interface SetHeaders {
-    (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
+    (name: "Content-Type", value?: BaseMime, options?: SetHeadersOptions): void;
     (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
     (name: string, value?: string, options?: SetHeadersOptions): void;
 }
-type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
+type ResponseHeadersInit = [
+    string,
+    string
+][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
 interface ResponseInit<T extends StatusCode = StatusCode> {
     headers?: ResponseHeadersInit;
     status?: T;
@@ -181,7 +192,6 @@ interface ResponseInit<T extends StatusCode = StatusCode> {
 type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response;
 export declare const TEXT_PLAIN = "text/plain; charset=UTF-8";
 export declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
-    #private;
     /**
      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
      *
@@ -195,7 +205,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * })
      * ```
      */
-    env: E['Bindings'];
+    env: E["Bindings"];
     finalized: boolean;
     /**
      * `.error` can get the error object from the middleware if the Handler throws an error.
@@ -223,7 +233,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     /**
      * `.req` is the instance of {@link HonoRequest}.
      */
-    get req(): HonoRequest<P, I['out']>;
+    get req(): HonoRequest<P, I["out"]>;
     /**
      * @see {@link https://hono.dev/docs/api/context#event}
      * The FetchEvent associated with the current request.
@@ -363,7 +373,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * const result = c.var.client.oneMethod()
      * ```
      */
-    get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
+    get var(): Readonly<ContextVariableMap & (IsAny<E["Variables"]> extends true ? Record<string, any> : E["Variables"])>;
     newResponse: NewResponse;
     /**
      * `.body()` can return the HTTP response.

package/dist/types/helper/accepts/accepts.d.ts

@@ -13,7 +13,6 @@ export interface acceptsConfig {
 export interface acceptsOptions extends acceptsConfig {
     match?: (accepts: Accept[], config: acceptsConfig) => string;
 }
-export declare const parseAccept: (acceptHeader: string) => Accept[];
 export declare const defaultMatch: (accepts: Accept[], config: acceptsConfig) => string;
 /**
  * Match the accept header with the given options.