sibujs 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -1,7 +1,134 @@
-import { T as TagProps, N as NodeChildren, a as NodeChild } from './tagFactory-Dl8QCLga.js';
-export { S as SVG_NS, t as tagFactory } from './tagFactory-Dl8QCLga.js';
+import { T as TagProps, N as NodeChildren, a as NodeChild } from './tagFactory-DaJ0YWX6.js';
+export { S as SVG_NS, t as tagFactory } from './tagFactory-DaJ0YWX6.js';
 import { R as ReactiveSignal } from './signal-BnWpq6WB.js';
 
+type reactive<T> = T | (() => T);
+interface AnchorProps extends TagProps {
+    href?: reactive<string>;
+    target?: "_self" | "_blank" | "_parent" | "_top" | (string & {});
+    rel?: reactive<string>;
+    download?: reactive<string | boolean>;
+    hreflang?: reactive<string>;
+    referrerpolicy?: reactive<"" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url">;
+    ping?: reactive<string>;
+}
+type InputType = "button" | "checkbox" | "color" | "date" | "datetime-local" | "email" | "file" | "hidden" | "image" | "month" | "number" | "password" | "radio" | "range" | "reset" | "search" | "submit" | "tel" | "text" | "time" | "url" | "week";
+interface InputProps extends TagProps {
+    type?: InputType | (string & {});
+    name?: reactive<string>;
+    value?: reactive<string | number>;
+    placeholder?: reactive<string>;
+    required?: reactive<boolean>;
+    disabled?: reactive<boolean>;
+    readonly?: reactive<boolean>;
+    checked?: reactive<boolean>;
+    min?: reactive<string | number>;
+    max?: reactive<string | number>;
+    step?: reactive<string | number>;
+    minlength?: reactive<number>;
+    maxlength?: reactive<number>;
+    pattern?: reactive<string>;
+    autocomplete?: reactive<string>;
+    autofocus?: reactive<boolean>;
+    multiple?: reactive<boolean>;
+    accept?: reactive<string>;
+    size?: reactive<number>;
+    form?: reactive<string>;
+    list?: reactive<string>;
+    inputmode?: reactive<"none" | "text" | "decimal" | "numeric" | "tel" | "search" | "email" | "url">;
+}
+interface ImgProps extends TagProps {
+    src?: reactive<string>;
+    alt?: reactive<string>;
+    width?: reactive<number | string>;
+    height?: reactive<number | string>;
+    loading?: reactive<"lazy" | "eager">;
+    decoding?: reactive<"sync" | "async" | "auto">;
+    srcset?: reactive<string>;
+    sizes?: reactive<string>;
+    crossorigin?: reactive<"anonymous" | "use-credentials">;
+    referrerpolicy?: reactive<string>;
+}
+interface ButtonProps extends TagProps {
+    type?: reactive<"button" | "submit" | "reset">;
+    name?: reactive<string>;
+    value?: reactive<string>;
+    disabled?: reactive<boolean>;
+    form?: reactive<string>;
+    formaction?: reactive<string>;
+    formenctype?: reactive<string>;
+    formmethod?: reactive<"get" | "post" | "dialog">;
+    formnovalidate?: reactive<boolean>;
+    formtarget?: reactive<string>;
+    autofocus?: reactive<boolean>;
+}
+interface FormProps extends TagProps {
+    action?: reactive<string>;
+    method?: reactive<"get" | "post" | "dialog">;
+    enctype?: reactive<"application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain">;
+    name?: reactive<string>;
+    novalidate?: reactive<boolean>;
+    target?: reactive<string>;
+    autocomplete?: reactive<"on" | "off">;
+    acceptcharset?: reactive<string>;
+}
+interface SelectProps extends TagProps {
+    name?: reactive<string>;
+    value?: reactive<string>;
+    disabled?: reactive<boolean>;
+    multiple?: reactive<boolean>;
+    required?: reactive<boolean>;
+    size?: reactive<number>;
+    autocomplete?: reactive<string>;
+    autofocus?: reactive<boolean>;
+    form?: reactive<string>;
+}
+interface TextareaProps extends TagProps {
+    name?: reactive<string>;
+    value?: reactive<string>;
+    placeholder?: reactive<string>;
+    disabled?: reactive<boolean>;
+    readonly?: reactive<boolean>;
+    required?: reactive<boolean>;
+    rows?: reactive<number>;
+    cols?: reactive<number>;
+    minlength?: reactive<number>;
+    maxlength?: reactive<number>;
+    wrap?: reactive<"hard" | "soft" | "off">;
+    autocomplete?: reactive<string>;
+    autofocus?: reactive<boolean>;
+    form?: reactive<string>;
+    spellcheck?: reactive<boolean>;
+}
+interface LabelProps extends TagProps {
+    for?: reactive<string>;
+    form?: reactive<string>;
+}
+interface OptionProps extends TagProps {
+    value?: reactive<string | number>;
+    selected?: reactive<boolean>;
+    disabled?: reactive<boolean>;
+    label?: reactive<string>;
+}
+interface MediaProps extends TagProps {
+    src?: reactive<string>;
+    autoplay?: reactive<boolean>;
+    controls?: reactive<boolean>;
+    loop?: reactive<boolean>;
+    muted?: reactive<boolean>;
+    preload?: reactive<"none" | "metadata" | "auto">;
+    crossorigin?: reactive<"anonymous" | "use-credentials">;
+}
+interface VideoProps extends MediaProps {
+    poster?: reactive<string>;
+    width?: reactive<number | string>;
+    height?: reactive<number | string>;
+    playsinline?: reactive<boolean>;
+}
+type AudioProps = MediaProps;
+
+type TypedTagFunction<Props extends TagProps, El extends Element> = (first?: Props | NodeChildren, second?: NodeChildren) => El;
+
 declare const head: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const body: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const title: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
