@nocobase/plugin-mcp-server 2.2.20 → 2.2.22

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

@@ -1,17 +1,18 @@
-import type { Context } from '../../context';
-import type { AcceptHeader } from '../../utils/headers';
+import { AcceptHeader } from "../../utils/headers.js";
+import { Context } from "../../context.js";
+//#region src/helper/accepts/accepts.d.ts
 export interface Accept {
-    type: string;
-    params: Record<string, string>;
-    q: number;
+  type: string;
+  params: Record<string, string>;
+  q: number;
 }
 export interface acceptsConfig {
-    header: AcceptHeader;
-    supports: string[];
-    default: string;
+  header: AcceptHeader;
+  supports: string[];
+  default: string;
 }
 export interface acceptsOptions extends acceptsConfig {
-    match?: (accepts: Accept[], config: acceptsConfig) => string;
+  match?: (accepts: Accept[], config: acceptsConfig) => string;
 }
 export declare const defaultMatch: (accepts: Accept[], config: acceptsConfig) => string;
 /**
@@ -28,3 +29,4 @@ export declare const defaultMatch: (accepts: Accept[], config: acceptsConfig) =>
  * ```
  */
 export declare const accepts: (c: Context, options: acceptsOptions) => string;
+//#endregion

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

@@ -1,5 +1,2 @@
-/**
- * @module
- * Accepts Helper for Hono.
- */
-export { accepts } from './accepts';
+import { accepts } from "./accepts.js";
+export { accepts };

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

@@ -1,12 +1,10 @@
-/**
- * @module
- * Adapter Helper for Hono.
- */
-import type { Context } from '../../context';
+import { Context } from "../../context.js";
+//#region src/helper/adapter/index.d.ts
 export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'other';
 export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{
-    Bindings: T;
+  Bindings: T;
 }>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
 export declare const knownUserAgents: Partial<Record<Runtime, string>>;
 export declare const getRuntimeKey: () => Runtime;
 export declare const checkUserAgentEquals: (platform: string) => boolean;
+//#endregion

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

@@ -1,5 +1,2 @@
-/**
- * @module
- * ConnInfo Helper for Hono.
- */
-export type { AddressType, NetAddrInfo, ConnInfo, GetConnInfo } from './types';
+import { AddressType, ConnInfo, GetConnInfo, NetAddrInfo } from "./types.js";
+export type { AddressType, ConnInfo, GetConnInfo, NetAddrInfo };

package/dist/node_modules/hono/dist/types/helper/conninfo/types.d.ts

@@ -1,36 +1,38 @@
-import type { Context } from '../../context';
+import { Context } from "../../context.js";
+//#region src/helper/conninfo/types.d.ts
 export type AddressType = 'IPv6' | 'IPv4' | undefined;
 export type NetAddrInfo = {
-    /**
-     * Transport protocol type
-     */
-    transport?: 'tcp' | 'udp';
-    /**
-     * Transport port number
-     */
-    port?: number;
-    address?: string;
-    addressType?: AddressType;
+  /**
+   * Transport protocol type
+   */
+  transport?: 'tcp' | 'udp';
+  /**
+   * Transport port number
+   */
+  port?: number;
+  address?: string;
+  addressType?: AddressType;
 } & ({
-    /**
-     * Host name such as IP Addr
-     */
-    address: string;
-    /**
-     * Host name type
-     */
-    addressType: AddressType;
+  /**
+   * Host name such as IP Addr
+   */
+  address: string;
+  /**
+   * Host name type
+   */
+  addressType: AddressType;
 } | {});
 /**
  * HTTP Connection information
  */
 export interface ConnInfo {
-    /**
-     * Remote information
-     */
-    remote: NetAddrInfo;
+  /**
+   * Remote information
+   */
+  remote: NetAddrInfo;
 }
 /**
  * Helper type
  */
 export type GetConnInfo = (c: Context) => ConnInfo;
