@nocobase/plugin-mcp-server 2.2.16 → 2.2.18

package/dist/node_modules/hono/dist/router/trie-router/router.js

@@ -3,19 +3,11 @@ import { checkOptionalParameter } from "../../utils/url.js";
 import { Node } from "./node.js";
 var TrieRouter = class {
   name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node();
-  }
+  #node = new Node();
   add(method, path, handler) {
-    const results = checkOptionalParameter(path);
-    if (results) {
-      for (let i = 0, len = results.length; i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
-      return;
+    for (const result of checkOptionalParameter(path) || [path]) {
+      this.#node.insert(method, result, handler);
     }
-    this.#node.insert(method, path, handler);
   }
   match(method, path) {
     return this.#node.search(method, path);

package/dist/node_modules/hono/dist/router/utils.js

@@ -0,0 +1,5 @@
+// src/router/utils.ts
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+export {
+  createNullObject
+};

package/dist/node_modules/hono/dist/router.js

@@ -1,7 +1,7 @@
 // src/router.ts
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
 var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
 var UnsupportedPathError = class extends Error {
 };

package/dist/node_modules/hono/dist/types/adapter/aws-lambda/handler.d.ts

@@ -66,7 +66,7 @@ export interface ALBProxyEvent {
     requestContext: ALBRequestContext;
 }
 type WithHeaders = {
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     multiValueHeaders?: undefined;
 };
 type WithMultiValueHeaders = {

package/dist/node_modules/hono/dist/types/adapter/aws-lambda/types.d.ts

@@ -96,6 +96,15 @@ interface Authorizer {
         userArn: string;
         userId: string;
     };
+    jwt?: {
+        claims: Record<string, string | number | boolean | string[]>;
+        scopes: string[] | null;
+    };
+    /**
+     * The `context` object returned by a Lambda (REQUEST) authorizer.
+     * It is `null` when the authorizer returns no context.
+     */
+    lambda?: Record<string, unknown> | null;
 }
 export interface ApiGatewayRequestContextV2 {
     accountId: string;

package/dist/node_modules/hono/dist/types/adapter/bun/serve-static.d.ts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from '../../middleware/serve-static';
 import type { Env, MiddlewareHandler } from '../../types';
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/adapter/cloudflare-workers/serve-static.d.ts

@@ -2,7 +2,7 @@ import type { ServeStaticOptions as BaseServeStaticOptions } from '../../middlew
 import type { Env, MiddlewareHandler } from '../../types';
 export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E> & {
     namespace?: unknown;
-    manifest: object | string;
+    manifest?: object | string;
 };
 /**
  * @deprecated
@@ -13,4 +13,4 @@ export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E>
  * please consider using Cloudflare Pages. You can start to create the Cloudflare Pages
  * application with the `npm create hono@latest` command.
  */
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/adapter/deno/serve-static.d.ts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from '../../middleware/serve-static';
 import type { Env, MiddlewareHandler } from '../../types';
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

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

@@ -81,7 +81,7 @@ interface CloudFrontResult {
     body?: string;
     bodyEncoding?: 'text' | 'base64';
 }
-export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult>);
+export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult | CloudFrontRequest>);
 export declare const createBody: (method: string, requestBody: CloudFrontRequest["body"]) => string | Uint8Array<ArrayBuffer> | undefined;
 export declare const isContentTypeBinary: (contentType: string) => boolean;
 export {};

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

@@ -10,7 +10,7 @@ import type { HasRequiredKeys } from '../utils/types';
 type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
 /**
  * Type representing all standard HTTP methods prefixed with '$'
- * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch' | '$query'
  */
 type StandardMethods = `$${(typeof METHODS)[number]}`;
 /**

package/dist/node_modules/hono/dist/types/context.d.ts

@@ -323,6 +323,10 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   c.header('X-Message', 'Hello!')
      *   c.header('Content-Type', 'text/plain')
      *
+     *   // Append multiple headers using the append option (e.g. Vary)
+     *   c.header('Vary', 'Accept-Encoding', { append: true })
+     *   c.header('Vary', 'User-Agent', { append: true })
+     *
      *   return c.body('Thank you for coming')
      * })
      * ```

package/dist/node_modules/hono/dist/types/helper/websocket/index.d.ts

@@ -31,7 +31,7 @@ export type WSReadyState = 0 | 1 | 2 | 3;
  * An argument for WSContext class
  */
 export interface WSContextInit<T = unknown> {
-    send(data: string | ArrayBuffer | Uint8Array, options: SendOptions): void;
+    send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options: SendOptions): void;
     close(code?: number, reason?: string): void;
     raw?: T;
     readyState: WSReadyState;

package/dist/node_modules/hono/dist/types/hono-base.d.ts

@@ -65,6 +65,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
     options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
     patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
     all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
     on: OnHandlerInterface<E, S, BasePath>;
     use: MiddlewareHandlerInterface<E, S, BasePath>;
@@ -179,12 +180,12 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
      * @see {@link https://hono.dev/docs/api/hono#fetch}
      *
      * @param {Request} request - request Object of request
-     * @param {Env} Env - env Object
-     * @param {ExecutionContext} - context of execution
+     * @param {Env} env - env Object
+     * @param {ExecutionContext} executionCtx - context of execution
      * @returns {Response | Promise<Response>} response of request
      *
      */
-    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**
      * `.request()` is a useful method for testing.
      * You can pass a URL or pathname to send a GET request.

package/dist/node_modules/hono/dist/types/index.d.ts

@@ -21,7 +21,8 @@ export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundRespo
 /**
  * Types for context, context variable map, context renderer, and execution context.
  */
-export type { Context, ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
+export { Context } from './context';
+export type { ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
 /**
  * Type for HonoRequest.
  */

package/dist/node_modules/hono/dist/types/jsx/base.d.ts

@@ -3,14 +3,16 @@ import { DOM_MEMO } from './constants';
 import type { Context } from './context';
 import type { JSX as HonoJSX, IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export type Props = Record<string, any>;
+type FunctionComponentResult = HtmlEscapedString | Child[] | Promise<HtmlEscapedString | Child[]> | null;
 export type FC<P = Props> = {
-    (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null;
+    (props: P): FunctionComponentResult;
     defaultProps?: Partial<P> | undefined;
     displayName?: string | undefined;
 };
 export type DOMAttributes = HonoJSX.HTMLAttributes;
 export declare namespace JSX {
     type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+    type ElementType = string | ((props: never) => FunctionComponentResult);
     interface ElementChildrenAttribute {
         children: Child;
     }
@@ -23,7 +25,6 @@ export declare namespace JSX {
 }
 export declare const getNameSpaceContext: () => Context<string> | undefined;
 export declare const booleanAttributes: string[];
-type LocalContexts = [Context<unknown>, unknown][];
 export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
 export declare class JSXNode implements HtmlEscaped {
     tag: string | Function;
@@ -31,7 +32,6 @@ export declare class JSXNode implements HtmlEscaped {
     key?: string;
     children: Child[];
     isEscaped: true;
-    localContexts?: LocalContexts;
     constructor(tag: string | Function, props: Props, children: Child[]);
     get type(): string | Function;
     get ref(): any;
@@ -41,8 +41,8 @@ export declare class JSXNode implements HtmlEscaped {
 export declare class JSXFragmentNode extends JSXNode {
     toStringToBuffer(buffer: StringBufferWithCallbacks): void;
 }
-export declare const jsx: (tag: string | Function, props: Props | null, ...children: (string | number | HtmlEscapedString)[]) => JSXNode;
-export declare const jsxFn: (tag: string | Function, props: Props, children: (string | number | HtmlEscapedString)[]) => JSXNode;
+export declare const jsx: (tag: string | Function, props: Props | null, ...children: Child[]) => JSXNode;
+export declare const jsxFn: (tag: string | Function, props: Props, children: Child[]) => JSXNode;
 export declare const shallowEqual: (a: Props, b: Props) => boolean;
 export type MemorableFC<T> = FC<T> & {
     [DOM_MEMO]: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean;

package/dist/node_modules/hono/dist/types/jsx/context.d.ts

@@ -8,5 +8,44 @@ export interface Context<T> extends FC<PropsWithChildren<{
     }>>;
 }
 export declare const globalContexts: Context<unknown>[];
+/** Per-render context store, isolated per request so values never leak across renders. */
+type RenderStore = WeakMap<Context<unknown>, unknown[]>;
+/**
+ * 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.
+ */
+export declare const runWithRenderContext: <T>(callback: () => T, resumeStore?: RenderStore) => T;
+/**
+ * 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.
+ */
+export declare const captureRenderContext: () => (<T>(callback: () => T) => T);
+/**
+ * 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.
+ */
 export declare const createContext: <T>(defaultValue: T) => Context<T>;
+/**
+ * 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.
+ */
 export declare const useContext: <T>(context: Context<T>) => T;
+export {};

package/dist/node_modules/hono/dist/types/jsx/dom/index.d.ts

@@ -24,7 +24,7 @@ declare const _default: {
         <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
     };
     useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    useRef: <T>(initialValue: T | null) => import("..").RefObject<T>;
+    useRef: typeof useRef;
     useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
     use: <T>(promise: Promise<T>) => T;
     startTransition: (callback: () => void) => void;
@@ -38,11 +38,11 @@ declare const _default: {
     useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-    createRef: <T>() => import("..").RefObject<T>;
-    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => JSX.Element) => ((props: P & {
-        ref?: import("..").RefObject<T>;
+    createRef: <T>() => import("..").RefObject<T | null>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T | null>) => JSX.Element) => ((props: P & {
+        ref?: import("..").RefObject<T | null>;
     }) => JSX.Element);
-    useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useImperativeHandle: <T>(ref: import("..").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
     useFormStatus: () => {
         pending: false;

package/dist/node_modules/hono/dist/types/jsx/dom/intrinsic-element/components.d.ts

@@ -1,7 +1,7 @@
 import type { IntrinsicElements } from '../../intrinsic-elements';
 import type { FC, PropsWithChildren, RefObject } from '../../types';
 export declare const clearCache: () => void;
-export declare const composeRef: <T>(ref: RefObject<T> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
+export declare const composeRef: <T>(ref: RefObject<T | null> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
 export declare const title: FC<PropsWithChildren>;
 export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
 export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;
@@ -10,7 +10,7 @@ export declare const meta: FC<PropsWithChildren>;
 export declare const form: FC<PropsWithChildren<{
     action?: Function | string;
     method?: 'get' | 'post';
-    ref?: RefObject<HTMLFormElement> | ((e: HTMLFormElement | null) => void | (() => void));
+    ref?: RefObject<HTMLFormElement | null> | ((e: HTMLFormElement | null) => void | (() => void));
 }>>;
 export declare const input: FC<PropsWithChildren<IntrinsicElements['input']>>;
 export declare const button: FC<PropsWithChildren<IntrinsicElements['button']>>;

package/dist/node_modules/hono/dist/types/jsx/dom/server.d.ts

@@ -43,7 +43,7 @@ declare const _default: {
             <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
         };
         useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-        useRef: <T>(initialValue: T | null) => import("..").RefObject<T>;
+        useRef: typeof import("..").useRef;
         useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
         use: <T>(promise: Promise<T>) => T;
         startTransition: (callback: () => void) => void;
@@ -57,11 +57,11 @@ declare const _default: {
         useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
         useId: () => string;
         useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-        createRef: <T>() => import("..").RefObject<T>;
-        forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => import("./jsx-dev-runtime").JSX.Element) => ((props: P & {
-            ref?: import("..").RefObject<T>;
+        createRef: <T>() => import("..").RefObject<T | null>;
+        forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T | null>) => import("./jsx-dev-runtime").JSX.Element) => ((props: P & {
+            ref?: import("..").RefObject<T | null>;
         }) => import("./jsx-dev-runtime").JSX.Element);
-        useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+        useImperativeHandle: <T>(ref: import("..").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
         useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
         useFormStatus: () => {
             pending: false;

package/dist/node_modules/hono/dist/types/jsx/hooks/index.d.ts

@@ -29,17 +29,19 @@ export declare const useLayoutEffect: (effect: () => void | (() => void), deps?:
 export declare const useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
 export type RefObject<T> = {
-    current: T | null;
+    current: T;
 };
-export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
+export declare function useRef<T>(initialValue: T): RefObject<T>;
+export declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+export declare function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
 export declare const useId: () => string;
 export declare const useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-export declare const createRef: <T>() => RefObject<T>;
-export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T>) => JSX.Element) => ((props: P & {
-    ref?: RefObject<T>;
+export declare const createRef: <T>() => RefObject<T | null>;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX.Element) => ((props: P & {
+    ref?: RefObject<T | null>;
 }) => JSX.Element);
-export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+export declare const useImperativeHandle: <T>(ref: RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
 export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
 export {};

package/dist/node_modules/hono/dist/types/jsx/index.d.ts

@@ -23,7 +23,7 @@ declare const _default: {
         children?: import("./base").Child | import("../utils/html").HtmlEscapedString;
     }) => import("../utils/html").HtmlEscapedString;
     isValidElement: (element: unknown) => element is import("./base").JSXNode;
-    createElement: (tag: string | Function, props: import("./base").Props | null, ...children: (string | number | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
+    createElement: (tag: string | Function, props: import("./base").Props | null, ...children: import("./base").Child[]) => import("./base").JSXNode;
     cloneElement: <T extends import("./base").JSXNode | import("./base").JSX.Element>(element: T, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T;
     ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
         fallback?: import("./base").Child;
@@ -37,7 +37,7 @@ declare const _default: {
         <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
     };
     useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    useRef: <T>(initialValue: T | null) => import("./hooks").RefObject<T>;
+    useRef: typeof useRef;
     useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
     useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
     useId: () => string;
@@ -51,11 +51,11 @@ declare const _default: {
     useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
     useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    createRef: <T>() => import("./hooks").RefObject<T>;
-    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T>) => import("./base").JSX.Element) => ((props: P & {
-        ref?: import("./hooks").RefObject<T>;
+    createRef: <T>() => import("./hooks").RefObject<T | null>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T | null>) => import("./base").JSX.Element) => ((props: P & {
+        ref?: import("./hooks").RefObject<T | null>;
     }) => import("./base").JSX.Element);
-    useImperativeHandle: <T>(ref: import("./hooks").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useImperativeHandle: <T>(ref: import("./hooks").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
     useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
     useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];

package/dist/node_modules/hono/dist/types/jsx/utils.d.ts

@@ -1,2 +1,4 @@
 export declare const normalizeIntrinsicElementKey: (key: string) => string;
-export declare const styleObjectForEach: (style: Record<string, string | number>, fn: (key: string, value: string | null) => void) => void;
+export declare const isValidTagName: (name: unknown) => name is string;
+export declare const isValidAttributeName: (name: string) => boolean;
+export declare const styleObjectForEach: (style: Record<string, unknown>, fn: (key: string, value: string | null) => void) => void;

package/dist/node_modules/hono/dist/types/middleware/bearer-auth/index.d.ts

@@ -3,13 +3,13 @@
  * Bearer Auth Middleware for Hono.
  */
 import type { Context } from '../../context';
-import type { MiddlewareHandler } from '../../types';
+import type { Env, MiddlewareHandler } from '../../types';
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;
 type CustomizedErrorResponseOptions = {
     wwwAuthenticateHeader?: string | object | MessageFunction;
     message?: string | object | MessageFunction;
 };
-type BearerAuthOptions = {
+type BearerAuthOptions<E extends Env = Env> = {
     token: string | string[];
     realm?: string;
     prefix?: string;
@@ -34,7 +34,7 @@ type BearerAuthOptions = {
     realm?: string;
     prefix?: string;
     headerName?: string;
-    verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
+    verifyToken: (token: string, c: Context<E>) => boolean | Promise<boolean>;
     hashFunction?: Function;
     /**
      * @deprecated Use noAuthenticationHeader.message instead
@@ -57,6 +57,7 @@ type BearerAuthOptions = {
  *
  * @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.
@@ -70,7 +71,7 @@ type BearerAuthOptions = {
  * @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} The middleware handler function.
+ * @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.
  *
@@ -87,5 +88,5 @@ type BearerAuthOptions = {
  * })
  * ```
  */
-export declare const bearerAuth: (options: BearerAuthOptions) => MiddlewareHandler;
+export declare const bearerAuth: <E extends Env = Env>(options: BearerAuthOptions<E>) => MiddlewareHandler<E>;
 export {};

package/dist/node_modules/hono/dist/types/middleware/cache/index.d.ts

@@ -14,15 +14,17 @@ import type { StatusCode } from '../../utils/http-status';
  * @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] - 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.
+ * @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.get(
+ * app.use(
  *   '*',
  *   cache({
  *     cacheName: 'my-app',
@@ -37,5 +39,7 @@ export declare const cache: (options: {
     cacheControl?: string;
     vary?: string | string[];
     keyGenerator?: (c: Context) => Promise<string> | string;
+    maxQueryBodySize?: number;
     cacheableStatusCodes?: StatusCode[];
+    onCacheNotAvailable?: ((reason: string) => void) | false;
 }) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/middleware/combine/index.d.ts

@@ -71,7 +71,7 @@ export declare const every: (...middleware: (MiddlewareHandler | Condition)[]) =
  * @example
  * ```ts
  * import { except } from 'hono/combine'
- * import { bearerAuth } from 'hono/bearer-auth
+ * import { bearerAuth } from 'hono/bearer-auth'
  *
  * // If client is accessing public API, then skip authentication.
  * // Otherwise, require a valid token.

package/dist/node_modules/hono/dist/types/middleware/compress/index.d.ts

@@ -3,10 +3,15 @@
  * Compress Middleware for Hono.
  */
 import type { MiddlewareHandler } from '../../types';
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from '../../utils/compress';
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX };
 declare const ENCODING_TYPES: readonly ["gzip", "deflate"];
+type Encoding = (typeof ENCODING_TYPES)[number];
+type ContentTypeFilter = RegExp | ((contentType: string) => boolean);
 interface CompressionOptions {
-    encoding?: (typeof ENCODING_TYPES)[number];
+    encoding?: Encoding;
     threshold?: number;
+    contentTypeFilter?: ContentTypeFilter;
 }
 /**
  * Compress Middleware for Hono.
@@ -16,6 +21,7 @@ interface CompressionOptions {
  * @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
@@ -23,7 +29,12 @@ interface CompressionOptions {
  * 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" }))
  * ```
  */
 export declare const compress: (options?: CompressionOptions) => MiddlewareHandler;
-export {};

package/dist/node_modules/hono/dist/types/middleware/context-storage/index.d.ts

@@ -24,11 +24,11 @@ import type { Env, MiddlewareHandler } from '../../types';
  * app.use(contextStorage())
  *
  * app.use(async (c, next) => {
- *   c.set('message', 'Hono is hot!!)
+ *   c.set('message', 'Hono is hot!!')
  *   await next()
  * })
  *
- * app.get('/', async (c) => { c.text(getMessage()) })
+ * app.get('/', async (c) => c.text(getMessage()))
  *
  * const getMessage = () => {
  *   return getContext<Env>().var.message

package/dist/node_modules/hono/dist/types/middleware/cors/index.d.ts

@@ -5,7 +5,7 @@
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type CORSOptions = {
-    origin: string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null);
+    origin?: string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null);
     allowMethods?: string[] | ((origin: string, c: Context) => Promise<string[]> | string[]);
     allowHeaders?: string[];
     maxAge?: number;
@@ -19,7 +19,7 @@ type CORSOptions = {
  *
  * @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']] - The value of "Access-Control-Allow-Methods" 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.

package/dist/node_modules/hono/dist/types/middleware/jsx-renderer/index.d.ts

@@ -5,15 +5,15 @@
 import type { Context, PropsForRenderer } from '../../context';
 import type { FC, Context as JSXContext, PropsWithChildren } from '../../jsx';
 import type { Env, Input, MiddlewareHandler } from '../../types';
-import type { HtmlEscapedString } from '../../utils/html';
 export declare const RequestContext: JSXContext<Context<any, any, {}> | null>;
 type RendererOptions = {
     docType?: boolean | string;
     stream?: boolean | Record<string, string>;
 };
+type ComponentResult = Exclude<ReturnType<FC>, null>;
 type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
     Layout: FC;
-}>, c: Context) => HtmlEscapedString | Promise<HtmlEscapedString>;
+}>, c: Context) => ComponentResult;
 /**
  * JSX Renderer Middleware for hono.
  *

package/dist/node_modules/hono/dist/types/middleware/jwk/jwk.d.ts

@@ -20,6 +20,7 @@ import type { VerifyOptions } from '../../utils/jwt/jwt';
  * @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.
@@ -50,5 +51,6 @@ export declare const jwk: (options: {
     };
     headerName?: string;
     alg: AsymmetricAlgorithm[];
+    realm?: string;
     verification?: VerifyOptions;
 }, init?: RequestInit) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/middleware/jwt/jwt.d.ts

@@ -21,6 +21,7 @@ export type JwtVariables<T = any> = {
  * @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.
  *
@@ -51,6 +52,7 @@ export declare const jwt: (options: {
     };
     alg: SignatureAlgorithm;
     headerName?: string;
+    realm?: string;
     verification?: VerifyOptions;
 }) => MiddlewareHandler;
 export declare const verifyWithJwks: (token: string, options: {