@nocobase/plugin-mcp-server 2.3.0-beta.12 → 2.3.0-beta.14

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

@@ -1,68 +1,49 @@
-import type { Child, FC, JSXNode, Props } from '../base';
-import { DOM_RENDERER, DOM_STASH } from '../constants';
-import type { Context as JSXContext } from '../context';
+import { DOM_RENDERER, DOM_STASH } from "../constants.js";
+import { Context as Context$1 } from "../context.js";
+import { Child, FC, JSXNode, Props } from "../base.js";
+//#region src/jsx/dom/render.d.ts
 export type HasRenderToDom = FC<any> & {
-    [DOM_RENDERER]: FC<any>;
+  [DOM_RENDERER]: FC<any>;
 };
 export type ErrorHandler = (error: any, retry: () => void) => Child | undefined;
 type Container = HTMLElement | DocumentFragment;
-type LocalJSXContexts = [JSXContext<unknown>, unknown][] | undefined;
+type LocalJSXContexts = [Context$1<unknown>, unknown][] | undefined;
 type SupportedElement = HTMLElement | SVGElement | MathMLElement;
 export type PreserveNodeType = 1 | 2;
 export type NodeObject = {
-    pP: Props | undefined;
-    nN: Node | undefined;
-    vC: Node[];
-    pC?: Node[];
-    vR: Node[];
-    n?: string;
-    f?: boolean;
-    s?: boolean;
-    c: Container | undefined;
-    e: SupportedElement | Text | undefined;
-    p?: PreserveNodeType;
-    a?: boolean;
-    o?: NodeObject;
-    [DOM_STASH]: [
-        number,
-        any[][],
-        LocalJSXContexts,
-        [
-            Context,
-            Function,
-            NodeObject
-        ]
-    ] | [number, any[][]];
+  pP: Props | undefined;
+  nN: Node | undefined;
+  vC: Node[];
+  pC?: Node[];
+  vR: Node[];
+  n?: string;
+  f?: boolean;
+  s?: boolean;
+  c: Container | undefined;
+  e: SupportedElement | Text | undefined;
+  p?: PreserveNodeType;
+  a?: boolean;
+  o?: NodeObject;
+  [DOM_STASH]: [number, any[][], LocalJSXContexts, [Context, Function, NodeObject]] | [number, any[][]];
 } & JSXNode;
 type NodeString = {
-    t: string;
-    d: boolean;
-    s?: boolean;
+  t: string;
+  d: boolean;
+  s?: boolean;
 } & {
-    e?: Text;
-    vC: undefined;
-    nN: undefined;
-    p?: true;
-    key: undefined;
-    tag: undefined;
+  e?: Text;
+  vC: undefined;
+  nN: undefined;
+  p?: true;
+  key: undefined;
+  tag: undefined;
 };
 export type Node = NodeString | NodeObject;
 export type PendingType = 0 | 1 | 2;
 export type UpdateHook = (context: Context, node: Node, cb: (context: Context) => void) => Promise<void>;
-export type Context = [
-    PendingType,
-    boolean,
-    UpdateHook,
-    boolean,
-    boolean,
-    [
-        Context,
-        Function,
-        NodeObject
-    ][]
-] | [PendingType, boolean, UpdateHook, boolean] | [PendingType, boolean, UpdateHook] | [PendingType, boolean] | [PendingType] | [];
+export type Context = [PendingType, boolean, UpdateHook, boolean, boolean, [Context, Function, NodeObject][]] | [PendingType, boolean, UpdateHook, boolean] | [PendingType, boolean, UpdateHook] | [PendingType, boolean] | [PendingType] | [];
 export declare const buildDataStack: [Context, Node][];
-export declare const getNameSpaceContext: () => JSXContext<string> | undefined;
+export declare const getNameSpaceContext: () => Context$1<string> | undefined;
 export declare const build: (context: Context, node: NodeObject, children?: Child[]) => void;
 export declare const buildNode: (node: Child) => Node | undefined;
 export declare const update: (context: Context, node: NodeObject) => Promise<NodeObject | undefined>;