@@ -33,7 +160,7 @@ declare const li: (first?: TagProps | NodeChildren, second?: NodeChildren) => El
 declare const ol: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const ul: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const pre: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const a: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const a: TypedTagFunction<AnchorProps, HTMLAnchorElement>;
 declare const abbr: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const b: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const bdi: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
@@ -61,11 +188,11 @@ declare const time: (first?: TagProps | NodeChildren, second?: NodeChildren) =>
 declare const u: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const var_: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const area: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const audio: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const img: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const audio: TypedTagFunction<AudioProps, HTMLAudioElement>;
+declare const img: TypedTagFunction<ImgProps, HTMLImageElement>;
 declare const map: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const track: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const video: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const video: TypedTagFunction<VideoProps, HTMLVideoElement>;
 declare const embed: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const iframe: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const object: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
@@ -90,20 +217,20 @@ declare const tfoot: (first?: TagProps | NodeChildren, second?: NodeChildren) =>
 declare const th: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const thead: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const tr: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const button: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const button: TypedTagFunction<ButtonProps, HTMLButtonElement>;
 declare const datalist: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const fieldset: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const form: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const input: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const label: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const form: TypedTagFunction<FormProps, HTMLFormElement>;
+declare const input: TypedTagFunction<InputProps, HTMLInputElement>;
+declare const label: TypedTagFunction<LabelProps, HTMLLabelElement>;
 declare const legend: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const meter: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const optgroup: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const option: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const option: TypedTagFunction<OptionProps, HTMLOptionElement>;
 declare const output: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const progress: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const select: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
