hono 4.13.13 → 5.0.0-rc.1

package/dist/http-exception.js

@@ -1,48 +1,12 @@
 //#region src/http-exception.ts
-/**
-* `HTTPException` must be used when a fatal error such as authentication failure occurs.
-*
-* @see {@link https://hono.dev/docs/api/exception}
-*
-* @param {StatusCode} status - status code of HTTPException
-* @param {HTTPExceptionOptions} options - options of HTTPException
-* @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
-* @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
-* @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
-*
-* @example
-* ```ts
-* import { HTTPException } from 'hono/http-exception'
-*
-* // ...
-*
-* app.post('/auth', async (c, next) => {
-*   // authentication
-*   if (authorized === false) {
-*     throw new HTTPException(401, { message: 'Custom error message' })
-*   }
-*   await next()
-* })
-* ```
-*/
 var HTTPException = class extends Error {
 	res;
 	status;
-	/**
-	* Creates an instance of `HTTPException`.
-	* @param status - HTTP status code for the exception. Defaults to 500.
-	* @param options - Additional options for the exception.
-	*/
 	constructor(status = 500, options) {
 		super(options?.message, { cause: options?.cause });
 		this.res = options?.res;
 		this.status = status;
 	}
-	/**
-	* Returns the response object associated with the exception.
-	* If a response object is not provided, a new response is created with the error message and status code.
-	* @returns The response object.
-	*/
 	getResponse() {
 		if (this.res) return new Response(this.res.body, {
 			status: this.status,

package/dist/index.js

@@ -1,20 +1,5 @@
 import { Context } from "./context.js";
 import { Hono } from "./hono.js";
 //#region src/index.ts
-/**
-* @module
-*
-* Hono - Web Framework built on Web Standards
-*
-* @example
-* ```ts
-* import { Hono } from 'hono'
-* const app = new Hono()
-*
-* app.get('/', (c) => c.text('Hono!'))
-*
-* export default app
-* ```
-*/
 //#endregion
 export { Context, Hono };

package/dist/jsx/components.js

@@ -26,11 +26,6 @@ const resolveChildEarly = (child) => {
 		return str instanceof Promise ? str : raw(str);
 	}
 };
-/**
-* @experimental
-* `ErrorBoundary` is an experimental feature.
-* The API might be changed.
-*/
 const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
 	if (!children) return raw("");
 	if (!Array.isArray(children)) children = [children];

package/dist/jsx/context.js

@@ -75,18 +75,6 @@ const resumeWithContextValues = (callback, store, contexts) => runWithRenderCont
 		throw e;
 	}
 }, store);
-/**
-* Establish the request-scoped context store for a render.
-*
-* `resumeStore` continues a suspended subtree in the same store on the fallback
-* path (ignored when `AsyncLocalStorage` is available, where isolation is
-* automatic).
-*
-* Without `AsyncLocalStorage` a render can't be followed across `await`, so the
-* store lives in `fallbackStore` only during synchronous work (mirroring
-* React's request storage). Reading context after `await` then finds no store
-* and falls back to the default value — never another request's value.
-*/
 const runWithRenderContext = (callback, resumeStore) => {
 	if (getCurrentStore()) return callback();
 	const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
@@ -107,27 +95,11 @@ const runWithRenderContext = (callback, resumeStore) => {
 	}
 	return result;
 };
-/**
-* Capture the current render store and return a resumer that re-establishes it
-* around a deferred continuation (e.g. a re-render after a suspended promise
-* settles). Shared by every suspension point so none reimplements it.
-*/
 const captureRenderContext = () => {
 	const store = getCurrentStore();
 	const contexts = captureContextValues(store);
 	return (callback) => resumeWithContextValues(callback, store, contexts);
 };
