ilha 0.14.9 → 0.15.0

package/dist/define.d.ts

@@ -1,5 +1,4 @@
-import { i as Component } from "./types-CJF2qMK6.js";
+import { i as Component } from "./types-DsdtZMhG.js";
 //#region src/define.d.ts
-declare const define: (name: string, component: Component) => void;
-//#endregion
-export { define };
+export declare const define: (name: string, component: Component) => void;
+//#endregion

package/dist/define.js

@@ -1,4 +1,4 @@
-import { t as mount } from "./mount-BzNrfVW4.js";
+import { t as mount } from "./mount-qJHX_CfF.js";
 
 //#region src/define.ts
 const define = (name, component) => {

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { S as Yielded, b as WatchContext, c as EventSourceStatus, g as UnsafeHtml, h as ResourceOptions, i as Component, l as Fragment, m as ResourceFetcher, n as AtomHandle, o as EventSourceFeed, p as Resource, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, u as Instruction, v as View, x as WatchOnceCleanup, y as WatchCallback } from "./types-CJF2qMK6.js";
-import { t as h } from "./vnode-CUTNGblA.js";
+import { C as WatchOnceCleanup, S as WatchContext, _ as ResourceOptions, b as View, c as EventSourceStatus, d as Instruction, g as ResourceFetcher, h as Resource, i as Component, l as Fragment, n as AtomHandle, o as EventSourceFeed, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, v as UnsafeHtml, w as Yielded, x as WatchCallback } from "./types-DsdtZMhG.js";
+import { t as h } from "./vnode-CpSQZnLM.js";
+import { r as watch } from "./runtime-B-sEGtAa.js";
 import * as Atom from "effect/reactivity/Atom";
 import { Equal } from "effect";
 import * as Effect$1 from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
 import { AtomRegistry } from "effect/reactivity/AtomRegistry";
-import "effect/Scope";
 //#region src/context.d.ts
 interface ContextProviderProps<A> {
   value: A;
@@ -16,9 +16,9 @@ interface IlhaContext<A> {
   readonly defaultValue: A;
   readonly Provider: (props: ContextProviderProps<A>) => View;
 }
-declare const createContext: <A>(defaultValue: A) => IlhaContext<A>;
+export declare const createContext: <A>(defaultValue: A) => IlhaContext<A>;
 /** Read a context value as an atom handle. Subscribes the active fiber on read. */
-declare const context: <A>(ctx: IlhaContext<A>) => AtomHandle<A>;
+export declare const context: <A>(ctx: IlhaContext<A>) => AtomHandle<A>;
 //#endregion
 //#region src/error-boundary.d.ts
 interface ErrorFallbackProps {
@@ -32,42 +32,30 @@ interface ErrorBoundaryProps {
   children?: View;
 }
 /** Catch subtree failures and paint a fallback. Supports reset(). */
-declare const ErrorBoundary: (props: ErrorBoundaryProps) => View;
-//#endregion
-//#region src/watch.d.ts
-/** Values delivered to watch callbacks. */
-type WatchValue = string | number | boolean | bigint | null | undefined | readonly WatchValue[] | WatchRecord;
-interface WatchRecord {
-  readonly [key: string]: WatchValue | undefined;
-}
-interface WatchFn {
-  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream$1.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<undefined>;
-  once: (fn: (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>) => Instruction<undefined>;
-}
-declare const watch: WatchFn;
+export declare const ErrorBoundary: (props: ErrorBoundaryProps) => View;
 //#endregion
 //#region src/atom.d.ts
 /** Key-order-insensitive deep equality for JSON-shaped values. */
-declare const structuralEqual: typeof Equal.equals;
+export declare const structuralEqual: typeof Equal.equals;
 /** Read atoms inside `fn` without subscribing the active render. Sync only. */
-declare const untrack: <A>(fn: () => A) => A;
+export declare const untrack: <A>(fn: () => A) => A;
 interface AtomFn {
   <A>(init: A | Atom.Atom<A> | Effect$1.Effect<A, unknown, AtomRegistry> | Stream$1.Stream<A, unknown, AtomRegistry>, options?: AtomOptions<A>): AtomHandle<A>;
   lazy: <A>(init: () => A) => AtomHandle<A>;
 }
-declare const atom: AtomFn;
-declare const batch: (f: () => void) => void;
+export declare const atom: AtomFn;
+export declare const batch: (f: () => void) => void;
 //#endregion
 //#region src/resource.d.ts
 /** Drop the cached value for `key` and refetch it in live components. */
-declare const invalidate: (key: string) => void;
+export declare const invalidate: (key: string) => void;
 /**
  * Fetch-once, share-everywhere async state for `key`. Concurrent mounts
  * dedupe on one in-flight request; remounts seed from the shared cache
  * (and revalidate when `staleWhileRevalidate` holds). Call unconditionally
  * at the top level of a sync component, before any `await`.
  */
-declare const resource: <T>(key: string, fetcher: ResourceFetcher<T>, opts?: ResourceOptions) => Resource<T>;
+export declare const resource: <T>(key: string, fetcher: ResourceFetcher<T>, opts?: ResourceOptions) => Resource<T>;
 //#endregion
 //#region src/sse.d.ts
 /**
@@ -76,10 +64,10 @@ declare const resource: <T>(key: string, fetcher: ResourceFetcher<T>, opts?: Res
  * an empty stream with status `"closed"`. Call unconditionally at the top
  * level of a component.
  */
-declare const fromEventSource: <T = string>(url: string, opts?: EventSourceOptions<T>) => EventSourceFeed<T>;
+export declare const fromEventSource: <T = string>(url: string, opts?: EventSourceOptions<T>) => EventSourceFeed<T>;
 //#endregion
 //#region src/when.d.ts
-declare const when: <A, E = never, R = never>(stream: Stream$1.Stream<A, E, R>, body: (value: A) => Generator<Yielded, View | undefined, View>) => Instruction<undefined, E>;
+export declare const when: <A, E = never, R = never>(stream: Stream$1.Stream<A, E, R>, body: (value: A) => Generator<Yielded, View | undefined, View>) => Instruction<undefined, E>;
 //#endregion
 //#region src/mount.d.ts
 interface RenderToStringOptions {
@@ -90,10 +78,14 @@ interface RenderToStringOptions {
 }
 interface MountOptions {
   hydrate?: boolean;
-  onError?: <E>(error: E) => void;
+  /**
+   * Called with a failing root component, and with a nested component no
+   * `ErrorBoundary` caught, before the error view paints.
+   */
+  onError?: (error: Error) => void;
 }
-declare const mount: (el: Element, fn: Component, opts?: MountOptions) => (() => void);
-declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => Promise<string>;
+export declare const mount: (el: Element, fn: Component, opts?: MountOptions) => (() => void);
+export declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => Promise<string>;
 //#endregion
 //#region src/unsafe.d.ts
 /**
@@ -104,6 +96,6 @@ declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => P
  * scripts inserted this way do not run, but event attributes and other
  * markup still apply.
  */
-declare const unsafe: (html: string) => UnsafeHtml;
+export declare const unsafe: (html: string) => UnsafeHtml;
 //#endregion
-export { type AtomEquality, type AtomHandle, type AtomOptions, type Component, type ContextProviderProps, ErrorBoundary, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, type EventSourceFeed, type EventSourceOptions, type EventSourceStatus, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type Resource, type ResourceFetcher, type ResourceOptions, type UnsafeHtml, type View, type WatchCallback, type WatchContext, type WatchOnceCleanup, atom, batch, context, createContext, fromEventSource, h, invalidate, mount, renderToString, resource, structuralEqual, unsafe, untrack, watch, when };
+export { type AtomEquality, type AtomHandle, type AtomOptions, type Component, type ContextProviderProps, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, type EventSourceFeed, type EventSourceOptions, type EventSourceStatus, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type Resource, type ResourceFetcher, type ResourceOptions, type UnsafeHtml, type View, type WatchCallback, type WatchContext, type WatchOnceCleanup, h, watch };

package/dist/index.js

@@ -1,5 +1,6 @@
-import { _ as makeFiber, a as interpret, c as handleOwner, d as structuralEqual, f as untrack, g as getFiber, h as closeFiber, i as runSetup, l as instr, m as clearFiberView, n as renderToString, o as atom, p as wrapHandle, r as unsafe, s as batch, t as mount, u as isAtomHandle } from "./mount-BzNrfVW4.js";
-import { d as errorView, g as isString, i as Fragment, p as isFunction, t as h } from "./vnode-M-oJMKcv.js";
+import { _ as isString, f as errorView, i as Fragment, m as isFunction, t as h } from "./vnode-BHUY61Rm.js";
+import { C as makeFiber, S as getFiber, _ as structuralEqual, b as clearFiberView, d as interpret, f as atom, g as isAtomHandle, h as instr, m as handleOwner, n as unsafe, p as batch, u as runSetup, v as untrack, x as closeFiber, y as wrapHandle } from "./paint-core-Cw1HbMp6.js";
+import { n as renderToString, t as mount } from "./mount-qJHX_CfF.js";
 import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";

package/dist/jsx-dev-runtime.d.ts

@@ -1,4 +1,4 @@
-import { l as Fragment } from "./types-CJF2qMK6.js";
-import { n as JSX } from "./vnode-CUTNGblA.js";
+import { l as Fragment } from "./types-DsdtZMhG.js";
+import { n as JSX } from "./vnode-CpSQZnLM.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 export { Fragment, type JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-dev-runtime.js

@@ -1,4 +1,4 @@
-import { i as Fragment } from "./vnode-M-oJMKcv.js";
+import { i as Fragment } from "./vnode-BHUY61Rm.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 
 export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.ts

@@ -1,8 +1,8 @@
-import { a as ComponentFn, d as JsxComponent, f as PropBag, l as Fragment, v as View } from "./types-CJF2qMK6.js";
-import { n as JSX, t as h } from "./vnode-CUTNGblA.js";
+import { a as ComponentFn, b as View, f as JsxComponent, l as Fragment, p as PropBag } from "./types-DsdtZMhG.js";
+import { n as JSX, t as h } from "./vnode-CpSQZnLM.js";
 //#region src/jsx-runtime.d.ts
-declare const jsx: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
-declare const jsxs: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
-declare const jsxDEV: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
+export declare const jsx: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;
 //#endregion
-export { Fragment, type JSX, type View, h, jsx, jsxDEV, jsxs };
+export { Fragment, type JSX, type View, h };

package/dist/jsx-runtime.js

@@ -1,4 +1,4 @@
-import { i as Fragment, t as h } from "./vnode-M-oJMKcv.js";
+import { i as Fragment, t as h } from "./vnode-BHUY61Rm.js";
 
 //#region src/jsx-runtime.ts
 const jsx = (type, props, key) => h(type, key === void 0 ? props : {

package/dist/mount-qJHX_CfF.js

@@ -0,0 +1,482 @@
+import { _ as isString, c as KEEP, d as defer, g as isObject, m as isFunction, r as isVNode, u as SLOT_ATTR, y as unwrap } from "./vnode-BHUY61Rm.js";
+import { T as makeRuntime, a as morphInner, c as bindEvents, i as insertRendered, l as eventTypeFromProp, o as placeChildren, r as committedElement, s as standInFor, t as createPainter, u as runSetup, w as makeRootFiber, x as closeFiber } from "./paint-core-Cw1HbMp6.js";
+
+//#region src/paint.ts
+const noopDisconnect = () => {};
+const core$1 = createPainter({
+	appendRoot: (root, node) => insertRendered(root, node, null),
+	asElement: (el) => el,
+	asNode: (host) => host,
+	asRoot: (el) => el,
+	bindEvents,
+	committed: committedElement,
+	createElement: (tag, ns) => ns ? document.createElementNS(ns, tag) : document.createElement(tag),
+	createRaw: (html, parent) => {
+		const range = document.createRange();
+		range.selectNodeContents(parent);
+		return [...range.createContextualFragment(html).childNodes];
+	},
+	createSlotHost: (slotId) => {
+		const host = document.createElement("span");
+		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
+		host.style.display = "contents";
+		return host;
+	},
+	createText: (text) => document.createTextNode(text),
+	disconnect: noopDisconnect,
+	placeChildren: (root, nodes) => {
+		if (root instanceof Element) placeChildren(root, nodes);
+	},
+	reuseNode: (host) => host instanceof Element && host.isConnected ? standInFor(host) : host,
+	setFormControl: (el, key, v) => {
+		const node = el;
+		if (key === "value") {
+			if (v === null || v === void 0) {
+				el.removeAttribute("value");
+				node.value = "";
+			} else {
+				el.setAttribute("value", String(v));
+				node.value = String(v);
+			}
+		} else if (key === "checked") {
+			node.checked = Boolean(v);
+			if (v) el.setAttribute("checked", "");
+			else el.removeAttribute("checked");
+		} else {
+			node.selected = Boolean(v);
+			if (v) el.setAttribute("selected", "");
+			else el.removeAttribute("selected");
+		}
+	},
+	setStyle: (el, css) => {
+		el.style.cssText = css;
+	}
+});
+const refreshAtomHost = (fiber, atom, host, hole) => {
+	if (hole.closed || !host.isConnected) return;
+	const next = unwrap(fiber.registry.get(atom));
+	if (next === KEEP) return;
+	core$1.paintHole(hole, next);
+};
+const refreshAllAtomHosts = (fiber) => {
+	for (const h of fiber.holes) if (h.atom && h.host && h.holeFiber) refreshAtomHost(fiber, h.atom, h.host, h.holeFiber);
+};
+const pruneDisconnectedAtomHoles = (fiber) => {
+	fiber.holes = fiber.holes.filter((h) => {
+		if (!h.atom || !h.host || !h.holeFiber) return true;
+		if (h.host.isConnected) return true;
+		h.dispose();
+		return false;
+	});
+};
+const canHydrate = (fiber, view) => {
+	if (!isVNode(view) || !isString(view.type)) return false;
+	const el = fiber.root.firstElementChild;
+	return !!el && el.tagName === view.type.toUpperCase();
+};
+const paintHydrate = (fiber, view) => {
+	const el = fiber.root.firstElementChild;
+	if (!el) return;
+	fiber.hydrate = false;
+	fiber.liveEl = el;
+	core$1.applyProps(el, view.props, fiber);
+	const childFiber = {
+		...fiber,
+		holes: fiber.holes,
+		root: el
+	};
+	el.replaceChildren();
+	for (const c of view.children) for (const n of core$1.materialize(c, childFiber)) insertRendered(el, n, null);
+};
+const paintMorphLive = (fiber, view) => {
+	if (!fiber.liveEl) return;
+	core$1.disposeHoles(fiber, { morph: true });
+	core$1.applyProps(fiber.liveEl, view.props, fiber);
+	const liveNs = fiber.liveEl.namespaceURI;
+	const tmp = liveNs && liveNs !== "http://www.w3.org/1999/xhtml" ? document.createElementNS(liveNs, fiber.liveEl.localName) : document.createElement(fiber.liveEl.localName);
+	const childFiber = {
+		...fiber,
+		holes: fiber.holes,
+		root: tmp
+	};
+	for (const c of view.children) for (const n of core$1.materialize(c, childFiber)) tmp.append(n);
+	morphInner(fiber.liveEl, tmp);
+	refreshAllAtomHosts(fiber);
+	pruneDisconnectedAtomHoles(fiber);
+};
+const paintRoot = (fiber, view) => {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	if (fiber.hydrate) {
+		if (canHydrate(fiber, view)) {
+			paintHydrate(fiber, view);
+			return;
+		}
+		console.warn("[ilha] hydrate mismatch, full mount");
+		fiber.hydrate = false;
+		if (fiber.root instanceof Element) fiber.root.replaceChildren();
+	}
+	if (fiber.liveEl && isVNode(view) && isString(view.type) && fiber.liveEl.localName === view.type) {
+		paintMorphLive(fiber, view);
+		return;
+	}
+	core$1.disposeHoles(fiber, { morph: true });
+	if (fiber.root instanceof Element && fiber.root.childNodes.length > 0) {
+		const tmp = document.createElement("div");
+		for (const n of core$1.materialize(view, fiber)) tmp.append(n);
+		morphInner(fiber.root, tmp);
+		const first = fiber.root.firstElementChild;
+		if (first) fiber.liveEl = first;
+		return;
+	}
+	core$1.insert(fiber, core$1.materialize(view, fiber));
+	const first = fiber.root instanceof Element ? fiber.root.firstElementChild : null;
+	if (first) fiber.liveEl = first;
+};
+const paint$1 = (fiber, view) => {
+	core$1.commit(() => {
+		core$1.pass(fiber, () => {
+			paintRoot(fiber, view);
+		});
+	});
+};
+
+//#endregion
+//#region src/snapshot.ts
+const MAX_SNAPSHOT_CHARS = 262144;
+const MAX_SNAPSHOT_DEPTH = 32;
+const exceedsMaxDepth = (value, depth) => {
+	if (depth > MAX_SNAPSHOT_DEPTH) return true;
+	if (value === null || !isObject(value)) {
+		if (Array.isArray(value)) {
+			for (const item of value) if (exceedsMaxDepth(item, depth + 1)) return true;
+		}
+		return false;
+	}
+	const obj = value;
+	for (const key of Object.keys(obj)) if (exceedsMaxDepth(obj[key], depth + 1)) return true;
+	return false;
+};
+const deleteUnsafeKey = (obj, key) => {
+	if (Object.hasOwn(obj, key)) Reflect.deleteProperty(obj, key);
+};
+const stripUnsafeKeys = (value) => {
+	if (Array.isArray(value)) {
+		for (const item of value) stripUnsafeKeys(item);
+		return;
+	}
+	if (value === null || !isObject(value)) return;
+	const obj = value;
+	deleteUnsafeKey(obj, "__proto__");
+	deleteUnsafeKey(obj, "constructor");
+	deleteUnsafeKey(obj, "prototype");
+	for (const key of Object.getOwnPropertyNames(obj)) stripUnsafeKeys(obj[key]);
+};
+const safeParseSnapshot = (raw) => {
+	if (raw.length > MAX_SNAPSHOT_CHARS) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (exceedsMaxDepth(parsed, 1)) return;
+	if (!isObject(parsed) || Array.isArray(parsed)) return;
+	stripUnsafeKeys(parsed);
+	return parsed;
+};
+const encodeSnapshot = (values) => JSON.stringify({ v: values });
+const decodeSnapshot = (raw) => {
+	const values = safeParseSnapshot(raw)?.v;
+	return Array.isArray(values) ? values : void 0;
+};
+
+//#endregion
+//#region src/ssr-dom.ts
+const VOID = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Tags whose children are raw text — do not HTML-escape content. */
+const RAW_TEXT = /* @__PURE__ */ new Set(["script", "style"]);
+const escapeText = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const escapeAttr = (s) => escapeText(s).replaceAll("\"", "&quot;");
+const createSsrRaw = (html) => ({
+	html,
+	kind: "raw"
+});
+const createSsrText = (text) => ({
+	kind: "text",
+	text
+});
+const serializeRawText = (tag, text) => {
+	if (new RegExp(`</${tag}\\b`, "iu").test(text)) throw new Error(`ilha: unsafe raw text in <${tag}> (contains "</${tag}")`);
+	return text;
+};
+const serializeNode = (node) => {
+	if (node.kind === "text") return escapeText(node.text);
+	if (node.kind === "raw") return node.html;
+	const parts = [];
+	for (const [name, value] of node.attrs) parts.push(`${name}="${escapeAttr(value)}"`);
+	const attr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+	const { tag } = node;
+	if (VOID.has(tag)) return `<${tag}${attr}>`;
+	if (RAW_TEXT.has(tag)) return `<${tag}${attr}>${serializeRawText(tag, node.textContent)}</${tag}>`;
+	return `<${tag}${attr}>${node.children.map(serializeNode).join("")}</${tag}>`;
+};
+const toDataAttr = (key) => `data-${key.replaceAll(/[A-Z]/gu, (ch) => `-${ch.toLowerCase()}`)}`;
+const isSymbolKey = (value) => Object.prototype.toString.call(value) === "[object Symbol]";
+const createSsrElement = (tag) => {
+	const lower = tag.toLowerCase();
+	const children = [];
+	const el = {
+		append: (...nodes) => {
+			children.push(...nodes);
+		},
+		appendChild: (node) => {
+			children.push(node);
+		},
+		attrs: /* @__PURE__ */ new Map(),
+		children,
+		dataset: new Proxy({}, {
+			get: (_t, prop) => {
+				if (prop === "undefined" || isSymbolKey(prop)) return;
+				return el.getAttribute(toDataAttr(prop)) ?? void 0;
+			},
+			set: (_t, prop, value) => {
+				if (isSymbolKey(prop)) return false;
+				const attr = toDataAttr(prop);
+				if (value === void 0 || value === null) el.removeAttribute(attr);
+				else el.setAttribute(attr, String(value));
+				return true;
+			}
+		}),
+		getAttribute: (name) => {
+			const value = el.attrs.get(name);
+			return value === void 0 ? null : value;
+		},
+		hasAttribute: (name) => el.attrs.has(name),
+		isConnected: true,
+		kind: "element",
+		localName: lower,
+		removeAttribute: (name) => {
+			el.attrs.delete(name);
+		},
+		replaceChildren: (...nodes) => {
+			children.length = 0;
+			children.push(...nodes);
+		},
+		setAttribute: (name, value) => {
+			el.attrs.set(name, value);
+		},
+		tag: lower,
+		tagName: lower.toUpperCase(),
+		get textContent() {
+			return children.map((n) => {
+				if (n.kind === "text") return n.text;
+				if (n.kind === "raw") return n.html;
+				return n.textContent;
+			}).join("");
+		},
+		set textContent(value) {
+			children.length = 0;
+			children.push(createSsrText(value));
+		}
+	};
+	return el;
+};
+const createSsrRoot = () => {
+	const children = [];
+	return {
+		append: (...nodes) => {
+			children.push(...nodes);
+		},
+		appendChild: (node) => {
+			children.push(node);
+		},
+		children,
+		get innerHTML() {
+			return children.map(serializeNode).join("");
+		},
+		kind: "root",
+		replaceChildren: () => {
+			children.length = 0;
+		}
+	};
+};
+
+//#endregion
+//#region src/ssr-paint.ts
+const ssrAs = (n) => n;
+const ACTION_CALL = Symbol.for("ilha.actionCall");
+const bindSsrEvents = (el, props, fiber) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(props)) {
+		const type = eventTypeFromProp(key);
+		if (!type || seen.has(type)) continue;
+		seen.add(type);
+		const fn = props[key];
+		if (!isFunction(fn)) continue;
+		const branded = fn[ACTION_CALL];
+		const rec = branded?.k ? {
+			a: branded.a ?? [],
+			k: branded.k
+		} : void 0;
+		if (!rec) continue;
+		const id = `${type}:${fiber.runtime.ssrEventI}`;
+		fiber.runtime.ssrEventI += 1;
+		fiber.runtime.ssrActions[id] = rec;
+		const existing = el.dataset.ilhaOn;
+		el.dataset.ilhaOn = existing ? `${existing},${id}` : id;
+	}
+};
+const core = createPainter({
+	appendRoot: (root, node) => ssrAs(root).append(node),
+	asElement: (el) => ssrAs(el),
+	asNode: (host) => ssrAs(host),
+	asRoot: (el) => ssrAs(el),
+	bindEvents: bindSsrEvents,
+	committed: (el) => el,
+	createElement: createSsrElement,
+	createRaw: (html, _parent) => [createSsrRaw(html)],
+	createSlotHost: (slotId) => {
+		const host = createSsrElement("span");
+		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
+		host.setAttribute("style", "display:contents");
+		return host;
+	},
+	createText: createSsrText,
+	disconnect: (el) => {
+		el.isConnected = false;
+	},
+	placeChildren: (root, nodes) => {
+		const host = ssrAs(root);
+		host.replaceChildren();
+		for (const n of nodes) host.append(n);
+	},
+	reuseNode: (host) => ssrAs(host),
+	setFormControl: (el, key, v) => {
+		if (key === "value") el.setAttribute("value", String(v ?? ""));
+		else if (v) el.setAttribute(key, "");
+		else el.removeAttribute(key);
+	},
+	setStyle: (el, css) => el.setAttribute("style", css)
+});
+const paint = (fiber, view) => {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	core.pass(fiber, () => {
+		core.disposeHoles(fiber);
+		ssrAs(fiber.root).replaceChildren();
+		core.insert(fiber, core.materialize(view, fiber));
+	});
+};
+const attachSsr = (fn, opts) => {
+	const root = createSsrRoot();
+	const runtime = makeRuntime({
+		onError: opts?.onError,
+		ssr: true,
+		ssrCapture: opts?.ssrCapture === true
+	});
+	const { promise: ready, resolve } = defer();
+	const fiber = makeRootFiber({
+		paint,
+		root: ssrAs(root),
+		runtime,
+		settle: resolve
+	});
+	runtime.begin();
+	runtime.setIdle(resolve);
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		ready,
+		root,
+		runtime,
+		unmount: () => {
+			closeFiber(fiber);
+			runtime.close();
+			root.replaceChildren();
+		}
+	};
+};
+
+//#endregion
+//#region src/mount.ts
+const readHydrate = (el) => {
+	const raw = (el.matches("[data-ilha]") ? el : el.querySelector("[data-ilha]"))?.dataset.ilhaState;
+	if (raw) return decodeSnapshot(raw);
+	const first = el.firstElementChild;
+	if (first?.tagName === "TEMPLATE" && first.matches("[data-ilha-state]")) {
+		const tplRaw = first.dataset.ilhaState;
+		first.remove();
+		return tplRaw ? decodeSnapshot(tplRaw) : void 0;
+	}
+};
+const delay = (ms) => {
+	const { promise, resolve } = defer();
+	setTimeout(resolve, ms);
+	return promise;
+};
+const attach = (el, fn, opts) => {
+	if (!opts?.hydrate) el.innerHTML = "";
+	const runtime = makeRuntime({
+		hydrate: opts?.hydrate ? readHydrate(el) : void 0,
+		onError: opts?.onError
+	});
+	const { promise: ready, resolve } = defer();
+	const fiber = makeRootFiber({
+		paint: paint$1,
+		root: el,
+		runtime,
+		settle: resolve
+	});
+	if (opts?.hydrate) fiber.hydrate = true;
+	runtime.begin();
+	runtime.setIdle(resolve);
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		ready,
+		runtime,
+		unmount: () => {
+			closeFiber(fiber);
+			runtime.close();
+			if (!opts?.hydrate) el.innerHTML = "";
+		}
+	};
+};
+const mount = (el, fn, opts) => attach(el, fn, opts).unmount;
+const renderToString = async (fn, opts) => {
+	const snapshot = opts?.snapshot !== false;
+	const markers = opts?.markers !== false;
+	const { unmount, ready, runtime, root } = attachSsr(fn, { ssrCapture: opts?.captureActions === true });
+	const timeout = opts?.timeout;
+	await (timeout === void 0 ? ready : Promise.race([ready, delay(timeout)]));
+	let inner = root.innerHTML;
+	const actions = runtime.ssrActions;
+	if (Object.keys(actions).length > 0) inner = `<template data-ilha-actions="${escapeAttr(JSON.stringify(actions))}"></template>${inner}`;
+	const snap = snapshot ? encodeSnapshot(runtime.ssrValues) : void 0;
+	unmount();
+	if (!markers) return snap ? `<template data-ilha-state="${escapeAttr(snap)}"></template>${inner}` : inner;
+	return `<div data-ilha${snap ? ` data-ilha-state="${escapeAttr(snap)}"` : ""}>${inner}</div>`;
+};
+
+//#endregion
+export { renderToString as n, mount as t };