@zuplo/cli 6.73.30 → 6.73.31

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

@@ -0,0 +1,69 @@
+/**
+ * @module
+ * WebSocket Helper for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler, TypedResponse } from '../../types';
+import type { StatusCode } from '../../utils/http-status';
+/**
+ * WebSocket Event Listeners type
+ */
+export interface WSEvents<T = unknown> {
+    onOpen?: (evt: Event, ws: WSContext<T>) => void;
+    onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) => void;
+    onClose?: (evt: CloseEvent, ws: WSContext<T>) => void;
+    onError?: (evt: Event, ws: WSContext<T>) => void;
+}
+/**
+ * Upgrade WebSocket Type
+ */
+export interface UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> {
+    (createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>, options?: U): MiddlewareHandler<any, string, {
+        outputFormat: 'ws';
+    }>;
+    (c: Context, events: _WSEvents, options?: U): Promise<Response & TypedResponse<{}, StatusCode, 'ws'>>;
+}
+/**
+ * ReadyState for WebSocket
+ */
+export type WSReadyState = 0 | 1 | 2 | 3;
+/**
+ * An argument for WSContext class
+ */
+export interface WSContextInit<T = unknown> {
+    send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options: SendOptions): void;
+    close(code?: number, reason?: string): void;
+    raw?: T;
+    readyState: WSReadyState;
+    url?: string | URL | null;
+    protocol?: string | null;
+}
+/**
+ * Options for sending message
+ */
+export interface SendOptions {
+    compress?: boolean;
+}
+/**
+ * A context for controlling WebSockets
+ */
+export declare class WSContext<T = unknown> {
+             
+    constructor(init: WSContextInit<T>);
+    send(source: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: SendOptions): void;
+    raw?: T;
+    binaryType: BinaryType;
+    get readyState(): WSReadyState;
+    url: URL | null;
+    protocol: string | null;
+    close(code?: number, reason?: string): void;
+}
+export type WSMessageReceive = string | Blob | ArrayBufferLike;
+export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;
+export interface WebSocketHelperDefineContext {
+}
+export type WebSocketHelperDefineHandler<T, U> = (c: Context, events: WSEvents<T>, options?: U) => Promise<Response | void> | Response | void;
+/**
+ * Create a WebSocket adapter/helper
+ */
+export declare const defineWebSocketHelper: <T = unknown, U = any>(handler: WebSocketHelperDefineHandler<T, U>) => UpgradeWebSocket<T, U>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/hono-base.d.ts