-declare const textarea: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+declare const select: TypedTagFunction<SelectProps, HTMLSelectElement>;
+declare const textarea: TypedTagFunction<TextareaProps, HTMLTextAreaElement>;
 declare const details: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const dialog: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
 declare const menu: (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
@@ -493,6 +620,38 @@ declare function catchErrorAsync<T>(fn: () => Promise<T>, onError?: ErrorHandler
  */
 declare function setGlobalErrorHandler(handler: ErrorHandler): void;
 
+/**
+ * Generate a stable, framework-unique ID string suitable for a11y pairing
+ * (`aria-labelledby`, `htmlFor` + `id`, etc.).
+ *
+ * Each call returns a fresh incrementing id. Optionally accepts a prefix.
+ *
+ * IDs are plain strings (not reactive) — call once per component instance
+ * and reuse the returned value for both sides of the association.
+ *
+ * @param prefix Optional prefix, default "sibu"
+ * @returns A unique id like `"sibu-1"` or `"my-input-2"`
+ *
+ * @example
+ * ```ts
+ * function Field(labelText: string) {
+ *   const id = createId("field");
+ *   return div({ nodes: [
+ *     label({ for: id, nodes: labelText }),
+ *     input({ id }),
+ *   ]});
+ * }
+ * ```
+ */
+declare function createId(prefix?: string): string;
+/**
+ * Reset the id counter. Intended for tests and SSR setups that want
+ * deterministic ids across runs.
+ *
+ * @internal
+ */
+declare function __resetIdCounter(): void;
+
 /**
  * Register a teardown function for a DOM node.
  * When dispose(node) is called, all registered teardowns run.
@@ -516,7 +675,7 @@ declare function checkLeaks(warnThreshold?: number): number;
 
 declare const __accessor: unique symbol;
 /**
- * A reactive signal getter returned by signal(), derived(), memo(), and similar primitives.
+ * A reactive signal getter returned by signal(), derived(), and similar primitives.
  *
  * Pass an Accessor directly into reactive prop positions — never call it there:
  * ```ts
@@ -669,28 +828,6 @@ interface Ref<T> {
 declare function ref<T>(initial: T): Ref<T>;
 declare function ref<T = undefined>(): Ref<T | undefined>;
 
-/**
- * memo returns a memoized value that only recomputes when its
- * reactive dependencies change. This is semantically identical to
- * derived but named for convenience.
- *
- * Use this to avoid expensive computations on every render cycle.
- *
- * @param factory Function that computes the memoized value
- * @returns Getter function that returns the memoized value
- */
-declare function memo<T>(factory: () => T): Accessor<T>;
-
-/**
- * memoFn returns a memoized callback function that only updates
- * when its reactive dependencies change. This prevents unnecessary
- * re-creations of callback functions passed to child components.
- *
- * @param callback The callback function to memoize
- * @returns Getter that returns the current memoized callback
- */
-declare function memoFn<T extends (...args: any[]) => any>(callback: () => T): Accessor<T>;
-
 /**
  * Reactive array hook. Provides common array operations that
  * automatically trigger reactive updates.
@@ -823,6 +960,46 @@ declare function writable<T>(get: () => T, set: (value: T) => void, options?: {
     name?: string;
 }): [Accessor<T>, (value: T) => void];
 
+interface AsyncDerivedState<T> {
+    /** Resolved value, or `initial` while loading. */
+    value: () => T;
+    /** True while the underlying promise is in-flight. */
+    loading: () => boolean;
+    /** The last caught error, or `null`. */
+    error: () => unknown | null;
+    /** Manually re-run the async computation. */
+    refresh: () => void;
+}
+/**
+ * `asyncDerived` is the async counterpart of `derived`: it takes a factory
+ * that returns a Promise and re-runs whenever its reactive dependencies
+ * change. The returned object exposes reactive `value`, `loading`, and
+ * `error` getters, plus a `refresh()` trigger.
+ *
+ * Stale responses are dropped: if a new run starts before an older one
+ * resolves, the older one's result is ignored. This prevents flicker when
+ * dependencies change rapidly (e.g. typing in a search box).
+ *
+ * Unlike `query()` or `resource()`, `asyncDerived` has no caching or retry
+ * logic — it's a minimal async-reactivity primitive suited for ad-hoc
+ * derivations (parsing, formatting, validation against a server).
+ *
+ * @param factory Async function returning the derived value
+ * @param initial Value used while the first computation is pending
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = signal("");
+ * const results = asyncDerived(async () => {
+ *   const q = query();
+ *   if (!q) return [];
+ *   const r = await fetch(`/api/search?q=${encodeURIComponent(q)}`);
+ *   return r.json();
+ * }, []);
+ * ```
+ */
+declare function asyncDerived<T>(factory: () => Promise<T>, initial: T): AsyncDerivedState<T>;
+
 /**
  * Lifecycle hooks for SibuJS components.
  *
@@ -889,8 +1066,6 @@ declare function onCleanup(callback: CleanupFn, element: Node): void;
  * Context API for SibuJS — provides dependency injection across
  * component trees without prop drilling.
  *
- * Inspired by React's Context and Vue's provide/inject patterns.
- *
  * @example
  * ```ts
  * // Create a context with a default value
@@ -927,6 +1102,46 @@ interface Context<T> {
  */
 declare function context<T>(defaultValue: T): Context<T>;
 
+/**
+ * Dev-only wrapper that runs `fn` twice — once now, once on the next
+ * microtask. Any hidden side effect (duplicate event listener, missing
+ * cleanup, stale closure) shows up immediately.
+ *
+ * In production builds the helper inlines to a single call.
+ *
+ * @example
+ * ```ts
+ * strict(() => {
+ *   // Any effect here is invoked twice in dev. If the second run
+ *   // causes duplicated listeners or DOM nodes, you have a cleanup bug.
+ *   effect(() => {
+ *     document.addEventListener("keydown", onKey);
+ *     // Forgot to return a disposer — strict() makes this obvious.
+ *   });
+ * });
+ * ```
+ */
+declare function strict<T>(fn: () => T): T;
+/**
+ * Dev-only wrapper that re-runs an effect twice the first time to catch
+ * accidental side-effect bleeding. The returned teardown disposes both
+ * invocations.
+ *
+ * This is a thin wrapper around `effect()` — use it instead of `effect()`
+ * in any place where you suspect a cleanup bug.
+ *
+ * @example
+ * ```ts
+ * const dispose = strictEffect(() => {
+ *   const handler = () => { ... };
+ *   window.addEventListener("resize", handler);
+ *   // Missing `return () => removeEventListener(...)` — strictEffect
+ *   // will double-attach in dev and you'll see two log lines.
+ * });
+ * ```
+ */
+declare function strictEffect(fn: () => void): () => void;
+
 /**
  * SSR context for SibuJS.
  *
@@ -950,6 +1165,11 @@ declare function disableSSR(): void;
 /**
  * Run a function in SSR mode. Automatically enables/disables SSR around the callback.
  * Returns whatever the callback returns.
+ *
+ * Nesting-safe: saves the prior SSR flag and restores it in the `finally`
+ * block. A nested `withSSR(...)` call cannot prematurely flip the outer
+ * scope's SSR flag back to `false`, and an exception thrown inside `fn`
+ * still leaves the flag in its original state.
  */
 declare function withSSR<T>(fn: () => T): T;
 
@@ -986,6 +1206,77 @@ declare function enqueueBatchedSignal(signal: ReactiveSignal): boolean;
  */
 declare function isBatching(): boolean;
 
+/**
+ * Wait for the next microtask — after any currently-pending reactive updates
+ * have been flushed. Useful in imperative code that needs to read DOM state
+ * right after changing a signal.
+ *
+ * Under the hood this resolves on a microtask and again on an animation frame
+ * so both synchronous reactive passes and layout side-effects have settled.
+ *
+ * @returns Promise that resolves after the next DOM flush
+ *
+ * @example
+ * ```ts
+ * setMenuOpen(true);
+ * await nextTick();
+ * menuRef.current?.focus(); // DOM has the new menu rendered
+ * ```
+ */
+declare function nextTick(): Promise<void>;
+
+/**
+ * Create a deferred mirror of a reactive getter. The returned accessor
+ * eventually converges to the source value, but updates on a microtask
+ * + `requestAnimationFrame` pair — so if the source changes repeatedly
+ * in the same frame, only the latest value is ever surfaced.
+ *
+ * Use this for expensive derived views (filtered lists, rich charts)
+ * that should not block fast state changes (typing, cursor movement).
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = signal("");
+ * const deferredQuery = defer(query);
+ *
+ * // input stays instant — it reads query()
+ * input({ on: { input: e => setQuery(e.target.value) } });
+ *
+ * // heavy list reads deferredQuery() and updates one frame later
+ * each(() => heavyFilter(items, deferredQuery()), row => li({ nodes: row.name }));
+ * ```
+ */
+declare function defer<T>(getter: () => T): () => T;
+interface TransitionState {
+    pending: () => boolean;
+    start: (fn: () => void | Promise<void>) => void;
+}
+/**
+ * Create a transition handle. `start(fn)` runs `fn` on the next idle
+ * callback so expensive reactive updates do not block immediate input
+ * events. `pending()` is a reactive boolean that is `true` while a
+ * transition is in flight.
+ *
+ * There is no "interruption" — the runtime has no concept of partial
+ * renders. The transition is cooperative: its body runs when the browser
+ * reports spare time via `requestIdleCallback`. That is sufficient for
+ * the 90% case (defer a heavy update so a click handler can finish first)
+ * and avoids the complexity of an interruptible reconciler.
+ *
+ * Async callbacks are supported: `pending()` stays `true` until the
+ * returned promise resolves OR rejects.
+ *
+ * @example
+ * ```ts
+ * const t = transition();
+ * button({
+ *   disabled: t.pending,
+ *   on: { click: () => t.start(() => setFilter(nextFilter)) },
+ * });
+ * ```
+ */
+declare function transition(): TransitionState;
+
 /**
  * Execute a function without tracking any signal reads as dependencies.
  * Useful for reading signals inside effects without creating subscriptions.
@@ -1067,6 +1358,23 @@ interface ErrorBoundaryProps {
      * Called when an error is caught (sync or async).
      */
     onError?: (error: Error) => void;
+    /**
+     * A list of reactive getters. Whenever any of these values change
+     * after an error has been caught, the boundary automatically resets
+     * (clears the error and re-renders). Useful for recovering from a
+     * failed render after the user navigates, changes filters, or
+     * otherwise picks a new input that might not fail this time.
+     *
+     * @example
+     * ```ts
+     * const [route, setRoute] = signal("/");
+     * ErrorBoundary({
+     *   resetKeys: [route],
+     *   nodes: () => div({ nodes: riskyPageFor(route()) }),
+     * });
+     * ```
+     */
+    resetKeys?: Array<() => unknown>;
 }
 /**
  * ErrorBoundary component using SibuJS reactive pattern.
@@ -1080,7 +1388,57 @@ interface ErrorBoundaryProps {
  * - onError callback for logging/telemetry
  * - Improved CSS styling
  */
