sibujs 4.13.0 → 4.14.0

package/dist/index.d.cts

@@ -4,7 +4,7 @@ import { T as TagProps, a as TagFunction, D as DerivedAccessor } from './tagFact
 export { S as SVG_NS, b as StyleMap, c as StyleObject, d as TagEventHandlers, e as derived, t as tagFactory } from './tagFactory-DkytnJws.cjs';
 import { A as Accessor } from './signal-EotCj4hS.cjs';
 export { D as DisposableAccessor, E as ExternalSource, S as SignalOptions, e as external, s as signal } from './signal-EotCj4hS.cjs';
-export { T as TrustedHTML, t as trustHTML } from './ssr-Db0Sgdu3.cjs';
+export { V as EachBindings, W as EachEventBindings, X as EnhanceContext, Y as EnhanceSetup, Z as IslandLoader, _ as IslandRegistration, $ as IslandStrategy, a0 as LazyIslandLoader, a1 as MountIslandsOptions, T as TrustedHTML, a2 as enhance, a3 as enhanceAll, a4 as lazyIsland, a5 as mountIslands, a6 as registerIsland, u as trustHTML, a7 as unregisterIsland } from './ssr-JpGpHnpC.cjs';
 import { R as ReactiveSignal } from './signal-BnWpq6WB.cjs';
 
 interface ErrorBoundaryOptions {
@@ -207,21 +207,6 @@ declare function setRuntimeErrorHandler(handler: RuntimeErrorHandler | null): Ru
  * @returns The installed handler, or `null` when none is set.
  */
 declare function getRuntimeErrorHandler(): RuntimeErrorHandler | null;
-/**
- * Report an error the runtime caught and contained.
- *
- * Resolution order: nearest claiming `ErrorBoundary` → configured runtime
- * handler → `console.error`. Exactly one of those runs for a given report.
- *
- * Never throws — callers are inside `catch`/`finally` blocks where a secondary
- * failure would corrupt teardown or abort a drain.
- *
- * @public Framework primitive, also usable by plugin/integration code that
- * catches an application exception on SibuJS's behalf (custom rendering
- * primitives, adapters) and wants it to follow the same boundary/handler
- * resolution as a built-in one. Ordinary application code should prefer
- * `ErrorBoundary` or `setRuntimeErrorHandler`.
- */
 declare function reportError(error: unknown, context: RuntimeErrorContext): void;
 
 /**
@@ -360,6 +345,40 @@ declare function catchErrorAsync<T>(fn: () => Promise<T>, onError?: ErrorHandler
  */
 declare function setGlobalErrorHandler(handler: ErrorHandler): void;
 
+/** Options of {@link ClientOnly}. */
+interface ClientOnlyOptions {
+    /**
+     * What the server renders (and what the browser shows until it takes over).
+     * Give it the same size as the content to avoid a layout jump when it is
+     * swapped. Omitted, nothing is rendered on the server.
+     */
+    fallback?: () => NodeChild;
+}
+/**
+ * Render content that only works in a browser — a canvas, `document.fonts`,
+ * `matchMedia`, storage, a third-party widget.
+ *
+ * - **On the server** (an SSR render or the build-time pre-renderer), only
+ *   `fallback` is rendered, so the content's browser APIs never run there.
+ * - **In the browser**, the content renders directly. During an adopting
+ *   hydration the fallback is rendered first, so it binds to the server's
+ *   fallback markup, and the content replaces it in one synchronous swap as
+ *   soon as the hydration ends.
+ *
+ * @param content Builds the browser-only content.
+ * @param options `fallback` for the server and for the first paint.
+ * @returns A directive anchor (like `when`), to place as a child.
+ *
+ * @example
+ * ```ts
+ * // The card ships a plain <img>; the browser recolors it on a <canvas>.
+ * ClientOnly(() => RecoloredCanvas(product), {
+ *   fallback: () => img({ src: product.image, width: 160, height: 160 }),
+ * });
+ * ```
+ */
+declare function ClientOnly(content: () => NodeChild, options?: ClientOnlyOptions): Comment;
+
 /**
  * Context API for SibuJS — a reactive global value that any component
  * can read without prop drilling.
@@ -1522,6 +1541,14 @@ declare function deepSignal<T>(initial: T): [Accessor<T>, (next: T | ((prev: T)
 interface EffectOptions {
     /** Error handler for exceptions thrown during effect execution. */
     onError?: (error: unknown) => void;
+    /**
+     * Also run during a server render. By default an effect is a client-only
+     * side effect and does nothing under SSR. With `server: true` it runs on the
+     * server exactly as in the browser — reactively, until the render is
+     * disposed — which is what a data primitive needs to start a fetch the server
+     * render then awaits. Browser APIs are still off limits inside it.
+     */
+    server?: boolean;
 }
 /**
  * Creates a callback that only tracks the specified dependencies,
@@ -1731,6 +1758,39 @@ interface SSRStore {
      * will ever use. See `plugins/i18n.ts`.
      */
     locale?: string;