@@ -0,0 +1,220 @@
+/**
+ * @module
+ * This module is the base module for the Hono object.
+ */
+import { Context } from './context';
+import type { ExecutionContext } from './context';
+import type { Router } from './router';
+import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
+type GetPath<E extends Env> = (request: Request, options?: {
+    env?: E['Bindings'];
+}) => string;
+export type HonoOptions<E extends Env> = {
+    /**
+     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * `router` option specifies which router to use.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#router-option}
+     *
+     * @example
+     * ```ts
+     * const app = new Hono({ router: new RegExpRouter() })
+     * ```
+     */
+    router?: Router<[H, RouterRoute]>;
+    /**
+     * `getPath` can handle the host header value.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
+     *
+     * @example
+     * ```ts
+     * const app = new Hono({
+     *  getPath: (req) =>
+     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
+     * })
+     *
+     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
+     *
+     * // A following request will match the route:
+     * // new Request('http://www1.example.com/hello', {
+     * //  headers: { host: 'www1.example.com' },
+     * // })
+     * ```
+     */
+    getPath?: GetPath<E>;
+};
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+    optionHandler?: MountOptionHandler;
+    replaceRequest?: MountReplaceRequest | false;
+};
+declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
+             
+    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
+    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
+    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
+    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
+    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
+    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
+    on: OnHandlerInterface<E, S, BasePath>;
+    use: MiddlewareHandlerInterface<E, S, BasePath>;
+    router: Router<[H, RouterRoute]>;
+    readonly getPath: GetPath<E>;
+    private _basePath;
+    routes: RouterRoute[];
+    constructor(options?: HonoOptions<E>);
+    private errorHandler;
+    /**
+     * `.route()` allows grouping other Hono instance in routes.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#grouping}
+     *
+     * @param {string} path - base Path
+     * @param {Hono} app - other Hono instance
+     * @returns {Hono} routed Hono instance
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const app2 = new Hono()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
+    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
+    /**
+     * `.basePath()` allows base paths to be specified.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#base-path}
+     *
+     * @param {string} path - base Path
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * const api = new Hono().basePath('/api')
+     * ```
+     */
+    basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
+    /**
+     * `.onError()` handles an error and returns a customized Response.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#error-handling}
+     *
+     * @param {ErrorHandler} handler - request Handler for error
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * app.onError((err, c) => {
+     *   console.error(`${err}`)
+     *   return c.text('Custom Error Message', 500)
+     * })
+     * ```
+     */
+    onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.notFound()` allows you to customize a Not Found Response.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#not-found}
+     *
+     * @param {NotFoundHandler} handler - request handler for not-found
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * app.notFound((c) => {
+     *   return c.text('Custom 404 Message', 404)
+     * })
+     * ```
+     */
+    notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#mount}
+     *
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Hono} mounted Hono instance
+     *
+     * @example
+     * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Hono } from 'hono'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
+     * const app = new Hono()
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
+     * ```
+     */
+    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.fetch()` will be entry point of your app.
+     *
+     * @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
+     * @returns {Response | Promise<Response>} response of request
+     *
+     */
+    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.
+     * app will return a Response object.
+     * ```ts
+     * test('GET /hello is ok', async () => {
+     *   const res = await app.request('/hello')
+     *   expect(res.status).toBe(200)
+     * })
+     * ```
+     * @see https://hono.dev/docs/api/hono#request
+     */
+    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    /**
+     * `.fire()` automatically adds a global fetch event listener.
+     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+     * @deprecated
+     * Use `fire` from `hono/service-worker` instead.
+     * ```ts
+     * import { Hono } from 'hono'
+     * import { fire } from 'hono/service-worker'
+     *
+     * const app = new Hono()
+     * // ...
+     * fire(app)
+     * ```
+     * @see https://hono.dev/docs/api/hono#fire
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+     */
+    fire: () => void;
+}
+export { Hono as HonoBase };

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/hono.d.ts