-declare function ErrorBoundary({ nodes, fallback, onError }: ErrorBoundaryProps): Element;
+declare function ErrorBoundary({ nodes, fallback, onError, resetKeys }: ErrorBoundaryProps): Element;
+
+type ErrorSeverity = "error" | "warning" | "info";
+interface ErrorDisplayProps {
+    /** The Error (or error-like value) to show. */
+    error: unknown;
+    /** Severity colour. Default `"error"`. */
+    severity?: ErrorSeverity;
+    /** Optional headline override. By default `error.message` is used. */
+    title?: string;
+    /**
+     * Label for the primary action. Shown next to a Reload button.
+     * Leave unset to hide the retry action.
+     */
+    retryLabel?: string;
+    /** Callback for the retry button. */
+    onRetry?: () => void;
+    /**
+     * If `true`, the Reload button is hidden. Useful for embedded
+     * error panels where a full page reload is inappropriate.
+     */
+    hideReload?: boolean;
+    /**
+     * If `true`, the stack trace and metadata are always shown even in
+     * production builds. Default: only shown in dev.
+     */
+    alwaysShowDetails?: boolean;
+    /**
+     * Extra metadata rendered as a key/value list under the message.
+     * Useful for attaching request IDs, user IDs, etc.
+     */
+    metadata?: Record<string, string | number | boolean | null | undefined>;
+}
+/**
+ * Rich error display component. Wire an error-like value in and get
+ * a colored panel back with copy, retry, reload, stack, cause chain,
+ * and metadata — all built from tag factories. Reusable anywhere
+ * (inside `ErrorBoundary`, from a fetch failure, from a form submit).
+ *
+ * @example
+ * ```ts
+ * button({
+ *   on: { click: async () => {
+ *     try { await save(); }
+ *     catch (err) { mount(ErrorDisplay({ error: err, onRetry: save }), errorHost); }
+ *   }},
+ *   nodes: "Save",
+ * });
+ * ```
+ */
+declare function ErrorDisplay(props: ErrorDisplayProps): Element;
 
 interface LoadingProps {
     /** Text to show alongside the spinner */
@@ -1103,4 +1461,4 @@ interface LoadingProps {
  */
 declare function Loading(props?: LoadingProps): HTMLElement;
 
-export { type Accessor, type ActionFn, type ArrayActions, type Context, DynamicComponent, type EffectOptions, ErrorBoundary, type ErrorBoundaryProps, Fragment, KeepAlive, type KeepAliveOptions, Loading, type LoadingProps, type LongPressOptions, NodeChild, NodeChildren, Portal, type Ref, type SignalOptions, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagProps, a, abbr, action, address, area, array, article, aside, audio, autoResize, b, base, batch, bdi, bdo, bindDynamic, blockquote, body, br, button, canvas, caption, catchError, catchErrorAsync, center, checkLeaks, circle, cite, clickOutside, clipPath, code, col, colgroup, context, copyOnClick, customElement, data, datalist, dd, deepEqual, deepSignal, defs, del, derived, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isSSR, kbd, label, lazy, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, memo, memoFn, menu, meta, meter, mount, nav, noscript, object, ol, on, onCleanup, onMount, onUnmount, optgroup, option, output, p, param, path, pattern, picture, polygon, polyline, portal, pre, progress, q, radialGradient, reactiveArray, rect, ref, registerComponent, registerDisposer, resolveComponent, rp, rt, ruby, s, samp, script, section, select, setGlobalErrorHandler, show, signal, slot, small, source, span, stop, store, strong, style, sub, summary, sup, svg, symbol, table, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track, trapFocus, tspan, u, ul, unregisterComponent, untracked, use, var_, video, watch, when, withSSR, writable };
+export { type Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedState, type AudioProps, type ButtonProps, type Context, DynamicComponent, type EffectOptions, ErrorBoundary, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, KeepAlive, type KeepAliveOptions, type LabelProps, Loading, type LoadingProps, type LongPressOptions, type MediaProps, NodeChild, NodeChildren, type OptionProps, Portal, type Ref, type SelectProps, type SignalOptions, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __resetIdCounter, a, abbr, action, address, area, array, article, aside, asyncDerived, audio, autoResize, b, base, batch, bdi, bdo, bindDynamic, blockquote, body, br, button, canvas, caption, catchError, catchErrorAsync, center, checkLeaks, circle, cite, clickOutside, clipPath, code, col, colgroup, context, copyOnClick, createId, customElement, data, datalist, dd, deepEqual, deepSignal, defer, defs, del, derived, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isSSR, kbd, label, lazy, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, nav, nextTick, noscript, object, ol, on, onCleanup, onMount, onUnmount, optgroup, option, output, p, param, path, pattern, picture, polygon, polyline, portal, pre, progress, q, radialGradient, reactiveArray, rect, ref, registerComponent, registerDisposer, resolveComponent, rp, rt, ruby, s, samp, script, section, select, setGlobalErrorHandler, show, signal, slot, small, source, span, stop, store, strict, strictEffect, strong, style, sub, summary, sup, svg, symbol, table, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track, transition, trapFocus, tspan, u, ul, unregisterComponent, untracked, use, var_, video, watch, when, withSSR, writable };