+    /**
+     * Async work started inside this request that a server render must wait for
+     * before it serializes: `lazy()` chunks, `query()` / `resource()` fetches, the
+     * router's initial navigation and route loads, `prerenderWait()` promises.
+     * Created by `runInSSRContext`; `settled()` drains it. See `trackPending`.
+     */
+    pending?: Set<PendingWork>;
+    /** Called whenever an entry leaves `pending`, so a waiting `settled()` re-checks. */
+    wake?: (() => void) | null;
+    /**
+     * Errors no `ErrorBoundary` claimed during this request. When present,
+     * `reportError` records them here instead of the console, and an async
+     * server render rejects with the first one.
+     */
+    errors?: Array<{
+        error: Error;
+        context: {
+            phase: string;
+            name?: string;
+            node?: unknown;
+        };
+    }>;
+    /** Request-scoped slots of other subsystems (router, head collector, transferred state). */
+    slots?: Map<string, unknown>;
+}
+/** One unit of async work a server render waits for. */
+interface PendingWork {
+    /** What the work is, for diagnostics: `query:/api/catalog`, `lazy`, `router:navigation`. */
+    readonly label: string;
+    /** `Date.now()` when the work was registered. */
+    readonly since: number;
+    /** The streaming `Suspense` boundary it was started in, if any (see `streamBoundary`). */
+    readonly boundary?: unknown;
 }
 /** Returns the active store (ALS or fallback). */
 declare function getSSRStore(): SSRStore;
@@ -1743,6 +1803,22 @@ declare function isSSR(): boolean;
  * AsyncLocalStorage, giving each request its own caches.
  */
 declare function getRequestScopedCache<V>(name: string): Map<string, V> | null;
+/**
+ * True while the code runs on a server: inside an SSR scope (`runInSSRContext`,
+ * `withSSR`, `enableSSR`) or in the build-time pre-renderer. Use it to keep
+ * browser-only work (canvas, `document.fonts`, storage, `matchMedia`) out of a
+ * server render; `ClientOnly` and `onMount` are usually the better tools.
+ *
+ * @returns `true` on the server, `false` in a browser.
+ */
+declare function isServer(): boolean;
+/**
+ * The opposite of {@link isServer}: true in a browser (or a browser-like test
+ * environment) that is not rendering for a server.
+ *
+ * @returns `true` in a browser, `false` on the server.
+ */
+declare function isClient(): boolean;
 /** Enable SSR mode. Side effects (effect, watch, onMount) become no-ops. */
 declare function enableSSR(): void;
 /** Disable SSR mode. Side effects resume normal behavior. */
@@ -1804,272 +1880,6 @@ declare function strict<T>(fn: () => T): T;
  */
 declare function strictEffect(fn: () => void): () => void;
 