+//#endregion

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

@@ -1,18 +1,15 @@
-/**
- * @module
- * Cookie Helper for Hono.
- */
-import type { Context } from '../../context';
-import type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from '../../utils/cookie';
+import { Context } from "../../context.js";
+import { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from "../../utils/cookie.js";
+//#region src/helper/cookie/index.d.ts
 interface GetCookie {
-    (c: Context, key: string): string | undefined;
-    (c: Context): Cookie;
-    (c: Context, key: string, prefixOptions?: CookiePrefixOptions): string | undefined;
+  (c: Context, key: string): string | undefined;
+  (c: Context): Cookie;
+  (c: Context, key: string, prefixOptions?: CookiePrefixOptions): string | undefined;
 }
 interface GetSignedCookie {
-    (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
-    (c: Context, secret: string | BufferSource): Promise<SignedCookie>;
-    (c: Context, secret: string | BufferSource, key: string, prefixOptions?: CookiePrefixOptions): Promise<string | undefined | false>;
+  (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
+  (c: Context, secret: string | BufferSource): Promise<SignedCookie>;
+  (c: Context, secret: string | BufferSource, key: string, prefixOptions?: CookiePrefixOptions): Promise<string | undefined | false>;
 }
 export declare const getCookie: GetCookie;
 export declare const getSignedCookie: GetSignedCookie;
@@ -21,4 +18,5 @@ export declare const setCookie: (c: Context, name: string, value: string, opt?:
 export declare const generateSignedCookie: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
 export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
 export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;
+//#endregion
 export {};

package/dist/node_modules/hono/dist/types/helper/css/common.d.ts

@@ -1,3 +1,4 @@
+//#region src/helper/css/common.d.ts
 export declare const PSEUDO_GLOBAL_SELECTOR = ":-hono-global";
 export declare const isPseudoGlobalSelectorRe: RegExp;
 export declare const DEFAULT_STYLE_ID = "hono-css";
@@ -8,15 +9,15 @@ export declare const SELECTORS: unique symbol;
 export declare const EXTERNAL_CLASS_NAMES: unique symbol;
 declare const CSS_ESCAPED: unique symbol;
 export interface CssClassName {
-    [SELECTOR]: string;
-    [CLASS_NAME]: string;
-    [STYLE_STRING]: string;
-    [SELECTORS]: CssClassName[];
-    [EXTERNAL_CLASS_NAMES]: string[];
+  [SELECTOR]: string;
+  [CLASS_NAME]: string;
+  [STYLE_STRING]: string;
+  [SELECTORS]: CssClassName[];
+  [EXTERNAL_CLASS_NAMES]: string[];
 }
 export declare const IS_CSS_ESCAPED: unique symbol;
 interface CssEscapedString {
-    [CSS_ESCAPED]: string;
+  [CSS_ESCAPED]: string;
 }
 /**
  * @experimental
@@ -51,9 +52,10 @@ export declare const cssCommon: (strings: TemplateStringsArray, values: CssVaria
 export declare const cxCommon: (args: (string | boolean | null | undefined | CssClassName)[]) => (string | boolean | null | undefined | CssClassName)[];
 export declare const keyframesCommon: (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug) => CssClassName;
 type ViewTransitionType = {
-    (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug): CssClassName;
-    (content: CssClassName): CssClassName;
-    (): CssClassName;
+  (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug): CssClassName;
+  (content: CssClassName): CssClassName;
+  (): CssClassName;
 };
 export declare const viewTransitionCommon: ViewTransitionType;
+//#endregion
 export {};

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

@@ -1,31 +1,26 @@
-/**
- * @module
- * css Helper for Hono.
- */
-import type { HtmlEscapedString } from '../../utils/html';
-import type { ClassNameSlug, CssClassName as CssClassNameCommon, CssVariableType, OnInvalidSlug } from './common';
-export { rawCssString } from './common';
-export type { ClassNameSlug, OnInvalidSlug } from './common';
-type CssClassName = HtmlEscapedString & CssClassNameCommon;
+import { ClassNameSlug, CssClassName as CssClassName$1, CssVariableType, OnInvalidSlug, rawCssString } from "./common.js";
+import { HtmlEscapedString } from "../../utils/html.js";
+//#region src/helper/css/index.d.ts
+type CssClassName = HtmlEscapedString & CssClassName$1;
 interface CssType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
 }
 interface CxType {
-    (...args: (CssClassName | Promise<string> | string | boolean | null | undefined)[]): Promise<string>;
+  (...args: (CssClassName | Promise<string> | string | boolean | null | undefined)[]): Promise<string>;
 }
 interface KeyframesType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassNameCommon;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName$1;
 }
 interface ViewTransitionType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
-    (content: Promise<string>): Promise<string>;
-    (): Promise<string>;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
+  (content: Promise<string>): Promise<string>;
+  (): Promise<string>;
 }
 interface StyleType {
-    (args?: {
-        children?: Promise<string>;
-        nonce?: string;
-    }): HtmlEscapedString;
+  (args?: {
+    children?: Promise<string>;
+    nonce?: string;
+  }): HtmlEscapedString;
 }
 /**
  * @experimental
@@ -36,17 +31,17 @@ interface StyleType {
  * @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
  */
-export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug, }: {
-    id: Readonly<string>;
-    classNameSlug?: ClassNameSlug;
-    onInvalidSlug?: OnInvalidSlug;
+export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug }: {
+  id: Readonly<string>;
+  classNameSlug?: ClassNameSlug;
+  onInvalidSlug?: OnInvalidSlug;
 }) => DefaultContextType;
 interface DefaultContextType {
-    css: CssType;
-    cx: CxType;
-    keyframes: KeyframesType;
-    viewTransition: ViewTransitionType;
-    Style: StyleType;
+  css: CssType;
+  cx: CxType;
+  keyframes: KeyframesType;
+  viewTransition: ViewTransitionType;
+  Style: StyleType;
 }
 /**
  * @experimental
@@ -78,3 +73,6 @@ export declare const viewTransition: ViewTransitionType;
  * The API might be changed.
  */
 export declare const Style: StyleType;