@@ -0,0 +1,19 @@
+import { HonoBase } from './hono-base';
+import type { HonoOptions } from './hono-base';
+import type { BlankEnv, BlankSchema, Env, Schema } from './types';
+/**
+ * The Hono class extends the functionality of the HonoBase class.
+ * It sets up routing and allows for custom options to be passed.
+ *
+ * @template E - The environment type.
+ * @template S - The schema type.
+ * @template BasePath - The base path type.
+ */
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+    /**
+     * Creates an instance of the Hono class.
+     *
+     * @param options - Optional configuration options for the Hono instance.
+     */
+    constructor(options?: HonoOptions<E>);
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/http-exception.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module
+ * This module provides the `HTTPException` class.
+ */
+import type { ContentfulStatusCode } from './utils/http-status';
+/**
+ * Options for creating an `HTTPException`.
+ * @property res - Optional response object to use.
+ * @property message - Optional custom error message.
+ * @property cause - Optional cause of the error.
+ */
+type HTTPExceptionOptions = {
+    res?: Response;
+    message?: string;
+    cause?: unknown;
+};
+/**
+ * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/docs/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
+ * @example
+ * ```ts
+ * import { HTTPException } from 'hono/http-exception'
+ *
+ * // ...
+ *
+ * app.post('/auth', async (c, next) => {
+ *   // authentication
+ *   if (authorized === false) {
+ *     throw new HTTPException(401, { message: 'Custom error message' })
+ *   }
+ *   await next()
+ * })
+ * ```
+ */
+export declare class HTTPException extends Error {
+    readonly res?: Response;
+    readonly status: ContentfulStatusCode;
+    /**
+     * Creates an instance of `HTTPException`.
+     * @param status - HTTP status code for the exception. Defaults to 500.
+     * @param options - Additional options for the exception.
+     */
+    constructor(status?: ContentfulStatusCode, options?: HTTPExceptionOptions);
+    /**
+     * Returns the response object associated with the exception.
+     * If a response object is not provided, a new response is created with the error message and status code.
+     * @returns The response object.
+     */
+    getResponse(): Response;
+}
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module
+ *
+ * Hono - Web Framework built on Web Standards
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hono!'))
+ *
+ * export default app
+ * ```
+ */
+import { Hono } from './hono';
+/**
+ * Types for environment variables, error handlers, handlers, middleware handlers, and more.
+ */
+export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundResponse, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
+/**
+ * Types for context, context variable map, context renderer, and execution context.
+ */
+export { Context } from './context';
+export type { ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
+/**
+ * Type for HonoRequest.
+ */
+export type { HonoRequest } from './request';
+/**
+ * Types for inferring request and response types and client request options.
+ */
+export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client';
+/**
+ * Hono framework for building web applications.
+ */
+export { Hono };

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/base.d.ts

@@ -0,0 +1,56 @@
+import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../utils/html';
+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>;
+export type FC<P = Props> = {
+    (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null;
+    defaultProps?: Partial<P> | undefined;
+    displayName?: string | undefined;
+};
+export type DOMAttributes = HonoJSX.HTMLAttributes;
+export declare namespace JSX {
+    type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+    interface ElementChildrenAttribute {
+        children: Child;
+    }
+    interface IntrinsicElements extends IntrinsicElementsDefined {
+        [tagName: string]: Props;
+    }
+    interface IntrinsicAttributes {
+        key?: string | number | bigint | null | undefined;
+    }
+}
+export declare const getNameSpaceContext: () => Context<string> | undefined;
+export declare const booleanAttributes: string[];
+export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
+export declare class JSXNode implements HtmlEscaped {
+    tag: string | Function;
+    props: Props;
+    key?: string;
+    children: Child[];
+    isEscaped: true;
+    suspendedContext?: <T>(callback: () => T) => T;
+    constructor(tag: string | Function, props: Props, children: Child[]);
+    get type(): string | Function;
+    get ref(): any;
+    toString(): string | Promise<string>;
+    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+}
+export declare class JSXFragmentNode extends JSXNode {
+    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+}
+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;
+};
+export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+export declare const Fragment: ({ children, }: {
+    key?: string;
+    children?: Child | HtmlEscapedString;
+}) => HtmlEscapedString;
+export declare const isValidElement: (element: unknown) => element is JSXNode;
+export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;
+export declare const reactAPICompatVersion = "19.0.0-hono-jsx";

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/children.d.ts

@@ -0,0 +1,9 @@
+import type { Child } from './base';
+export declare const toArray: (children: Child) => Child[];
+export declare const 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[];
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/components.d.ts

@@ -0,0 +1,15 @@
+import type { HtmlEscapedString } from '../utils/html';
+import type { Child, FC, PropsWithChildren } from './';
+export declare const childrenToString: (children: Child[]) => Promise<HtmlEscapedString[]>;
+export type ErrorHandler = (error: Error) => void;
+export type FallbackRender = (error: Error) => Child;
+/**
+ * @experimental
+ * `ErrorBoundary` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+}>>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DOM_RENDERER: unique symbol;
+export declare const DOM_ERROR_HANDLER: unique symbol;
+export declare const DOM_STASH: unique symbol;
+export declare const DOM_INTERNAL_TAG: unique symbol;
+export declare const DOM_MEMO: unique symbol;
+export declare const PERMALINK: unique symbol;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/context.d.ts

@@ -0,0 +1,51 @@
+import type { FC, PropsWithChildren } from './';
+export interface Context<T> extends FC<PropsWithChildren<{
+    value: T;
+}>> {
+    values: T[];
+    Provider: FC<PropsWithChildren<{
+        value: T;
+    }>>;
+}
+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/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/dom/client.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom/client`, which is compatible with `react-dom/client`.
+ */
+import type { Child } from '../base';
+export interface Root {
+    render(children: Child): void;
+    unmount(): void;
+}
+export type RootOptions = Record<string, unknown>;
+/**
+ * Create a root object for rendering
+ * @param element Render target
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export declare const createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
+/**
+ * Create a root object and hydrate app to the target element.
+ * In hono/jsx/dom, hydrate is equivalent to render.
+ * @param element Render target
+ * @param reactNode A JSXNode to render
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export declare const hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
+declare const _default: {
+    createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
+    hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
+};
+export default _default;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/dom/components.d.ts

@@ -0,0 +1,10 @@
+import type { Child, FC, PropsWithChildren } from '../';
+import type { ErrorHandler, FallbackRender } from '../components';
+export declare const ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+}>>;
+export declare const Suspense: FC<PropsWithChildren<{
+    fallback: any;
+}>>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/dom/context.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../context';
+export declare const createContextProviderFunction: <T>(values: T[]) => Function;
+export declare const createContext: <T>(defaultValue: T) => Context<T>;