-/** Event handlers for {@link EachBindings}, typed per event name. */
-type EachEventBindings = {
-    [K in keyof HTMLElementEventMap]?: (event: HTMLElementEventMap[K], el: HTMLElement) => void;
-};
-/**
- * What {@link EnhanceContext.each} attaches to one element.
- *
- * Every field maps one-to-one onto an existing `ctx.*` helper and is committed
- * through it — this is a shorthand for calls you could write by hand, not a
- * template language and not a second binding engine. There is no expression
- * parsing, no string interpolation and no `eval`: every value is a plain
- * function you wrote, so it stays CSP-safe and fully type-checked.
- *
- * Anything not covered here (two-way `model()`, listener options, a nested
- * `enhance`) is written imperatively in the same callback — it receives the
- * element, so `ctx.model(el, …)` beside a returned descriptor is normal.
- */
-interface EachBindings {
-    /** Reactive `textContent` — same as `ctx.text(el, value)`. */
-    text?: () => unknown;
-    /** Reactive attributes by name — same as `ctx.attr(el, name, value)`. */
-    attr?: Record<string, () => unknown>;
-    /** Reactive class toggles by class name — same as `ctx.classed(el, name, on)`. */
-    class?: Record<string, () => boolean>;
-    /** Reactive visibility — same as `ctx.show(el, when)`. */
-    show?: () => boolean;
-    /** Event listeners by event name — same as `ctx.on(el, event, handler)`. */
-    on?: EachEventBindings;
-    /** Per-element teardown, run with the rest of the enhancement's cleanups. */
-    cleanup?: () => void;
-}
-/**
- * Helpers handed to an `enhance` setup. Every binding is fine-grained (its own
- * effect) and auto-disposed when the root element (or the returned dispose) is
- * torn down.
- *
- * Target resolution for every helper:
- *   - `"@name"`  → a descendant marked `data-ref="name"` (the ergonomic form).
- *   - any other string → a raw CSS selector, queried within the root.
- *   - an `Element` → used as-is.
- *   - `null` / omitted (where allowed) → the root element itself.
- */
-interface EnhanceContext {
-    /** The enhanced root element (the server-rendered node). */
-    root: HTMLElement;
-    /** First descendant matching a `@ref`/selector (or the root for `null`). */
-    ref<T extends Element = HTMLElement>(target: string | null): T | null;
-    /** All descendants matching a `@ref`/selector. */
-    refs<T extends Element = HTMLElement>(target: string): T[];
-    /** Attach an auto-removed event listener to a target (root if `null`). */
-    on<K extends keyof HTMLElementEventMap>(target: string | Element | null, event: K, handler: (event: HTMLElementEventMap[K], el: HTMLElement) => void, options?: AddEventListenerOptions): void;
-    /** Reactively drive `textContent` of an existing node. */
-    text(target: string | Element | null, value: () => unknown): void;
-    /** Reactively drive an attribute; a `null`/`false`/`undefined` value removes it. */
-    attr(target: string | Element | null, name: string, value: () => unknown): void;
-    /** Reactively toggle a class on a node. */
-    classed(target: string | Element | null, name: string, on: () => boolean): void;
-    /** Reactively toggle visibility (sets `display:none` when `false`). */
-    show(target: string | Element | null, when: () => boolean): void;
-    /** Two-way bind a form control to a `[get, set]` signal tuple. */
-    model<T>(target: string | Element, state: readonly [() => T, (value: T) => void], options?: {
-        event?: string;
-    }): void;
-    /**
-     * Bind a set of elements the server already rendered — a board, a table, a
-     * keyboard, a timeline, a legend — one descriptor at a time.
-     *
-     * The callback receives each element and its index and returns what to
-     * attach; every field is committed through the matching `ctx.*` helper, so
-     * ownership, disposal, write elision, attribute sanitization and error
-     * routing are byte-for-byte the same as writing the calls out by hand. No
-     * element is created, replaced, moved or re-parented — node identity is
-     * preserved, which is the entire point of enhancing existing markup.
-     *
-     * ```ts
-     * ctx.each<HTMLButtonElement>("@square", (el) => {
-     *   const square = el.dataset.square as Square;
-     *   return {
-     *     text: () => pieceAt(square),
-     *     class: { selected: () => selected() === square },
-     *     attr: { "aria-label": () => describe(square) },
-     *     on: { click: () => choose(square) },
-     *   };
-     * });
-     * ```
-     *
-     * The callback may also return nothing and wire the element imperatively —
-     * `ctx.model(el, …)`, `ctx.on(el, "click", h, { passive: true })` — for the
-     * cases the descriptor deliberately does not cover.
-     *
-     * Zero matches is a silent no-op. Calling `each` twice over the same
-     * elements creates two independent sets of bindings, exactly as calling
-     * `ctx.text()` twice on one node does; the helper is sugar over those calls
-     * and does not track what a previous call attached.
-     *
-     * @param target A `@ref`/CSS selector resolved with {@link EnhanceContext.refs},
-     *   or any iterable of elements (an array, a `NodeList`, an `HTMLCollection`).
-     * @param describe Called once per element, in document order.
-     */
-    each<T extends Element = HTMLElement>(target: string | Iterable<Element>, describe: (element: T, index: number) => EachBindings | void): void;
-    /** Register arbitrary teardown to run on disposal. */
-    cleanup(fn: () => void): void;
-}
-/** A setup function for `enhance` — wire reactivity, optionally return cleanup.
- *  The `void | (() => void)` shape mirrors `useEffect`'s "return a teardown, or
- *  nothing". */
-type EnhanceSetup = (ctx: EnhanceContext) => void | (() => void);
-/**
- * Attach reactivity to an existing element (typically server-rendered) without
- * replacing it. Returns a dispose function; disposal is also wired to the
- * element, so removing its subtree cleans everything up.
- *
- * **Setup is a transaction.** If `setup` throws, every binding, listener and
- * cleanup it registered through the {@link EnhanceContext} is torn down and the
- * original error is rethrown unchanged — the element is left exactly as
- * unenhanced as it started, so a retry is legal. The rollback covers
- * framework-owned resources only (`ctx.on`, `ctx.text`, `ctx.attr`,
- * `ctx.classed`, `ctx.show`, `ctx.model`, `ctx.cleanup`, and a cleanup returned
- * from setup); work the setup performed outside those helpers — `innerHTML`
- * writes, network calls, global mutation — cannot be reversed generically, so
- * register its undo with `ctx.cleanup()` as you go.
- *
- * **Ownership.** A successfully enhanced root is marked
- * `data-sibu-enhanced="true"`; disposal removes it. The marker tracks *current*
- * ownership rather than history, so a **disposed root can be enhanced again**,
- * while enhancing a root that is still active is refused (dev-warns) to prevent
- * two competing sets of bindings. See `docs/architecture/enhancement-lifecycle.md`.
- *
- * @param target An `Element` or a CSS selector resolved against `document`
- *   (the first match is used; see {@link enhanceAll} for many).
- * @param setup  Wires reactivity via the {@link EnhanceContext}.
- * @throws Whatever `setup` throws, after rolling its resources back.
- *
- * @example
- * ```ts
- * // server HTML: <div data-counter><b data-ref="n">0</b><button data-ref="inc">+1</button></div>
- * const [n, setN] = signal(0);
- * enhance("[data-counter]", (ctx) => {
- *   ctx.text("@n", () => n());
- *   ctx.on("@inc", "click", () => setN((v) => v + 1));
- * });
- * ```
- */
-declare function enhance(target: Element | string, setup: EnhanceSetup): () => void;
-/**
- * Enhance every element matching a selector. Returns a single dispose that
- * tears down all of them.
- *
- * The whole collection is one transaction: if any element's setup throws, the
- * elements already enhanced are rolled back (newest first, mirroring stack
- * unwinding) and the original error is rethrown. A caller that never received
- * the aggregate disposer is therefore never left holding live enhancements it
- * has no way to release. A teardown that fails during that rollback is reported
- * and skipped — it neither aborts the remaining rollback nor replaces the
- * original setup error.
- *
- * The returned disposer is idempotent, and the collection may be enhanced again
- * afterwards (see {@link enhance} on marker lifetime).
- *
- * @throws Whatever the failing element's setup threw, after rolling back.
- */
-declare function enhanceAll(selector: string, setup: EnhanceSetup): () => void;
-
-/** When an island activates. Declared per-element via `data-sibu-load`. */
-type IslandStrategy = "load" | "idle" | "visible" | "interaction" | "media";
-/** A lazy code loader: resolves to an island setup (or a module whose `default`
- *  is one). Only fetched when the island activates. Wrap with {@link lazyIsland}. */
-type IslandLoader = () => Promise<EnhanceSetup | {
-    default: EnhanceSetup;
-}>;
-/**
- * A loader that has been through {@link lazyIsland}.
- *
- * Exported for callers that want to be explicit about having wrapped one. It is
- * NOT required by {@link IslandRegistration}, and that is deliberate.
- *
- * Requiring the brand would catch a forgotten `lazyIsland(...)` at compile time,
- * which is where a mistake is cheapest to find — but it also rejects code that
- * compiles today, and this package's contract is that the existing public API
- * keeps working, widening rather than replacing, with a codemod for anything
- * that cannot be widened. There is no codemod infrastructure here to ship one
- * through, so the narrowing is not taken: the mistake is caught at mount time
- * instead, by the thenable guard in `enhance()`, which throws immediately with
- * an actionable message and leaves the element unenhanced. Loud and instant at
- * runtime beats a type error that arrives with a breaking change attached.
- *
- * The brand is a phantom STRING-keyed property, never a `unique symbol`. A
- * `unique symbol` has nominal identity per declaration, so two copies of this
- * package's `.d.ts` in one dependency tree would produce two incompatible
- * types. That is not hypothetical: the registry is deliberately shared through
- * `Symbol.for` precisely because duplicate copies are expected. The property
- * exists only in the type — the runtime marker is the global symbol below.
- */
-type LazyIslandLoader = IslandLoader & {
-    readonly __sibujsLazyIsland: true;
-};
-/**
- * Either an inline setup, or a loader.
- *
- * Unchanged from 4.2: an unbranded `IslandLoader` is still accepted, so no
- * previously-compiling code breaks. Wrapping with {@link lazyIsland} is what
- * makes it *work* — see {@link LazyIslandLoader} for why this is not narrowed.
- */
-type IslandRegistration = EnhanceSetup | IslandLoader | LazyIslandLoader;
-/**
- * Mark a loader as lazy island code — its module is fetched only when the island
- * activates, so a page ships ~0 JS for islands that never trigger.
- *
- * @example
- * ```ts
- * registerIsland("chart", lazyIsland(() => import("./islands/chart.js")));
- * ```
- */
-declare function lazyIsland(loader: IslandLoader): LazyIslandLoader;
-/**
- * Register an island by name. The setup is applied via `enhance()` when a
- * matching `[data-sibu-island="name"]` element activates.
- *
- * @example
- * ```ts
- * registerIsland("counter", (ctx) => {
- *   const [n, setN] = signal(0);
- *   ctx.text("@n", () => n());
- *   ctx.on("@inc", "click", () => setN((v) => v + 1));
- * });
- * ```
- */
-declare function registerIsland(name: string, setup: IslandRegistration): void;
-/** Remove a registration (mainly for tests / HMR). */
-declare function unregisterIsland(name: string): void;
-interface MountIslandsOptions {
-    /** IntersectionObserver options for the `visible` strategy. */
-    rootMargin?: string;
-    threshold?: number | number[];
-}
-/**
- * Scan a root for `[data-sibu-island]` elements and activate each according to
- * its `data-sibu-load` strategy (default `load`). Returns a cleanup function
- * that cancels pending schedulers and disposes every mounted island.
- *
- * Strategies (`data-sibu-load`):
- *   - `load`        — activate immediately (next microtask).
- *   - `idle`        — `requestIdleCallback` (falls back to a timeout).
- *   - `visible`     — when the element scrolls into view (IntersectionObserver).
- *   - `interaction` — on first pointer/focus/key/touch interaction.
- *   - `media`       — when `data-sibu-media` (a media query) matches.
- *
- * **Error isolation is lifecycle isolation.** Each island is one `enhance()`
- * transaction, so an island whose setup throws is reported and leaves zero live
- * bindings and zero live listeners; siblings activate normally, and the failed
- * island can be mounted again once its setup is fixed.
- *
- * **Remounting is supported.** Cleanup disposes each island and releases its
- * `data-sibu-enhanced` marker, so the same server markup can be mounted again
- * with a fresh generation. Mounting twice *without* cleanup is also safe:
- * islands that currently own an enhancement are skipped, never double-wired.
- *
- * Activation can never outlive its owner. Cleanup landing before a lazy chunk
- * resolves prevents activation entirely, and cleanup landing *during* a setup
- * disposes the island rather than stranding it — DISPOSED never becomes ACTIVE.
- * `data-sibu-hydrated` is hydration provenance rather than ownership, and is
- * therefore not cleared on disposal; see
- * `docs/architecture/enhancement-lifecycle.md`.
- */
-declare function mountIslands(root?: ParentNode | null, options?: MountIslandsOptions): () => void;
-
 /**
  * Batch multiple state updates into a single notification pass.
  * Subscribers are only notified once after the batch completes,
@@ -2336,4 +2146,4 @@ declare const untracked: ReactiveApi["untracked"];
 declare const retrack: ReactiveApi["retrack"];
 declare const setMaxDrainIterations: ReactiveApi["setMaxDrainIterations"];
 
-export { Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedContext, type AsyncDerivedState, type AudioProps, type ButtonProps, Component, type Context, DerivedAccessor, type DirectiveOptions, DynamicComponent, type EachBindings, type EachEventBindings, type EffectBody, type EffectOptions, type EnhanceContext, type EnhanceSetup, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FocusPolicy, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, type IslandLoader, type IslandRegistration, type IslandStrategy, KeepAlive, type KeepAliveOptions, type LabelProps, type LazyIslandLoader, Loading, type LoadingProps, type LongPressOptions, MAX_DRAIN_TEARDOWNS, type MediaProps, type MountIslandsOptions, NodeChild, NodeChildren, type OnCleanup, type OptionProps, Portal, type Ref, type RuntimeErrorContext, type RuntimeErrorHandler, type RuntimeErrorPhase, type SSRStore, type SelectProps, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagFunction, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __renderParsedTemplate, __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, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enhance, enhanceAll, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getAction, getRequestScopedCache, getRuntimeErrorHandler, getSSRStore, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isSSR, kbd, label, lazy, lazyIsland, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, mountIslands, 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, registerAction, registerComponent, registerDisposer, registerIsland, replaceChildrenSafely, reportDrainRunaway, reportError, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, setRuntimeErrorHandler, show, slot, small, source, span, stop, store, strict, strictEffect, strong, style, sub, summary, sup, svg, symbol, table, takePendingError, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track$1 as track, transition, trapFocus, tspan, u, ul, unregisterComponent, unregisterDisposer, unregisterIsland, untracked, use, var_, video, watch, when, withSSR, writable };
+export { Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedContext, type AsyncDerivedState, type AudioProps, type ButtonProps, ClientOnly, type ClientOnlyOptions, Component, type Context, DerivedAccessor, type DirectiveOptions, DynamicComponent, type EffectBody, type EffectOptions, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FocusPolicy, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, KeepAlive, type KeepAliveOptions, type LabelProps, Loading, type LoadingProps, type LongPressOptions, MAX_DRAIN_TEARDOWNS, type MediaProps, NodeChild, NodeChildren, type OnCleanup, type OptionProps, Portal, type Ref, type RuntimeErrorContext, type RuntimeErrorHandler, type RuntimeErrorPhase, type SSRStore, type SelectProps, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagFunction, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __renderParsedTemplate, __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, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getAction, getRequestScopedCache, getRuntimeErrorHandler, getSSRStore, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isClient, isSSR, isServer, 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, registerAction, registerComponent, registerDisposer, replaceChildrenSafely, reportDrainRunaway, reportError, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, setRuntimeErrorHandler, show, slot, small, source, span, stop, store, strict, strictEffect, strong, style, sub, summary, sup, svg, symbol, table, takePendingError, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track$1 as track, transition, trapFocus, tspan, u, ul, unregisterComponent, unregisterDisposer, untracked, use, var_, video, watch, when, withSSR, writable };