+//#endregion
+export { type ClassNameSlug, type OnInvalidSlug, rawCssString };
+export {};

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

@@ -1,20 +1,18 @@
-/**
- * @module
- * Dev Helper for Hono.
- */
-import type { Hono } from '../../hono';
-import type { Env } from '../../types';
+import { Env } from "../../types.js";
+import { Hono } from "../../hono.js";
+//#region src/helper/dev/index.d.ts
 interface ShowRoutesOptions {
-    verbose?: boolean;
-    colorize?: boolean;
+  verbose?: boolean;
+  colorize?: boolean;
 }
 interface RouteData {
-    path: string;
-    method: string;
-    name: string;
-    isMiddleware: boolean;
+  path: string;
+  method: string;
+  name: string;
+  isMiddleware: boolean;
 }
 export declare const inspectRoutes: <E extends Env>(hono: Hono<E>) => RouteData[];
 export declare const showRoutes: <E extends Env>(hono: Hono<E>, opts?: ShowRoutesOptions) => void;
 export declare const getRouterName: <E extends Env>(app: Hono<E>) => string;
+//#endregion
 export {};

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

@@ -1,82 +1,35 @@
-/**
- * @module
- * Factory Helper for Hono.
- */
-import { Hono } from '../../hono';
-import type { HonoOptions } from '../../hono-base';
-import type { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from '../../types';
+import { HonoOptions } from "../../hono-base.js";
+import { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from "../../types.js";
+import { Hono } from "../../hono.js";
+//#region src/helper/factory/index.d.ts
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export interface CreateHandlersInterface<E extends Env, P extends string> {
-    <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [H<E2, P, I, R>];
-    <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>): [H<E2, P, I, R>, H<E3, P, I2, R2>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>): [
-        H<E2, P, I, R>,
-        H<E3, P, I2, R2>,
-        H<E4, P, I3, R3>,
-        H<E5, P, I4, R4>,
-        H<E6, P, I5, R5>,
-        H<E7, P, I6, R6>
-    ];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>): [
-        H<E2, P, I, R>,
-        H<E3, P, I2, R2>,
-        H<E4, P, I3, R3>,
-        H<E5, P, I4, R4>,
-        H<E6, P, I5, R5>,
-        H<E7, P, I6, R6>,
-        H<E8, P, I7, R7>
-    ];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>): [
-        H<E2, P, I, R>,
-        H<E3, P, I2, R2>,
-        H<E4, P, I3, R3>,
-        H<E5, P, I4, R4>,
-        H<E6, P, I5, R5>,
-        H<E7, P, I6, R6>,
-        H<E8, P, I7, R7>,
-        H<E9, P, I8, R8>
-    ];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, R9 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>, handler9: H<E10, P, I9, R9>): [
-        H<E2, P, I, R>,
-        H<E3, P, I2, R>,
-        H<E4, P, I3, R>,
-        H<E5, P, I4, R>,
-        H<E6, P, I5, R>,
-        H<E7, P, I6, R>,
-        H<E8, P, I7, R>,
-        H<E9, P, I8, R>,
-        H<E10, P, I9, R>
-    ];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, R9 extends HandlerResponse<any> = any, R10 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>, handler9: H<E10, P, I9, R9>, handler10: H<E11, P, I10, R10>): [
-        H<E2, P, I, R>,
-        H<E3, P, I2, R2>,
-        H<E4, P, I3, R3>,
-        H<E5, P, I4, R4>,
-        H<E6, P, I5, R5>,
-        H<E7, P, I6, R6>,
-        H<E8, P, I7, R7>,
-        H<E9, P, I8, R8>,
-        H<E10, P, I9, R9>,
-        H<E11, P, I10, R10>
-    ];
+  <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [H<E2, P, I, R>];
+  <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>): [H<E2, P, I, R>, H<E3, P, I2, R2>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>, H<E7, P, I6, R6>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>, H<E7, P, I6, R6>, H<E8, P, I7, R7>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>, H<E7, P, I6, R6>, H<E8, P, I7, R7>, H<E9, P, I8, R8>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, R9 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>, handler9: H<E10, P, I9, R9>): [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>, H<E5, P, I4, R>, H<E6, P, I5, R>, H<E7, P, I6, R>, H<E8, P, I7, R>, H<E9, P, I8, R>, H<E10, P, I9, R>];
+  <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, R extends HandlerResponse<any> = any, R2 extends HandlerResponse<any> = any, R3 extends HandlerResponse<any> = any, R4 extends HandlerResponse<any> = any, R5 extends HandlerResponse<any> = any, R6 extends HandlerResponse<any> = any, R7 extends HandlerResponse<any> = any, R8 extends HandlerResponse<any> = any, R9 extends HandlerResponse<any> = any, R10 extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R2>, handler3: H<E4, P, I3, R3>, handler4: H<E5, P, I4, R4>, handler5: H<E6, P, I5, R5>, handler6: H<E7, P, I6, R6>, handler7: H<E8, P, I7, R7>, handler8: H<E9, P, I8, R8>, handler9: H<E10, P, I9, R9>, handler10: H<E11, P, I10, R10>): [H<E2, P, I, R>, H<E3, P, I2, R2>, H<E4, P, I3, R3>, H<E5, P, I4, R4>, H<E6, P, I5, R5>, H<E7, P, I6, R6>, H<E8, P, I7, R7>, H<E9, P, I8, R8>, H<E10, P, I9, R9>, H<E11, P, I10, R10>];
 }
 export declare class Factory<E extends Env = Env, P extends string = string> {
-             
-    private initApp?;
-    constructor(init?: {
-        initApp?: InitApp<E>;
-        defaultAppOptions?: HonoOptions<E>;
-    });
-    createApp: (options?: HonoOptions<E>) => Hono<E>;
-    createMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
-    createHandlers: CreateHandlersInterface<E, P>;
-}
-export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
+  
+  private initApp?;
+  constructor(init?: {
     initApp?: InitApp<E>;
     defaultAppOptions?: HonoOptions<E>;
+  });
+  createApp: (options?: HonoOptions<E>) => Hono<E>;
+  createMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+  createHandlers: CreateHandlersInterface<E, P>;
+}
+export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
+  initApp?: InitApp<E>;
+  defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
 export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+//#endregion
 export {};

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