-/**
-* Create a context whose value can be provided with `<Context.Provider>` and
-* read with {@link useContext}.
-*
-* Server-side renders are isolated per request, so a provided value never leaks
-* into a concurrent request — even across `await` in an async component, when
-* `AsyncLocalStorage` is available (Node.js >= 20.16, Deno, Bun, Cloudflare
-* Workers with `nodejs_compat`). Without it, reading context after `await`
-* returns the default value; synchronous components and `use()`-based
-* suspension are unaffected.
-*/
 const createContext = (defaultValue) => {
 	const values = [defaultValue];
 	const context = ((props) => {
@@ -152,12 +124,6 @@ const createContext = (defaultValue) => {
 	globalContexts.push(context);
 	return context;
 };
-/**
-* Read the current value of a context created with {@link createContext}.
-*
-* Safe to call from async components after `await`. See {@link createContext}
-* for the per-runtime isolation guarantees.
-*/
 const useContext = (context) => {
 	return readContextValueIn(getCurrentStore(), context);
 };

package/dist/jsx/dom/client.js

@@ -1,12 +1,6 @@
 import { buildNode, renderNode } from "./render.js";
 import { useState } from "../hooks/index.js";
 //#region src/jsx/dom/client.ts
-/**
-* Create a root object for rendering
-* @param element Render target
-* @param options Options for createRoot (not supported yet)
-* @returns Root object has `render` and `unmount` methods
-*/
 const createRoot = (element, options = {}) => {
 	let setJsxNode = void 0;
 	if (Object.keys(options).length > 0) console.warn("createRoot options are not supported yet");
@@ -29,14 +23,6 @@ const createRoot = (element, options = {}) => {
 		}
 	};
 };
-/**
-* Create a root object and hydrate app to the target element.
-* In hono/jsx/dom, hydrate is equivalent to render.
-* @param element Render target
-* @param reactNode A JSXNode to render
-* @param options Options for createRoot (not supported yet)
-* @returns Root object has `render` and `unmount` methods
-*/
 const hydrateRoot = (element, reactNode, options = {}) => {
 	const root = createRoot(element, options);
 	root.render(reactNode);

package/dist/jsx/dom/css.js

@@ -76,15 +76,6 @@ const createCssJsxDomObjects = ({ id }) => {
 	});
 	return [cssObject, Style];
 };
-/**
-* @experimental
-* `createCssContext` is an experimental feature.
-* The API might be changed.
-*
-* @param options.id - The ID for the style element
-* @param options.classNameSlug - Optional function to customize generated CSS class names
-* @param options.onInvalidSlug - Optional callback function called when an invalid slug is returned from ClassNameSlug
-*/
 const createCssContext = ({ id, classNameSlug, onInvalidSlug }) => {
 	const [cssObject, Style] = createCssJsxDomObjects({ id });
 	const newCssClassNameObject = (cssClassName) => {
@@ -111,35 +102,10 @@ const createCssContext = ({ id, classNameSlug, onInvalidSlug }) => {
 	};
 };
 const defaultContext = createCssContext({ id: DEFAULT_STYLE_ID });
-/**
-* @experimental
-* `css` is an experimental feature.
-* The API might be changed.
-*/
 const css = defaultContext.css;
-/**
-* @experimental
-* `cx` is an experimental feature.
-* The API might be changed.
-*/
 const cx = defaultContext.cx;
-/**
-* @experimental
-* `keyframes` is an experimental feature.
-* The API might be changed.
-*/
 const keyframes = defaultContext.keyframes;
-/**
-* @experimental
-* `viewTransition` is an experimental feature.
-* The API might be changed.
-*/
 const viewTransition = defaultContext.viewTransition;
-/**
-* @experimental
-* `Style` is an experimental feature.
-* The API might be changed.
-*/
 const Style = defaultContext.Style;
 //#endregion
 export { Style, createCssContext, createCssJsxDomObjects, css, cx, keyframes, rawCssString, viewTransition };

package/dist/jsx/dom/hooks/index.js

@@ -3,9 +3,6 @@ import { createContext } from "../context.js";
 import { useContext } from "../../context.js";
 import { useCallback, useState } from "../../hooks/index.js";
 //#region src/jsx/dom/hooks/index.ts
-/**
-* Provide hooks used only in jsx/dom
-*/
 const FormContext = createContext({
 	pending: false,
 	data: null,
@@ -17,20 +14,9 @@ const registerAction = (action) => {
 	actions.add(action);
 	action.finally(() => actions.delete(action));
 };
-/**
-* This hook returns the current form status
-* @returns FormStatus
-*/
 const useFormStatus = () => {
 	return useContext(FormContext);
 };
-/**
-* This hook returns the current state and a function to update the state optimistically
-* The current state is updated optimistically and then reverted to the original state when all actions are resolved
-* @param state
-* @param updateState
-* @returns [T, (action: N) => void]
-*/
 const useOptimistic = (state, updateState) => {
 	const [optimisticState, setOptimisticState] = useState(state);
 	if (actions.size > 0) Promise.all(actions).finally(() => {
@@ -41,13 +27,6 @@ const useOptimistic = (state, updateState) => {
 		setOptimisticState((currentState) => updateState(currentState, newData));
 	}, [])];
 };
-/**
-* This hook returns the current state and a function to update the state by form action
-* @param fn
-* @param initialState
-* @param permalink
-* @returns [T, (data: FormData) => void]
-*/
 const useActionState = (fn, initialState, permalink) => {
 	const [state, setState] = useState(initialState);
 	const actionState = async (data) => {

package/dist/jsx/dom/index.js

@@ -10,10 +10,6 @@ import { Fragment, jsxDEV } from "./jsx-dev-runtime.js";
 import "./jsx-runtime.js";
 import { ErrorBoundary, Suspense } from "./components.js";
 //#region src/jsx/dom/index.ts
-/**
-* @module
-* This module provides APIs for `hono/jsx/dom`.
-*/
 const createElement = (tag, props, ...children) => {
 	const jsxProps = props ? { ...props } : {};
 	if (children.length) jsxProps.children = children.length === 1 ? children[0] : children;

package/dist/jsx/dom/server.js

@@ -3,12 +3,6 @@ import { renderToReadableStream as renderToReadableStream$1 } from "../streaming
 import dom_default from "./index.js";
 //#region src/jsx/dom/server.ts
 const prepareRoot = (element) => typeof element === "string" || Array.isArray(element) ? renderChildren([element]) : element;
-/**
-* Render JSX element to string.
-* @param element JSX element to render.
-* @param options Options for rendering.
-* @returns Rendered string.
-*/
 const renderToString = (element, options = {}) => {
 	if (Object.keys(options).length > 0) console.warn("options are not supported yet");
 	element = prepareRoot(element);
@@ -16,12 +10,6 @@ const renderToString = (element, options = {}) => {
 	if (typeof res !== "string") throw new Error("Async component is not supported in renderToString");
 	return res;
 };
-/**
-* Render JSX element to readable stream.
-* @param element JSX element to render.
-* @param options Options for rendering.
-* @returns Rendered readable stream.
-*/
 const renderToReadableStream = async (element, options = {}) => {
 	if (Object.keys(options).some((key) => key !== "onError")) console.warn("options are not supported yet, except onError");
 	element = prepareRoot(element);

package/dist/jsx/index.js

@@ -6,10 +6,6 @@ import { useActionState, useOptimistic } from "./dom/hooks/index.js";
 import { Suspense } from "./streaming.js";
 import { ErrorBoundary } from "./components.js";
 //#region src/jsx/index.ts
-/**
-* @module
-* JSX for Hono.
-*/
 var jsx_default = {
 	version: reactAPICompatVersion,
 	memo,

package/dist/jsx/streaming.js

@@ -6,30 +6,9 @@ import { buildDataStack } from "./dom/render.js";
 import { Suspense as Suspense$1 } from "./dom/components.js";
 import { childrenToString } from "./components.js";
 //#region src/jsx/streaming.ts
-/**
-* @module
-* This module enables JSX to supports streaming Response.
-*/
-/**
-* Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
-*
-* @example
-* ```tsx
-* <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
-*   <Suspense fallback={<p>Loading...</p>}>
-*     <Content />
-*   </Suspense>
-* </StreamingContext.Provider>
-* ```
-*/
 const StreamingContext = createContext(null);
 let suspenseCounter = 0;
 const serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
-/**
-* @experimental
-* `Suspense` is an experimental feature.
-* The API might be changed.
-*/
 const Suspense = async ({ children, fallback }) => {
 	if (!Array.isArray(children)) children = [children];
 	const nonce = useContext(StreamingContext)?.scriptNonce;
@@ -82,11 +61,6 @@ d.replaceWith(c.content)
 };
 Suspense[DOM_RENDERER] = Suspense$1;
 const textEncoder = new TextEncoder();
-/**
-* @experimental
-* `renderToReadableStream()` is an experimental feature.
-* The API might be changed.
-*/
 const renderToReadableStream = (content, onError = console.trace) => {
 	let cancelled = false;
 	return new ReadableStream({

package/dist/{types/middleware → middleware}/basic-auth/index.d.ts

@@ -1,18 +1,19 @@
 import { MiddlewareHandler } from "../../types.js";
 import { Context } from "../../context.js";
+import { StringHashFunction } from "../../utils/buffer.js";
 //#region src/middleware/basic-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;
 type BasicAuthOptions = {
   username: string;
   password: string;
   realm?: string;
-  hashFunction?: Function;
+  hashFunction?: StringHashFunction;
   invalidUserMessage?: string | object | MessageFunction;
   onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
 } | {
   verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
   realm?: string;
-  hashFunction?: Function;
+  hashFunction?: StringHashFunction;
   invalidUserMessage?: string | object | MessageFunction;
   onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
 };
@@ -25,7 +26,7 @@ type BasicAuthOptions = {
  * @param {string} options.username - The username for authentication.
  * @param {string} options.password - The password for authentication.
  * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
- * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {StringHashFunction} [options.hashFunction] - The hash function used for secure comparison.
  * @param {Function} [options.verifyUser] - The function to verify user credentials.
  * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
  * @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.

package/dist/middleware/basic-auth/index.js

@@ -2,55 +2,6 @@ import { HTTPException } from "../../http-exception.js";
 import { timingSafeEqual } from "../../utils/buffer.js";
 import { auth } from "../../utils/basic-auth.js";
 //#region src/middleware/basic-auth/index.ts
-/**
-* Basic Auth Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/basic-auth}
-*
-* @param {BasicAuthOptions} options - The options for the basic authentication middleware.
-* @param {string} options.username - The username for authentication.
-* @param {string} options.password - The password for authentication.
-* @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
-* @param {Function} [options.hashFunction] - The hash function used for secure comparison.
-* @param {Function} [options.verifyUser] - The function to verify user credentials.
-* @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
-* @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.
-* @returns {MiddlewareHandler} The middleware handler function.
-* @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(
-*   '/auth/*',
-*   basicAuth({
-*     username: 'hono',
-*     password: 'ahotproject',
-*   })
-* )
-*
-* app.get('/auth/page', (c) => {
-*   return c.text('You are authorized')
-* })
-* ```
-*
-* @example
-* ```ts
-* // With onAuthSuccess callback
-* app.use(
-*   '/auth/*',
-*   basicAuth({
-*     username: 'hono',
-*     password: 'ahotproject',
-*     onAuthSuccess: (c, username) => {
-*       c.set('user', { name: username, role: 'admin' })
-*       console.log(`User ${username} authenticated`)
-*     },
-*   })
-* )
-* ```
-*/
 const basicAuth = (options, ...users) => {
 	const usernamePasswordInOptions = "username" in options && "password" in options;
 	const verifyUserInOptions = "verifyUser" in options;

package/dist/{types/middleware → middleware}/bearer-auth/index.d.ts

@@ -1,5 +1,6 @@
 import { Env, MiddlewareHandler } from "../../types.js";
 import { Context } from "../../context.js";
+import { StringHashFunction } from "../../utils/buffer.js";
 //#region src/middleware/bearer-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;
 type CustomizedErrorResponseOptions = {
@@ -11,42 +12,18 @@ type BearerAuthOptions<E extends Env = Env> = {
   realm?: string;
   prefix?: string;
   headerName?: string;
-  hashFunction?: Function;
-  /**
-   * @deprecated Use noAuthenticationHeader.message instead
-   */
-  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  hashFunction?: StringHashFunction;
   noAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidAuthenticationHeader.message instead
-   */
-  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
   invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidToken.message instead
-   */
-  invalidTokenMessage?: string | object | MessageFunction;
   invalidToken?: CustomizedErrorResponseOptions;
 } | {
   realm?: string;
   prefix?: string;
   headerName?: string;
   verifyToken: (token: string, c: Context<E>) => boolean | Promise<boolean>;
-  hashFunction?: Function;
-  /**
-   * @deprecated Use noAuthenticationHeader.message instead
-   */
-  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  hashFunction?: StringHashFunction;
   noAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidAuthenticationHeader.message instead
-   */
-  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
   invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidToken.message instead
-   */
-  invalidTokenMessage?: string | object | MessageFunction;
   invalidToken?: CustomizedErrorResponseOptions;
 };
 /**
@@ -61,7 +38,7 @@ type BearerAuthOptions<E extends Env = Env> = {
  * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
  * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
  * @param {string} [options.headerName=Authorization] - The header name.
- * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @param {StringHashFunction} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
  * @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
  * @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
  * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.

package/dist/middleware/bearer-auth/index.js

@@ -4,42 +4,6 @@ import { timingSafeEqual } from "../../utils/buffer.js";
 const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
 const PREFIX = "Bearer";
 const HEADER = "Authorization";
-/**
-* Bearer Auth Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
-*
-* @template E - The environment type.
-* @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
-* @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
-* @param {Function} [options.verifyToken] - The function to verify the token.
-* @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
-* @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
-* @param {string} [options.headerName=Authorization] - The header name.
-* @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
-* @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
-* @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
-* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.
-* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.wwwAuthenticateHeader="Bearer error=\"invalid_request\""] - The response header value for the WWW-Authenticate header when authentication header is invalid.
-* @param {string | object | MessageFunction} [options.invalidToken.message="Unauthorized"] - The invalid token message.
-* @param {string | object | MessageFunction} [options.invalidToken.wwwAuthenticateHeader="Bearer error=\"invalid_token\""] - The response header value for the WWW-Authenticate header when token is invalid.
-* @returns {MiddlewareHandler<E>} The middleware handler function.
-* @throws {Error} If neither "token" nor "verifyToken" options are provided.
-* @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* const token = 'honoishot'
-*
-* app.use('/api/*', bearerAuth({ token }))
-*
-* app.get('/api/page', (c) => {
-*   return c.json({ message: 'You are authorized' })
-* })
-* ```
-*/
 const bearerAuth = (options) => {
 	if (!("token" in options || "verifyToken" in options)) throw new Error("bearer auth middleware requires options for \"token\" or \"verifyToken\"");
 	if (!options.realm) options.realm = "";
@@ -66,7 +30,7 @@ const bearerAuth = (options) => {
 	};
 	return async function bearerAuth(c, next) {
 		const headerToken = c.req.header(options.headerName || HEADER);
-		if (!headerToken) await throwHTTPException(c, 401, options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`, options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized");
+		if (!headerToken) await throwHTTPException(c, 401, options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`, options.noAuthenticationHeader?.message || "Unauthorized");
 		else {
 			let tokenValue;
 			if (prefix === "") tokenValue = headerToken;
@@ -75,7 +39,7 @@ const bearerAuth = (options) => {
 				const prefixLower = prefix.toLowerCase();
 				if (headerLower.startsWith(prefixLower) && headerToken[prefix.length] === " ") tokenValue = headerToken.slice(prefix.length).trimStart();
 			}
-			if (!tokenValue || !tokenRegexp.test(tokenValue)) await throwHTTPException(c, 400, options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`, options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request");
+			if (!tokenValue || !tokenRegexp.test(tokenValue)) await throwHTTPException(c, 400, options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`, options.invalidAuthenticationHeader?.message || "Bad Request");
 			else {
 				let equal = false;
 				if ("verifyToken" in options) equal = await options.verifyToken(tokenValue, c);
@@ -86,7 +50,7 @@ const bearerAuth = (options) => {
 						break;
 					}
 				}
-				if (!equal) await throwHTTPException(c, 401, options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`, options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized");
+				if (!equal) await throwHTTPException(c, 401, options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`, options.invalidToken?.message || "Unauthorized");
 			}
 		}
 		await next();

package/dist/middleware/body-limit/index.js

@@ -1,38 +1,6 @@
 import { HTTPException } from "../../http-exception.js";
 //#region src/middleware/body-limit/index.ts
 const ERROR_MESSAGE = "Payload Too Large";
-/**
-* Body Limit Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
-*
-* @param {BodyLimitOptions} options - The options for the body limit middleware.
-* @param {number} options.maxSize - The maximum body size allowed.
-* @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.post(
-*   '/upload',
-*   bodyLimit({
-*     maxSize: 50 * 1024, // 50kb
-*     onError: (c) => {
-*       return c.text('overflow :(', 413)
-*     },
-*   }),
-*   async (c) => {
-*     const body = await c.req.parseBody()
-*     if (body['file'] instanceof File) {
-*       console.log(`Got file sized: ${body['file'].size}`)
-*     }
-*     return c.text('pass :)')
-*   }
-* )
-* ```
-*/
 const bodyLimit = (options) => {
 	const onError = options.onError || (() => {
 		const res = new Response(ERROR_MESSAGE, { status: 413 });

package/dist/middleware/cache/index.js

@@ -1,9 +1,6 @@
 import { sha256 } from "../../utils/crypto.js";
 import { cloneRawRequest } from "../../request.js";
 //#region src/middleware/cache/index.ts
-/**
-* status codes that can be cached by default.
-*/
 const defaultCacheableStatusCodes = [200];
 const defaultMaxQueryBodySize = 65536;
 const cacheKeyPath = "/.hono/cache";
@@ -69,34 +66,6 @@ const createQueryDigest = async (c, maxQueryBodySize) => {
 		return;
 	}
 };
-/**
-* Cache Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/cache}
-*
-* @param {Object} options - The options for the cache middleware.
-* @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
-* @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
-* @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
-* @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
-* @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters. QUERY keys additionally include a digest of the request content and its representation metadata.
-* @param {number} [options.maxQueryBodySize=65536] - The maximum QUERY request body size in bytes that can be cached. Larger QUERY requests bypass the cache.
-* @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
-* @param {Function | false} [options.onCacheNotAvailable] - A callback invoked with the reason when `globalThis.caches` is not available or QUERY caching cannot use Web Crypto. By default, the reason is logged to the console. Set to `false` to suppress the log, or provide a custom function.
-* @returns {MiddlewareHandler} The middleware handler function.
-* @throws {Error} If the `vary` option includes "*".
-*
-* @example
-* ```ts
-* app.use(
-*   '*',
-*   cache({
-*     cacheName: 'my-app',
-*     cacheControl: 'max-age=3600',
-*   })
-* )
-* ```
-*/
 const cache = (options) => {
 	if (!globalThis.caches) {
 		reportCacheNotAvailable(options.onCacheNotAvailable, "Cache Middleware is not enabled because caches is not defined.");