@zuplo/cli 6.73.30 → 6.73.31

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

@@ -0,0 +1,83 @@
+/**
+ * @module
+ * This module provides APIs that enable `hono/jsx/dom` to support.
+ */
+import type { FC, PropsWithChildren } from '../';
+import type { ClassNameSlug, CssClassName, CssVariableType, OnInvalidSlug } from '../../helper/css/common';
+export { rawCssString } from '../../helper/css/common';
+interface CreateCssJsxDomObjectsType {
+    (args: {
+        id: Readonly<string>;
+    }): readonly [
+        {
+            toString(this: CssClassName): string;
+        },
+        FC<PropsWithChildren<void>>
+    ];
+}
+export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
+interface CssType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+}
+interface CxType {
+    (...args: (string | boolean | null | undefined)[]): string;
+}
+interface KeyframesType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
+}
+interface ViewTransitionType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+    (content: string): string;
+    (): string;
+}
+interface DefaultContextType {
+    css: CssType;
+    cx: CxType;
+    keyframes: KeyframesType;
+    viewTransition: ViewTransitionType;
+    Style: FC<PropsWithChildren<void>>;
+}
+/**
+ * @experimental
+ * `createCssContext` is an experimental feature.
+ * The API might be changed.
+ *
+ * @param options.id - The ID for the style element
+ * @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;
+}) => DefaultContextType;
+/**
+ * @experimental
+ * `css` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const css: CssType;
+/**
+ * @experimental
+ * `cx` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const cx: CxType;
+/**
+ * @experimental
+ * `keyframes` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const keyframes: KeyframesType;
+/**
+ * @experimental
+ * `viewTransition` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const viewTransition: ViewTransitionType;
+/**
+ * @experimental
+ * `Style` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const Style: FC<PropsWithChildren<void>>;

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

@@ -0,0 +1,39 @@
+/**
+ * Provide hooks used only in jsx/dom
+ */
+import type { Context } from '../../context';
+type FormStatus = {
+    pending: false;
+    data: null;
+    method: null;
+    action: null;
+} | {
+    pending: true;
+    data: FormData;
+    method: 'get' | 'post';
+    action: string | ((formData: FormData) => void | Promise<void>);
+};
+export declare const FormContext: Context<FormStatus>;
+export declare const registerAction: (action: Promise<unknown>) => void;
+/**
+ * This hook returns the current form status
+ * @returns FormStatus
+ */
+export declare const useFormStatus: () => FormStatus;
+/**
+ * This hook returns the current state and a function to update the state optimistically
+ * The current state is updated optimistically and then reverted to the original state when all actions are resolved
+ * @param state
+ * @param updateState
+ * @returns [T, (action: N) => void]
+ */
+export declare const useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+/**
+ * This hook returns the current state and a function to update the state by form action
+ * @param fn
+ * @param initialState
+ * @param permalink
+ * @returns [T, (data: FormData) => void]
+ */
+export declare const useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+export {};

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

@@ -0,0 +1,88 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom`.
+ */
+import { isValidElement, reactAPICompatVersion } from '../base';
+import type { Child, DOMAttributes, JSX, JSXNode, Props, FC } from '../base';
+import { Children } from '../children';
+import { useContext } from '../context';
+import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from '../hooks';
+import { ErrorBoundary, Suspense } from './components';
+import { createContext } from './context';
+import { useActionState, useFormStatus, useOptimistic } from './hooks';
+import { Fragment } from './jsx-runtime';
+import { createPortal, flushSync } from './render';
+export { render } from './render';
+declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
+declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
+declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+export { reactAPICompatVersion as version, createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, useFormStatus, useActionState, useOptimistic, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, Fragment as StrictMode, DOMAttributes, flushSync, createPortal, };
+declare const _default: {
+    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>) => JSX.Element) => ((props: P & {
+        ref?: import("..").RefObject<T>;
+    }) => 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: FC<import("..").PropsWithChildren<{
+        fallback: any;
+    }>>;
+    ErrorBoundary: 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: 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;
+export type { Context } from '../context';
+export type * from '../types';

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

@@ -0,0 +1,16 @@
+import type { IntrinsicElements } from '../../intrinsic-elements';
+import type { FC, PropsWithChildren, RefObject } from '../../types';
+export declare const clearCache: () => void;
+export declare const composeRef: <T>(ref: RefObject<T> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
+export declare const 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';
+    ref?: RefObject<HTMLFormElement> | ((e: HTMLFormElement | null) => void | (() => void));
+}>>;
+export declare const input: FC<PropsWithChildren<IntrinsicElements['input']>>;
+export declare const button: FC<PropsWithChildren<IntrinsicElements['button']>>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/jsx/dom/jsx-dev-runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * This module provides the `hono/jsx/dom` dev runtime.
+ */
+import type { JSXNode, Props } from '../base';
+export type { JSX } from '../base';
+export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
+export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

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

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * This module provides the `hono/jsx/dom` runtime.
+ */
+export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime';
+export { jsxDEV as jsxs } from './jsx-dev-runtime';
+export type { JSX } from './jsx-dev-runtime';

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

@@ -0,0 +1,73 @@
+import type { Child, FC, JSXNode, Props } from '../base';
+import { DOM_RENDERER, DOM_STASH } from '../constants';
+import type { Context as JSXContext } from '../context';
+export type HasRenderToDom = 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 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[][]];
+} & JSXNode;
+type NodeString = {
+    t: string;
+    d: boolean;
+    s?: boolean;
+} & {
+    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 declare const buildDataStack: [Context, Node][];
+export declare const getNameSpaceContext: () => JSXContext<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>;
+export declare const renderNode: (node: NodeObject, container: Container) => void;
+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;
+export {};

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

@@ -0,0 +1,106 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/server`, which is compatible with `react-dom/server`.
+ */
+import type { Child } from '../base';
+import version from './';
+export interface RenderToStringOptions {
+    identifierPrefix?: string;
+}
+/**
+ * Render JSX element to string.
+ * @param element JSX element to render.
+ * @param options Options for rendering.
+ * @returns Rendered string.
+ */
+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;
+}
+/**
+ * Render JSX element to readable stream.
+ * @param element JSX element to render.
+ * @param options Options for rendering.
+ * @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;
+    };
+};
+export default _default;

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

@@ -0,0 +1 @@
+export declare const setInternalTagFlag: (fn: Function) => Function;

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

@@ -0,0 +1,45 @@
+import type { JSX } from '../base';
+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 declare const startViewTransition: (callback: () => void) => void;
+export declare const useViewTransition: () => [boolean, (callback: () => void) => void];
+export declare const startTransition: (callback: () => void) => void;
+export declare const useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+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>];
+};
+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];
+export declare const useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+export declare const useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+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;
+};
+export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
+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>;
+}) => JSX.Element);
+export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+export {};

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

@@ -0,0 +1,75 @@
+/**
+ * @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, };
+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: import("./base").Child[]) => import("./base").JSXNode;
+    cloneElement: <T extends import("./base").JSXNode | import("./base").JSX.Element>(element: T, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T;
+    ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
+        fallback?: import("./base").Child;
+        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[];
+    };
+};
+export default _default;
+export type * from './types';
+export type { JSX } from './intrinsic-elements';

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

@@ -0,0 +1,6 @@
+import type { Props } from '../base';
+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;

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

@@ -0,0 +1,13 @@
+import type { IntrinsicElements } from '../intrinsic-elements';
+import type { FC, PropsWithChildren } from '../types';
+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';
+}>>;
+export declare const input: (props: PropsWithChildren) => unknown;
+export declare const button: (props: PropsWithChildren) => unknown;