hono 4.13.13 → 5.0.0-rc.1

package/dist/middleware/combine/index.js

@@ -3,34 +3,6 @@ import "../../router.js";
 import { TrieRouter } from "../../router/trie-router/router.js";
 import "../../router/trie-router/index.js";
 //#region src/middleware/combine/index.ts
-/**
-* @module
-* Combine Middleware for Hono.
-*/
-/**
-* Create a composed middleware that runs the first middleware that returns true.
-*
-* @param middleware - An array of MiddlewareHandler or Condition functions.
-* Middleware is applied in the order it is passed, and if any middleware exits without returning
-* an exception first, subsequent middleware will not be executed.
-* You can also pass a condition function that returns a boolean value. If returns true
-* the evaluation will be halted, and rest of the middleware will not be executed.
-* @returns A composed middleware.
-*
-* @example
-* ```ts
-* import { some } from 'hono/combine'
-* import { bearerAuth } from 'hono/bearer-auth'
-* import { myRateLimit } from '@/rate-limit'
-*
-* // If client has a valid token, then skip rate limiting.
-* // Otherwise, apply rate limiting.
-* app.use('/api/*', some(
-*   bearerAuth({ token }),
-*   myRateLimit({ limit: 100 }),
-* ));
-* ```
-*/
 const some = (...middleware) => {
 	return async function some(c, next) {
 		let isNextCalled = false;
@@ -57,34 +29,6 @@ const some = (...middleware) => {
 		return response;
 	};
 };
-/**
-* Create a composed middleware that runs all middleware and throws an error if any of them fail.
-*
-* @param middleware - An array of MiddlewareHandler or Condition functions.
-* Middleware is applied in the order it is passed, and if any middleware throws an error,
-* subsequent middleware will not be executed.
-* You can also pass a condition function that returns a boolean value. If returns false
-* the evaluation will be halted, and rest of the middleware will not be executed.
-* @returns A composed middleware.
-*
-* @example
-* ```ts
-* import { some, every } from 'hono/combine'
-* import { bearerAuth } from 'hono/bearer-auth'
-* import { myCheckLocalNetwork } from '@/check-local-network'
-* import { myRateLimit } from '@/rate-limit'
-*
-* // If client is in local network, then skip authentication and rate limiting.
-* // Otherwise, apply authentication and rate limiting.
-* app.use('/api/*', some(
-*   myCheckLocalNetwork(),
-*   every(
-*     bearerAuth({ token }),
-*     myRateLimit({ limit: 100 }),
-*   ),
-* ));
-* ```
-*/
 const every = (...middleware) => {
 	return async function every(c, next) {
 		const currentRouteIndex = c.req.routeIndex;
@@ -96,30 +40,6 @@ const every = (...middleware) => {
 		}]]))(c, next);
 	};
 };