@@ -70,4 +51,5 @@ export declare const renderNode: (node: NodeObject, container: Container) => voi
 export declare const render: (jsxNode: Child, container: Container) => void;
 export declare const flushSync: (callback: () => void) => void;
 export declare const createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
+//#endregion
 export {};

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

@@ -1,11 +1,12 @@
-/**
- * @module
- * This module provides APIs for `hono/jsx/server`, which is compatible with `react-dom/server`.
- */
-import type { Child } from '../base';
-import version from './';
+import { ErrorHandler, FallbackRender } from "../components.js";
+import { RefObject, useRef } from "../hooks/index.js";
+import { PropsWithChildren } from "../types.js";
+import { Context } from "../context.js";
+import { Child, FC, JSX, JSXNode, Props } from "../base.js";
+import _default$1 from "./index.js";
+//#region src/jsx/dom/server.d.ts
 export interface RenderToStringOptions {
-    identifierPrefix?: string;
+  identifierPrefix?: string;
 }
 /**
  * Render JSX element to string.
@@ -15,15 +16,15 @@ export interface RenderToStringOptions {
  */
 declare const renderToString: (element: Child, options?: RenderToStringOptions) => string;
 export interface RenderToReadableStreamOptions {
-    identifierPrefix?: string;
-    namespaceURI?: string;
-    nonce?: string;
-    bootstrapScriptContent?: string;
-    bootstrapScripts?: string[];
-    bootstrapModules?: string[];
-    progressiveChunkSize?: number;
-    signal?: AbortSignal;
-    onError?: (error: unknown) => string | void;
+  identifierPrefix?: string;
+  namespaceURI?: string;
+  nonce?: string;
+  bootstrapScriptContent?: string;
+  bootstrapScripts?: string[];
+  bootstrapModules?: string[];
+  progressiveChunkSize?: number;
+  signal?: AbortSignal;
+  onError?: (error: unknown) => string | void;
 }
 /**
  * Render JSX element to readable stream.
@@ -32,75 +33,76 @@ export interface RenderToReadableStreamOptions {
  * @returns Rendered readable stream.
  */
 declare const renderToReadableStream: (element: Child, options?: RenderToReadableStreamOptions) => Promise<ReadableStream<Uint8Array>>;
