@depup/hono 4.12.8-depup.0

package/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/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/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/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/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/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/dist/types/jsx/dom/utils.d.ts

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

package/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/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: (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[];
+    };
+};
+export default _default;
+export type * from './types';
+export type { JSX } from './intrinsic-elements';

package/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/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;