-/**
-* Create a composed middleware that runs all middleware except when the condition is met.
-*
-* @param condition - A string or Condition function.
-* If there are multiple targets to match any of them, they can be passed as an array.
-* If a string is passed, it will be treated as a path pattern to match.
-* If a Condition function is passed, it will be evaluated against the request context.
-* @param middleware - Middleware to run when the condition is not met.
-* Multiple middleware can be passed, and they are applied in the order they are passed.
-* @returns A composed middleware.
-*
-* @example
-* ```ts
-* import { except } from 'hono/combine'
-* import { bearerAuth } from 'hono/bearer-auth'
-*
-* // If client is accessing public API, then skip authentication.
-* // Otherwise, require a valid token.
-* app.use('/api/*', except(
-*   '/api/public/*',
-*   bearerAuth({ token }),
-* ));
-* ```
-*/
 const except = (condition, ...middleware) => {
 	let router = void 0;
 	const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition) => {

package/dist/middleware/compress/index.js

@@ -20,30 +20,6 @@ const selectEncoding = (header, candidates) => {
 	return best?.encoding;
 };
 const varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i;
-/**
-* Compress Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/compress}
-*
-* @param {CompressionOptions} [options] - The options for the compress middleware.
-* @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
-* @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
-* @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(compress())
-*
-* // Compress only JSON responses
-* app.use(compress({ contentTypeFilter: /^application\/json/ }))
-*
-* // Compress based on custom Content-Type logic
-* app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
-* ```
-*/
 const compress = (options) => {
 	const threshold = options?.threshold ?? 1024;
 	const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;

package/dist/middleware/context-storage/index.js

@@ -1,41 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/middleware/context-storage/index.ts
-/**
-* @module
-* Context Storage Middleware for Hono.
-*/
 const asyncLocalStorage = new AsyncLocalStorage();
-/**
-* Context Storage Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
-*
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* type Env = {
-*   Variables: {
-*     message: string
-*   }
-* }
-*
-* const app = new Hono<Env>()
-*
-* app.use(contextStorage())
-*
-* app.use(async (c, next) => {
-*   c.set('message', 'Hono is hot!!')
-*   await next()
-* })
-*
-* app.get('/', async (c) => c.text(getMessage()))
-*
-* const getMessage = () => {
-*   return getContext<Env>().var.message
-* }
-* ```
-*/
 const contextStorage = () => {
 	return async function contextStorage(c, next) {
 		await asyncLocalStorage.run(c, next);

package/dist/middleware/cors/index.js

@@ -1,43 +1,4 @@
 //#region src/middleware/cors/index.ts
-/**
-* CORS Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/cors}
-*
-* @param {CORSOptions} [options] - The options for the CORS middleware.
-* @param {string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
-* @param {string[] | ((origin: string, c: Context) => Promise<string[]> | string[])} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH', 'QUERY']] - The value of "Access-Control-Allow-Methods" CORS header.
-* @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
-* @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
-* @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
-* @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use('/api/*', cors())
-* app.use(
-*   '/api2/*',
-*   cors({
-*     origin: 'http://example.com',
-*     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
-*     allowMethods: ['POST', 'GET', 'OPTIONS'],
-*     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
-*     maxAge: 600,
-*     credentials: true,
-*   })
-* )
-*
-* app.all('/api/abc', (c) => {
-*   return c.json({ success: true })
-* })
-* app.all('/api2/abc', (c) => {
-*   return c.json({ success: true })
-* })
-* ```
-*/
 const cors = (options) => {
 	const opts = {
 		origin: "*",

package/dist/middleware/csrf/index.js

@@ -9,68 +9,6 @@ const secFetchSiteValues = [
 const isSecFetchSite = (value) => secFetchSiteValues.includes(value);
 const isSafeMethodRe = /^(GET|HEAD|OPTIONS)$/;
 const isRequestedByFormElementRe = /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i;
-/**
-* CSRF Protection Middleware for Hono.
-*
-* Protects against Cross-Site Request Forgery attacks by validating request origins
-* and sec-fetch-site headers. The request is allowed if either validation passes.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/csrf}
-*
-* @param {CSRFOptions} [options] - The options for the CSRF protection middleware.
-* @param {string|string[]|(origin: string, context: Context) => boolean} [options.origin] -
-*   Allowed origins for requests.
-*   - string: Single allowed origin (e.g., 'https://example.com')
-*   - string[]: Multiple allowed origins
-*   - function: Custom validation logic
-*   - Default: Only same origin as the request URL
-* @param {string|string[]|(secFetchSite: string, context: Context) => boolean} [options.secFetchSite] -
-*   Sec-Fetch-Site header validation. Standard values include 'same-origin', 'same-site', 'cross-site', 'none'.
-*   - string: Single allowed value (e.g., 'same-origin')
-*   - string[]: Multiple allowed values (e.g., ['same-origin', 'same-site'])
-*   - function: Custom validation with access to context
-*   - Default: Only allows 'same-origin'
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* // Default: both origin and sec-fetch-site validation
-* app.use('*', csrf())
-*
-* // Allow specific origins
-* app.use('*', csrf({ origin: 'https://example.com' }))
-* app.use('*', csrf({ origin: ['https://app.com', 'https://api.com'] }))
-*
-* // Allow specific sec-fetch-site values
-* app.use('*', csrf({ secFetchSite: 'same-origin' }))
-* app.use('*', csrf({ secFetchSite: ['same-origin', 'same-site'] }))
-*
-* // Dynamic sec-fetch-site validation
-* app.use('*', csrf({
-*   secFetchSite: (secFetchSite, c) => {
-*     // Always allow same-origin
-*     if (secFetchSite === 'same-origin') return true
-*     // Allow cross-site for webhook endpoints
-*     if (secFetchSite === 'cross-site' && c.req.path.startsWith('/webhook/')) {
-*       return true
-*     }
-*     return false
-*   }
-* }))
-*
-* // Dynamic origin validation
-* app.use('*', csrf({
-*   origin: (origin, c) => {
-*     // Allow same origin
-*     if (origin === new URL(c.req.url).origin) return true
-*     // Allow specific trusted domains
-*     return ['https://app.example.com', 'https://admin.example.com'].includes(origin)
-*   }
-* }))
-* ```
-*/
 const csrf = (options) => {
 	const originHandler = ((optsOrigin) => {
 		if (!optsOrigin) return (origin, c) => origin === new URL(c.req.url).origin;

package/dist/middleware/etag/index.js

@@ -1,11 +1,5 @@
 import { generateDigest } from "./digest.js";
 //#region src/middleware/etag/index.ts
-/**
-* Default headers to pass through on 304 responses. From the spec:
-* > The response must not contain a body and must include the headers that
-* > would have been sent in an equivalent 200 OK response: Cache-Control,
-* > Content-Location, Date, ETag, Expires, and Vary.
-*/
 const RETAINED_304_HEADERS = [
 	"cache-control",
 	"content-location",
@@ -24,29 +18,6 @@ function initializeGenerator(generator) {
 	}
 	return generator;
 }
-/**
-* ETag Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/etag}
-*
-* @param {ETagOptions} [options] - The options for the ETag middleware.
-* @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
-* @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
-* @param {function(Uint8Array): ArrayBuffer | Promise<ArrayBuffer>} [options.generateDigest] -
-* A custom digest generation function. By default, it uses 'SHA-1'
-* This function is called with the response body as a `Uint8Array` and should return a hash as an `ArrayBuffer` or a Promise of one.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use('/etag/*', etag())
-* app.get('/etag/abc', (c) => {
-*   return c.text('Hono is hot')
-* })
-* ```
-*/
 const etag = (options) => {
 	const retainedHeaders = new Set((options?.retainedHeaders ?? RETAINED_304_HEADERS).map((header) => header.toLowerCase()));
 	const weak = options?.weak ?? false;

package/dist/middleware/ip-restriction/index.js

@@ -84,47 +84,6 @@ const buildMatcher = (rules) => {
 		return false;
 	};
 };
-/**
-* IP Restriction Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/ip-restriction}
-*
-* @param {GetConnInfo | ((c: Context) => string)} getIP - A function to retrieve the client IP address. Use `getConnInfo` from the appropriate runtime adapter.
-* @param {IPRestrictionRules} rules - An object with optional `denyList` and `allowList` arrays of IP rules. Each rule can be a static IP, a CIDR range, or a custom function.
-* @param {(remote: { addr: string; type: AddressType }, c: Context) => Response | Promise<Response>} [onError] - Optional custom handler invoked when a request is blocked. Defaults to returning a 403 Forbidden response.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* import { Hono } from 'hono'
-* import { ipRestriction } from 'hono/ip-restriction'
-* import { getConnInfo } from 'hono/cloudflare-workers'
-*
-* const app = new Hono()
-*
-* app.use(
-*   '*',
-*   ipRestriction(getConnInfo, {
-*     // Block a specific IP and an entire subnet
-*     denyList: ['192.168.0.5', '10.0.0.0/8'],
-*     // Only allow requests from localhost and a private range
-*     allowList: ['127.0.0.1', '::1', '192.168.1.0/24'],
-*   })
-* )
-*
-* // With a custom error handler
-* app.use(
-*   '/admin/*',
-*   ipRestriction(
-*     getConnInfo,
-*     { allowList: ['203.0.113.0/24'] },
-*     (remote, c) => c.text(`Access denied for ${remote.addr}`, 403)
-*   )
-* )
-*
-* app.get('/', (c) => c.text('Hello!'))
-* ```
-*/
 const ipRestriction = (getIP, { denyList = [], allowList = [] }, onError) => {
 	const allowLength = allowList.length;
 	const denyMatcher = buildMatcher(denyList);

package/dist/middleware/jsx-renderer/index.js

@@ -23,40 +23,6 @@ const createRenderer = (c, Layout, component, options) => (children, props) => {
 		return c.body(renderToReadableStream(body));
 	} else return c.html(body);
 };
-/**
-* JSX Renderer Middleware for hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/jsx-renderer}
-*
-* @param {ComponentWithChildren} [component] - The component to render, which can accept children and props.
-* @param {RendererOptions} [options] - The options for the JSX renderer middleware.
-* @param {boolean | string} [options.docType=true] - The DOCTYPE to be added at the beginning of the HTML. If set to false, no DOCTYPE will be added.
-* @param {boolean | Record<string, string>} [options.stream=false] - If set to true, enables streaming response with default headers. If a record is provided, custom headers will be used.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.get(
-*   '/page/*',
-*   jsxRenderer(({ children }) => {
-*     return (
-*       <html>
-*         <body>
-*           <header>Menu</header>
-*           <div>{children}</div>
-*         </body>
-*       </html>
-*     )
-*   })
-* )
-*
-* app.get('/page/about', (c) => {
-*   return c.render(<h1>About me!</h1>)
-* })
-* ```
-*/
 const jsxRenderer = (component, options) => function jsxRenderer(c, next) {
 	const Layout = c.getLayout() ?? Fragment;
 	if (component) c.setLayout((props) => {
@@ -68,30 +34,6 @@ const jsxRenderer = (component, options) => function jsxRenderer(c, next) {
 	c.setRenderer(createRenderer(c, Layout, component, options));
 	return next();
 };
-/**
-* useRequestContext for Hono.
-*
-* @template E - The environment type.
-* @template P - The parameter type.
-* @template I - The input type.
-* @returns {Context<E, P, I>} An instance of Context.
-*
-* @example
-* ```ts
-* const RequestUrlBadge: FC = () => {
-*   const c = useRequestContext()
-*   return <b>{c.req.url}</b>
-* }
-*
-* app.get('/page/info', (c) => {
-*   return c.render(
-*     <div>
-*       You are accessing: <RequestUrlBadge />
-*     </div>
-*   )
-* })
-* ```
-*/
 const useRequestContext = () => {
 	const c = useContext(RequestContext);
 	if (!c) throw new Error("RequestContext is not provided.");

package/dist/middleware/jwk/jwk.js

@@ -2,37 +2,6 @@ import { HTTPException } from "../../http-exception.js";
 import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
 import { Jwt } from "../../utils/jwt/index.js";
 //#region src/middleware/jwk/jwk.ts
-/**
-* JWK Auth Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/jwk}
-*
-* @param {object} options - The options for the JWK middleware.
-* @param {HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[])} [options.keys] - The public keys used for JWK verification, or a function that returns them.
-* @param {string | ((ctx: Context) => Promise<string> | string)} [options.jwks_uri] - If set to a URI string or a function that returns a URI string, attempt to fetch JWKs from it. The response must be a JSON object containing a `keys` array, which will be merged with the `keys` option.
-* @param {boolean} [options.allow_anon] - If set to `true`, the middleware allows requests without a token to proceed without authentication.
-* @param {string} [options.cookie] - If set, the middleware attempts to retrieve the token from a cookie with these options (optionally signed) only if no token is found in the header.
-* @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
-* @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
-* @param {AsymmetricAlgorithm[]} options.alg - An array of allowed asymmetric algorithms for JWT verification. Only tokens signed with these algorithms will be accepted.
-* @param {RequestInit} [init] - Optional init options for the `fetch` request when retrieving JWKS from a URI.
-* @param {VerifyOptions} [options.verification] - Additional options for JWK payload verification.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use("/auth/*", jwk({
-*   jwks_uri: (c) => `https://${c.env.authServer}/.well-known/jwks.json`,
-*   headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
-* }))
-*
-* app.get('/auth/page', (c) => {
-*   return c.text('You are authorized')
-* })
-* ```
-*/
 const jwk = (options, init) => {
 	const verifyOpts = options.verification || {};
 	if (!options || !(options.keys || options.jwks_uri)) throw new Error("JWK auth middleware requires options for either \"keys\" or \"jwks_uri\" or both");

package/dist/middleware/jwt/jwt.js

@@ -2,38 +2,6 @@ import { HTTPException } from "../../http-exception.js";
 import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
 import { Jwt } from "../../utils/jwt/index.js";
 //#region src/middleware/jwt/jwt.ts
-/**
-* JWT Auth Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/jwt}
-*
-* @param {object} options - The options for the JWT middleware.
-* @param {SignatureKey} options.secret - A value of your secret key.
-* @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
-* @param {SignatureAlgorithm} options.alg - An algorithm type that is used for verifying (required). Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
-* @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
-* @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
-* @param {VerifyOptions} [options.verification] - Additional options for JWT payload verification.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(
-*   '/auth/*',
-*   jwt({
-*     secret: 'it-is-very-secret',
-*     alg: 'HS256',
-*     headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
-*   })
-* )
-*
-* app.get('/auth/page', (c) => {
-*   return c.text('You are authorized')
-* })
-* ```
-*/
 const jwt = (options) => {
 	const verifyOpts = options.verification || {};
 	if (!options || !options.secret) throw new Error("JWT auth middleware requires options for \"secret\"");

package/dist/middleware/language/language.js

@@ -23,23 +23,12 @@ const DEFAULT_OPTIONS = {
 	},
 	debug: false
 };
-/**
-* Parse Accept-Language header values with quality scores
-* @param header Accept-Language header string
-* @returns Array of parsed languages with quality scores
-*/
 function parseAcceptLanguage(header) {
 	return parseAccept(header).map(({ type, q }) => ({
 		lang: type,
 		q
 	}));
 }
-/**
-* Validate and normalize language codes
-* @param lang Language code to normalize
-* @param options Detector options
-* @returns Normalized language code or undefined
-*/
 const normalizeLanguage = (lang, options) => {
 	if (!lang) return;
 	try {
@@ -64,23 +53,14 @@ const normalizeLanguage = (lang, options) => {
 		return;
 	}
 };
-/**
-* Detects language from query parameter
-*/
 const detectFromQuery = (c, options) => {
 	const query = c.req.query(options.lookupQueryString);
 	return normalizeLanguage(query, options);
 };
-/**
-* Detects language from cookie
-*/
 const detectFromCookie = (c, options) => {
 	const cookie = getCookie(c, options.lookupCookie);
 	return normalizeLanguage(cookie, options);
 };
-/**
-* Detects language from Accept-Language header
-*/
 function detectFromHeader(c, options) {
 	try {
 		const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
@@ -96,35 +76,21 @@ function detectFromHeader(c, options) {
 		return;
 	}
 }
-/**
-* Detects language from URL path
-*/
 function detectFromPath(c, options) {
 	const langSegment = new URL(c.req.url).pathname.split("/").filter(Boolean)[options.lookupFromPathIndex];
 	return normalizeLanguage(langSegment, options);
 }
-/**
-* Collection of all language detection strategies
-*/
 const detectors = {
 	querystring: detectFromQuery,
 	cookie: detectFromCookie,
 	header: detectFromHeader,
 	path: detectFromPath
 };
-/**
-* Validate detector options
-* @param options Detector options to validate
-* @throws Error if options are invalid
-*/
 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");
 }
-/**
-* Cache detected language
-*/
 function cacheLanguage(c, language, options) {
 	if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) return;
 	try {
@@ -133,9 +99,6 @@ function cacheLanguage(c, language, options) {
 		if (options.debug) console.error("Failed to cache language:", error);
 	}
 }
-/**
-* Detect language from request
-*/
 const detectLanguage = (c, options) => {
 	let detectedLang;
 	for (const detectorName of options.order) {
@@ -155,29 +118,6 @@ const detectLanguage = (c, options) => {
 	if (detectedLang && options.caches) cacheLanguage(c, finalLang, options);
 	return finalLang;
 };
-/**
-* Language detector middleware factory
-* @param userOptions Configuration options for the language detector
-* @returns Hono middleware function
-*
-* @example
-* ```ts
-* type Variables = LanguageVariables
-* const app = new Hono<{ Variables: Variables }>()
-*
-* app.use(
-*   languageDetector({
-*     supportedLanguages: ['en', 'ja'], // Must include fallback
-*     fallbackLanguage: 'en', // Required
-*   })
-* )
-*
-* app.get('/', (c) => {
-*   const lang = c.get('language')
-*   return c.text(`Current language: ${lang}`)
-* })
-* ```
-*/
 const languageDetector = (userOptions) => {
 	const options = {
 		...DEFAULT_OPTIONS,