-export { renderToString, renderToReadableStream, version };
 declare const _default: {
-    renderToString: (element: Child, options?: RenderToStringOptions) => string;
-    renderToReadableStream: (element: Child, options?: RenderToReadableStreamOptions) => Promise<ReadableStream<Uint8Array>>;
-    version: {
-        version: string;
-        useState: {
-            <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-            <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>;
-        useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
-        use: <T>(promise: Promise<T>) => T;
-        startTransition: (callback: () => void) => void;
-        useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
-        useDeferredValue: <T>(value: T, initialValue?: T) => T;
-        startViewTransition: (callback: () => void) => void;
-        useViewTransition: () => [boolean, (callback: () => void) => void];
-        useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
-        useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-        useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-        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>;
-        }) => import("./jsx-dev-runtime").JSX.Element);
-        useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
-        useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
-        useFormStatus: () => {
-            pending: false;
-            data: null;
-            method: null;
-            action: null;
-        } | {
-            pending: true;
-            data: FormData;
-            method: "get" | "post";
-            action: string | ((formData: FormData) => void | Promise<void>);
-        };
-        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];
-        Suspense: import("..").FC<import("..").PropsWithChildren<{
-            fallback: any;
-        }>>;
-        ErrorBoundary: import("..").FC<import("..").PropsWithChildren<{
-            fallback?: Child;
-            fallbackRender?: import("../components").FallbackRender;
-            onError?: import("../components").ErrorHandler;
-        }>>;
-        createContext: <T>(defaultValue: T) => import("..").Context<T>;
-        useContext: <T>(context: import("..").Context<T>) => T;
-        memo: <T>(component: import("..").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("..").FC<T>;
-        isValidElement: (element: unknown) => element is import("..").JSXNode;
-        createElement: (tag: string | ((props: import("../base").Props) => import("..").JSXNode), props: import("../base").Props | null, ...children: Child[]) => import("..").JSXNode;
-        cloneElement: <T extends import("..").JSXNode | import("./jsx-dev-runtime").JSX.Element>(element: T, props: import("../base").Props, ...children: Child[]) => T;
-        Children: {
-            map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
-            forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
-            count: (children: Child[]) => number;
-            only: (_children: Child[]) => Child;
-            toArray: (children: Child) => Child[];
-        };
-        Fragment: (props: Record<string, unknown>) => import("..").JSXNode;
-        StrictMode: (props: Record<string, unknown>) => import("..").JSXNode;
-        flushSync: (callback: () => void) => void;
-        createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
+  renderToString: (element: Child, options?: RenderToStringOptions) => string;
+  renderToReadableStream: (element: Child, options?: RenderToReadableStreamOptions) => Promise<ReadableStream<Uint8Array>>;
+  version: {
+    version: string;
+    useState: {
+      <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
+      <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
+    };
+    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    useRef: typeof useRef;
+    useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
+    use: <T>(promise: Promise<T>) => T;
+    startTransition: (callback: () => void) => void;
+    useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+    useDeferredValue: <T>(value: T, initialValue?: T) => T;
+    startViewTransition: (callback: () => void) => void;
+    useViewTransition: () => [boolean, (callback: () => void) => void];
+    useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    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>() => RefObject<T | null>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX.Element) => ((props: P & {
+      ref?: RefObject<T | null>;
+    }) => JSX.Element);
+    useImperativeHandle: <T>(ref: RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+    useFormStatus: () => {
+      pending: false;
+      data: null;
+      method: null;
+      action: null;
+    } | {
+      pending: true;
+      data: FormData;
+      method: "get" | "post";
+      action: string | ((formData: FormData) => void | Promise<void>);
+    };
+    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];
+    Suspense: FC<PropsWithChildren<{
+      fallback: any;
+    }>>;
+    ErrorBoundary: FC<PropsWithChildren<{
+      fallback?: Child;
+      fallbackRender?: FallbackRender;
+      onError?: ErrorHandler;
+    }>>;
+    createContext: <T>(defaultValue: T) => Context<T>;
+    useContext: <T>(context: Context<T>) => T;
+    memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+    isValidElement: (element: unknown) => element is JSXNode;
+    createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
+    cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
+    Children: {
+      map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+      forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+      count: (children: Child[]) => number;
+      only: (_children: Child[]) => Child;
+      toArray: (children: Child) => Child[];
     };
+    Fragment: (props: Record<string, unknown>) => JSXNode;
+    StrictMode: (props: Record<string, unknown>) => JSXNode;
+    flushSync: (callback: () => void) => void;
+    createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
+  };
 };
-export default _default;
+//#endregion
+export { _default as default, renderToReadableStream, renderToString, _default$1 as version };
+export {};

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

@@ -1 +1,3 @@
+//#region src/jsx/dom/utils.d.ts
 export declare const setInternalTagFlag: (fn: Function) => Function;
+//#endregion

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

@@ -1,17 +1,16 @@
-import type { JSX } from '../base';
+import { JSX } from "../base.js";
+//#region src/jsx/hooks/index.d.ts
 type UpdateStateFunction<T> = (newState: T | ((currentState: T) => T)) => void;
 export declare const STASH_EFFECT = 1;
-export type EffectData = [
-    readonly unknown[] | undefined,
-    // deps
-    (() => void | (() => void)) | undefined,
-    // layout effect
-    (() => void) | undefined,
-    // cleanup
-    (() => void) | undefined,
-    // effect
-    (() => void) | undefined
-];
+export type EffectData = [readonly unknown[] | undefined,
+// deps
+(() => void | (() => void)) | undefined,
+// layout effect
+(() => void) | undefined,
+// cleanup
+(() => void) | undefined,
+// effect
+(() => void) | undefined];
 export declare const startViewTransition: (callback: () => void) => void;
 export declare const useViewTransition: () => [boolean, (callback: () => void) => void];
 export declare const startTransition: (callback: () => void) => void;