@@ -1,8 +1,5 @@
-/**
- * @module
- * html Helper for Hono.
- */
-import { raw } from '../../utils/html';
-import type { HtmlEscapedString } from '../../utils/html';
-export { raw };
+import { HtmlEscapedString, raw } from "../../utils/html.js";
+//#region src/helper/html/index.d.ts
 export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => HtmlEscapedString | Promise<HtmlEscapedString>;
+//#endregion
+export { raw };

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

@@ -1,33 +1,30 @@
-/**
- * @module
- * Proxy Helper for Hono.
- */
-import type { RequestHeader } from '../../utils/headers';
+import { RequestHeader } from "../../utils/headers.js";
+//#region src/helper/proxy/index.d.ts
 interface ProxyRequestInit extends Omit<RequestInit, 'headers'> {
-    raw?: Request;
-    headers?: HeadersInit | [string, string][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
-    customFetch?: (request: Request) => Promise<Response>;
-    /**
-     * Enable strict RFC 9110 compliance for Connection header processing.
-     *
-     * - `false` (default): Ignores Connection header to prevent potential
-     *   Hop-by-Hop Header Injection attacks. Recommended for untrusted clients.
-     * - `true`: Processes Connection header per RFC 9110 and removes listed headers.
-     *   Only use in trusted environments.
-     *
-     * @default false
-     * @see https://datatracker.ietf.org/doc/html/rfc9110#section-7.6.1
-     */
-    strictConnectionProcessing?: boolean;
+  raw?: Request;
+  headers?: HeadersInit | [string, string][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
+  customFetch?: (request: Request) => Promise<Response>;
+  /**
+   * Enable strict RFC 9110 compliance for Connection header processing.
+   *
+   * - `false` (default): Ignores Connection header to prevent potential
+   *   Hop-by-Hop Header Injection attacks. Recommended for untrusted clients.
+   * - `true`: Processes Connection header per RFC 9110 and removes listed headers.
+   *   Only use in trusted environments.
+   *
+   * @default false
+   * @see https://datatracker.ietf.org/doc/html/rfc9110#section-7.6.1
+   */
+  strictConnectionProcessing?: boolean;
 }
 interface ProxyFetch {
-    (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
+  (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
 }
 /**
  * Fetch API wrapper for proxy.
  * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
  *
- * The “Accept-Encoding” header is replaced with an encoding that the current runtime can handle.
+ * The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
  * Unnecessary response headers are deleted and a Response object is returned that can be returned
  * as is as a response from the handler.
  *
@@ -69,4 +66,5 @@ interface ProxyFetch {
  * ```
  */
 export declare const proxy: ProxyFetch;
+//#endregion
 export {};

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

@@ -1,5 +1,6 @@
-import type { Context } from '../../context';
-import type { RouterRoute } from '../../types';
+import { RouterRoute } from "../../types.js";
+import { Context } from "../../context.js";
+//#region src/helper/route/index.d.ts
 /**
  * Get matched routes in the handler
  *
@@ -31,7 +32,7 @@ export declare const matchedRoutes: (c: Context) => RouterRoute[];
  * Get the route path registered within the handler
  *
  * @param {Context} c - The context object
- * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
  * @returns The route path registered within the handler
  *
  * @example
@@ -54,7 +55,7 @@ export declare const routePath: (c: Context, index?: number) => string;
  * Get the basePath of the as-is route specified by routing.
  *
  * @param {Context} c - The context object
- * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
  * @returns The basePath of the as-is route specified by routing.
  *
  * @example
@@ -73,3 +74,4 @@ export declare const routePath: (c: Context, index?: number) => string;
  */
 export declare const baseRoutePath: (c: Context, index?: number) => string;
 export declare const basePath: (c: Context, index?: number) => string;
+//#endregion

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

@@ -1,7 +1,4 @@
-/**
- * @module
- * SSG Helper for Hono.
- */
-export * from './ssg';
-export { X_HONO_DISABLE_SSG_HEADER_KEY, ssgParams, isSSGContext, disableSSG, onlySSG, } from './middleware';
-export { defaultPlugin, redirectPlugin } from './plugins';
+import { AfterGenerateHook, AfterResponseHook, BeforeRequestHook, DEFAULT_OUTPUT_DIR, FileSystemModule, SSGPlugin, ToSSGAdaptorInterface, ToSSGInterface, ToSSGOptions, ToSSGResult, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, fetchRoutesContent, saveContentToFile, toSSG } from "./ssg.js";
+import { X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams } from "./middleware.js";
+import { defaultPlugin, redirectPlugin } from "./plugins.js";
+export { AfterGenerateHook, AfterResponseHook, BeforeRequestHook, DEFAULT_OUTPUT_DIR, FileSystemModule, SSGPlugin, ToSSGAdaptorInterface, ToSSGInterface, ToSSGOptions, ToSSGResult, X_HONO_DISABLE_SSG_HEADER_KEY, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, defaultPlugin, disableSSG, fetchRoutesContent, isSSGContext, onlySSG, redirectPlugin, saveContentToFile, ssgParams, toSSG };

package/dist/node_modules/hono/dist/types/helper/ssg/middleware.d.ts

@@ -1,5 +1,6 @@
-import type { Context } from '../../context';
-import type { Env, MiddlewareHandler } from '../../types';
+import { Env, MiddlewareHandler } from "../../types.js";
+import { Context } from "../../context.js";
+//#region src/helper/ssg/middleware.d.ts
 export declare const SSG_CONTEXT = "HONO_SSG_CONTEXT";
 export declare const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
 /**
@@ -9,15 +10,15 @@ export declare const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
  */
 export declare const SSG_DISABLED_RESPONSE: Response;
 interface SSGParam {
-    [key: string]: string;
+  [key: string]: string;
 }
 export type SSGParams = SSGParam[];
 interface SSGParamsMiddleware {
-    <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
-    <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
+  <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
+  <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
 }
 export type AddedSSGDataRequest = Request & {
-    ssgParams?: SSGParams;
+  ssgParams?: SSGParams;
 };
 /**
  * Define SSG Route
@@ -41,4 +42,5 @@ export declare const disableSSG: () => MiddlewareHandler;
  * The API might be changed.
  */
 export declare const onlySSG: () => MiddlewareHandler;
+//#endregion
 export {};

package/dist/node_modules/hono/dist/types/helper/ssg/plugins.d.ts

@@ -1,4 +1,5 @@
-import type { SSGPlugin } from './ssg';
+import { SSGPlugin } from "./ssg.js";
+//#region src/helper/ssg/plugins.d.ts
 /**
  * The default plugin that defines the recommended behavior.
  *
@@ -25,3 +26,4 @@ export declare const defaultPlugin: () => SSGPlugin;
  * The API might be changed.
  */
 export declare const redirectPlugin: () => SSGPlugin;
+//#endregion