@@ -19,8 +18,8 @@ export declare const useTransition: () => [boolean, (callback: () => void | Prom
 type UseDeferredValue = <T>(value: T, initialValue?: T) => T;
 export declare const useDeferredValue: UseDeferredValue;
 type UseStateType = {
-    <T>(initialState: T | (() => T)): [T, UpdateStateFunction<T>];
-    <T = undefined>(): [T | undefined, UpdateStateFunction<T | undefined>];
+  <T>(initialState: T | (() => T)): [T, UpdateStateFunction<T>];
+  <T = undefined>(): [T | undefined, UpdateStateFunction<T | undefined>];
 };
 export declare const useState: UseStateType;
 export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
@@ -29,17 +28,20 @@ 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;
+//#endregion
 export {};

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

@@ -1,75 +1,73 @@
-/**
- * @module
- * JSX for Hono.
- */
-import { Fragment, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from './base';
-import type { DOMAttributes } from './base';
-import { Children } from './children';
-import { ErrorBoundary } from './components';
-import { createContext, useContext } from './context';
-import { useActionState, useOptimistic } from './dom/hooks';
-import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from './hooks';
-import { Suspense } from './streaming';
-export { reactAPICompatVersion as version, jsx, memo, Fragment, Fragment as StrictMode, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, useActionState, useOptimistic, Suspense, Children, DOMAttributes, };
+import { HtmlEscapedString } from "../utils/html.js";
+import { ErrorBoundary, ErrorHandler, FallbackRender } from "./components.js";
+import { JSX } from "./intrinsic-elements.js";
+import { RefObject, createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from "./hooks/index.js";
+import { AnimationEvent, CSSProperties, ClipboardEvent, ComponentClass, DragEvent, Event, FocusEvent, InputEvent, KeyboardEvent, MouseEvent, PointerEvent, PropsWithChildren, ReactElement, ReactNode, TouchEvent, TransitionEvent, WheelEvent } from "./types.js";
+import { Children } from "./children.js";
+import { useActionState, useOptimistic } from "./dom/hooks/index.js";
+import { Suspense } from "./streaming.js";
+import { Context, createContext, useContext } from "./context.js";
+import { Child, DOMAttributes, FC, Fragment, JSX as JSX$1, JSXNode, Props, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from "./base.js";
+//#region src/jsx/index.d.ts
 declare const _default: {
-    version: string;
-    memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
-    Fragment: ({ children, }: {
-        key?: string;
-        children?: import("./base").Child | import("../utils/html").HtmlEscapedString;
-    }) => import("../utils/html").HtmlEscapedString;
-    StrictMode: ({ children, }: {
-        key?: string;
-        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;
-    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;
-        fallbackRender?: import("./components").FallbackRender;
-        onError?: import("./components").ErrorHandler;
-    }>>;
-    createContext: <T>(defaultValue: T) => import("./context").Context<T>;
-    useContext: <T>(context: import("./context").Context<T>) => T;
-    useState: {
-        <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-        <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>;
-    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;
-    useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-    use: <T>(promise: Promise<T>) => T;
-    startTransition: (callback: () => void) => void;
-    useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
-    useDeferredValue: <T>(value: T, initialValue?: T) => T;
-    startViewTransition: (callback: () => void) => void;
-    useViewTransition: () => [boolean, (callback: () => void) => void];
-    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>;
-    }) => import("./base").JSX.Element);
-    useImperativeHandle: <T>(ref: import("./hooks").RefObject<T>, 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];
-    Suspense: import("./base").FC<import("./types").PropsWithChildren<{
-        fallback: any;
-    }>>;
-    Children: {
-        map: (children: import("./base").Child[], fn: (child: import("./base").Child, index: number) => import("./base").Child) => import("./base").Child[];
-        forEach: (children: import("./base").Child[], fn: (child: import("./base").Child, index: number) => void) => void;
-        count: (children: import("./base").Child[]) => number;
-        only: (_children: import("./base").Child[]) => import("./base").Child;
-        toArray: (children: import("./base").Child) => import("./base").Child[];
-    };
+  version: string;
+  memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+  Fragment: ({ children }: {
+    key?: string;
+    children?: Child | HtmlEscapedString;
+  }) => HtmlEscapedString;
+  StrictMode: ({ children }: {
+    key?: string;
+    children?: Child | HtmlEscapedString;
+  }) => HtmlEscapedString;
+  isValidElement: (element: unknown) => element is JSXNode;
+  createElement: (tag: string | Function, props: Props | null, ...children: Child[]) => JSXNode;
+  cloneElement: <T extends JSXNode | JSX$1.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;
+  ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+  }>>;
+  createContext: <T>(defaultValue: T) => Context<T>;
+  useContext: <T>(context: Context<T>) => T;
+  useState: {
+    <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
+    <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
+  };
+  useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+  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;
+  useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+  use: <T>(promise: Promise<T>) => T;
+  startTransition: (callback: () => void) => void;
+  useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+  useDeferredValue: <T>(value: T, initialValue?: T) => T;
+  startViewTransition: (callback: () => void) => void;
+  useViewTransition: () => [boolean, (callback: () => void) => void];
+  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>() => RefObject<T | null>;
+  forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX$1.Element) => ((props: P & {
+    ref?: RefObject<T | null>;
+  }) => JSX$1.Element);
+  useImperativeHandle: <T>(ref: 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];
+  Suspense: FC<PropsWithChildren<{
+    fallback: any;
+  }>>;
+  Children: {
+    map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+    forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+    count: (children: Child[]) => number;
+    only: (_children: Child[]) => Child;
+    toArray: (children: Child) => Child[];
+  };
 };
-export default _default;
-export type * from './types';
-export type { JSX } from './intrinsic-elements';
+//#endregion
+export { type AnimationEvent, type CSSProperties, type Child, Children, type ClipboardEvent, type ComponentClass, type Context, type DOMAttributes, type DragEvent, ErrorBoundary, type Event, type FC, type FocusEvent, Fragment, Fragment as StrictMode, type InputEvent, type JSX, type JSXNode, type KeyboardEvent, type MouseEvent, type PointerEvent, type PropsWithChildren, type ReactElement, type ReactNode, type RefObject, Suspense, type TouchEvent, type TransitionEvent, type WheelEvent, cloneElement, createContext, jsx as createElement, jsx, createRef, _default as default, forwardRef, isValidElement, memo, startTransition, startViewTransition, use, useActionState, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition, reactAPICompatVersion as version };
+export {};

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

@@ -1,6 +1,8 @@
-import type { Props } from '../base';
+import { Props } from "../base.js";
+//#region src/jsx/intrinsic-element/common.d.ts
 export declare const deDupeKeyMap: Record<string, string[]>;
 export declare const domRenderers: Record<string, Function>;
 export declare const dataPrecedenceAttr = "data-precedence";
 export declare const isStylesheetLinkWithPrecedence: (props: Props) => boolean;
 export declare const shouldDeDupeByKey: (tagName: string, supportSort: boolean) => boolean;
+//#endregion

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

@@ -1,13 +1,16 @@
-import type { IntrinsicElements } from '../intrinsic-elements';
-import type { FC, PropsWithChildren } from '../types';
+import { IntrinsicElements } from "../intrinsic-elements.js";
+import { PropsWithChildren } from "../types.js";
+import { FC } from "../base.js";
+//#region src/jsx/intrinsic-element/components.d.ts
 export declare const title: FC<PropsWithChildren>;
 export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
 export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;
 export declare const link: FC<PropsWithChildren<IntrinsicElements['link']>>;
 export declare const meta: FC<PropsWithChildren>;
 export declare const form: FC<PropsWithChildren<{
-    action?: Function | string;
-    method?: 'get' | 'post';
+  action?: Function | string;
+  method?: 'get' | 'post';
 }>>;
 export declare const input: (props: PropsWithChildren) => unknown;
 export declare const button: (props: PropsWithChildren) => unknown;
+//#endregion