ilha 0.14.3 → 0.14.4

package/dist/mount-hD-OyLIo.js

@@ -0,0 +1,1519 @@
+import { _ as skip, a as ISLAND, b as failureMessage, c as KEEP, d as errorView, f as isBigInt, g as isString, h as isObject, i as Fragment, l as KEY_ATTR, m as isNumber, n as isSetupFn, o as ISLAND_MOUNT_INTERNAL, p as isFunction, r as isVNode, s as ISLAND_SLOT_TAG, u as SLOT_ATTR, v as unwrap, y as asFailure } from "./vnode-DP76Gn-b.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Scope from "effect/Scope";
+import * as Registry from "effect/unstable/reactivity/AtomRegistry";
+
+//#region src/runtime.ts
+const stack = [];
+const getFiber = () => {
+	const f = stack.findLast((x) => !x.closed);
+	if (!f) throw new Error("ilha: no fiber");
+	return f;
+};
+const getActiveFiber = () => stack.findLast((x) => !x.closed);
+const withFiber = (fiber, fn) => {
+	stack.push(fiber);
+	try {
+		return fn();
+	} finally {
+		stack.pop();
+	}
+};
+const provide = (effect, registry) => effect.pipe(Effect.provideService(Registry.AtomRegistry, registry));
+const runInScope = (effect, registry, scope, onOk, onErr, onDone) => {
+	const provided = provide(effect, registry);
+	const f = Effect.runFork(onOk || onDone ? provided.pipe(Effect.onExit((ex) => Effect.sync(() => {
+		onDone?.();
+		if (Exit.isSuccess(ex)) onOk?.(ex.value);
+		else if (!Cause.hasInterruptsOnly(ex.cause)) onErr?.(Cause.squash(ex.cause));
+	}))) : provided);
+	Effect.runSync(Scope.addFinalizer(scope, Fiber.interrupt(f)));
+};
+const closeFiber = (fiber) => {
+	if (fiber.closed) return;
+	fiber.closed = true;
+	fiber.trackRestore?.();
+	fiber.trackRestore = void 0;
+	fiber.renderSub?.();
+	fiber.renderSub = void 0;
+	for (const slot of fiber.watchSlots ?? []) slot?.dispose();
+	fiber.watchSlots = [];
+	for (const h of fiber.holes) h.dispose();
+	fiber.holes = [];
+	Effect.runFork(Scope.close(fiber.scope, Exit.void));
+};
+const makeRuntime = (opts) => {
+	const registry = Registry.make();
+	const scope = Scope.makeUnsafe();
+	let holeSeq = 0;
+	let pending = 0;
+	let onIdle;
+	const runtime = {
+		begin: () => {
+			pending += 1;
+		},
+		close: () => {
+			onIdle = void 0;
+			Effect.runFork(Scope.close(scope, Exit.void));
+			registry.dispose();
+		},
+		end: () => {
+			pending -= 1;
+			if (pending === 0) onIdle?.();
+		},
+		hydrateI: 0,
+		hydrateValues: opts?.hydrate,
+		later: (fn) => {
+			runtime.begin();
+			queueMicrotask(() => {
+				try {
+					fn();
+				} finally {
+					runtime.end();
+				}
+			});
+		},
+		nextHole: () => {
+			holeSeq += 1;
+			return holeSeq;
+		},
+		registry,
+		scope,
+		setIdle: (onReady) => {
+			onIdle = onReady;
+			if (pending === 0) return onReady();
+		},
+		ssr: opts?.ssr === true,
+		ssrActions: {},
+		ssrCapture: opts?.ssrCapture === true,
+		ssrEventI: 0,
+		ssrValues: []
+	};
+	return runtime;
+};
+const makeFiber = (runtime, root, paint, opts) => {
+	const scope = Scope.forkUnsafe(runtime.scope);
+	const fiber = {
+		closed: false,
+		fail: (e) => {
+			opts?.onFail?.(e);
+		},
+		holes: [],
+		inFlight: false,
+		paint: (view) => paint(fiber, view),
+		paintFn: paint,
+		registry: runtime.registry,
+		root,
+		run: (effect, onOk, onErr) => {
+			if (fiber.closed) return;
+			if (onOk) fiber.runtime.begin();
+			runInScope(effect, fiber.registry, fiber.scope, onOk && ((a) => {
+				if (!fiber.closed) withFiber(fiber, () => onOk(a));
+			}), onErr && ((e) => {
+				if (!fiber.closed) withFiber(fiber, () => onErr(e));
+			}), onOk && (() => fiber.runtime.end()));
+		},
+		runtime,
+		scope
+	};
+	return fiber;
+};
+
+//#endregion
+//#region src/atom.ts
+const handleOwner = /* @__PURE__ */ new WeakMap();
+const guardHandleFiber = (handle) => {
+	const owner = handleOwner.get(handle);
+	if (!owner) return;
+	const active = getActiveFiber();
+	if (!active || active.registry === owner.registry) return;
+	throw new Error("ilha: atom handle used from a different island");
+};
+const instr = (effect) => {
+	const fiber = getFiber();
+	const out = {
+		$$ilhaOp: 1,
+		effect,
+		*[Symbol.iterator]() {
+			return yield out;
+		}
+	};
+	const awaitInstruction = async (onFulfilled, onRejected) => {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		fiber.run(out.effect, (a) => {
+			withFiber(fiber, () => resolve(a));
+		}, reject);
+		try {
+			const value = await promise;
+			onFulfilled?.(value);
+		} catch (error) {
+			onRejected?.(error);
+		}
+	};
+	Object.defineProperty(out, "then", { value: awaitInstruction });
+	return out;
+};
+const isAtomHandle = (x) => isFunction(x) && x.$$atom === 1;
+let trackGet;
+const trackStack = [];
+const beginPrimitiveFrame = (fiber) => {
+	const used = fiber.primitiveI ?? 0;
+	const slots = fiber.primitives?.length ?? 0;
+	if (used > 0 && used !== slots) console.warn(`ilha: atom/watch slot count changed between renders (${slots} → ${used}); keep primitive order stable`);
+	fiber.primitiveI = 0;
+	fiber.watchI = 0;
+	if (!fiber.islandFrame) fiber.islandFrame = {
+		i: 0,
+		slots: []
+	};
+	const { islandFrame } = fiber;
+	const usedIslands = islandFrame.i;
+	if (usedIslands < islandFrame.slots.length) {
+		for (let j = usedIslands; j < islandFrame.slots.length; j += 1) {
+			const slot = islandFrame.slots[j];
+			if (slot) {
+				slot.unmount?.();
+				islandFrame.slots[j] = void 0;
+			}
+		}
+		islandFrame.slots.length = usedIslands;
+	}
+	islandFrame.i = 0;
+};
+const readTracked = (atom, registry) => {
+	const frame = trackStack.at(-1);
+	const active = getActiveFiber();
+	if (trackGet && frame && (active === frame.fiber || active === void 0)) return trackGet(atom);
+	return registry.get(atom);
+};
+const usePrimitiveSlot = (fiber, make) => {
+	const i = fiber.primitiveI ?? 0;
+	fiber.primitiveI = i + 1;
+	fiber.primitives ??= [];
+	const existing = fiber.primitives[i];
+	if (existing) return {
+		atom: existing,
+		fresh: false
+	};
+	const a = make();
+	fiber.primitives[i] = a;
+	return {
+		atom: a,
+		fresh: true
+	};
+};
+const withTrackGetRun = (fiber, fn, onOk, onErr) => {
+	const deps = /* @__PURE__ */ new Set();
+	const get = (a) => {
+		deps.add(a);
+		return fiber.registry.get(a);
+	};
+	const restore = () => {
+		if (fiber.trackRestore !== restore) return;
+		const top = trackStack.pop();
+		if (top?.get !== get) {
+			if (top) trackStack.push(top);
+			const i = trackStack.findIndex((frame) => frame.get === get);
+			if (i !== -1) trackStack.splice(i, 1);
+		}
+		trackGet = trackStack.at(-1)?.get;
+		fiber.trackRestore = void 0;
+	};
+	trackStack.push({
+		deps,
+		fiber,
+		get
+	});
+	trackGet = get;
+	fiber.trackRestore = restore;
+	try {
+		const result = withFiber(fiber, () => fn());
+		if (result instanceof Promise) {
+			const settle = async () => {
+				try {
+					const value = await result;
+					restore();
+					if (fiber.closed) return;
+					onOk({
+						deps,
+						value
+					});
+				} catch (error) {
+					restore();
+					if (fiber.closed) return;
+					onErr(error);
+				}
+			};
+			settle();
+			return;
+		}
+		restore();
+		onOk({
+			deps,
+			value: result
+		});
+	} catch (error) {
+		restore();
+		onErr(error);
+	}
+};
+const subscribeRenderDeps = (fiber, deps, run) => {
+	let scheduled = false;
+	const schedule = () => {
+		if (scheduled) return;
+		scheduled = true;
+		fiber.runtime.later(() => {
+			scheduled = false;
+			run();
+		});
+	};
+	const unsubs = [];
+	for (const dep of deps) unsubs.push(fiber.registry.subscribe(dep, schedule));
+	return () => {
+		for (const unsub of unsubs) unsub();
+	};
+};
+const wrapHandle = (atom, fiber) => {
+	const { registry } = fiber;
+	const read = (() => {
+		guardHandleFiber(read);
+		return readTracked(atom, registry);
+	});
+	handleOwner.set(read, fiber);
+	Object.defineProperties(read, {
+		$$atom: { value: 1 },
+		atom: { value: atom },
+		set: { value: (n) => {
+			guardHandleFiber(read);
+			if (Atom.isWritable(atom)) registry.set(atom, n);
+		} },
+		update: { value: (f) => {
+			guardHandleFiber(read);
+			if (Atom.isWritable(atom)) registry.update(atom, f);
+		} }
+	});
+	return read;
+};
+const makeAtom = (init) => {
+	const fiber = getFiber();
+	const snap = fiber.runtime.hydrateValues;
+	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
+		let seed = init;
+		if (snap && !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init)) {
+			const v = snap[fiber.runtime.hydrateI];
+			fiber.runtime.hydrateI += 1;
+			if (v !== void 0) seed = v;
+		}
+		if (Atom.isAtom(seed)) return seed;
+		if (Effect.isEffect(seed) || Stream.isStream(seed)) return Atom.make(seed);
+		return Atom.make(seed);
+	});
+	const handle = wrapHandle(a, fiber);
+	if (fresh && fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
+	return handle;
+};
+const atomLazy = (init) => {
+	const fiber = getFiber();
+	const snap = fiber.runtime.hydrateValues;
+	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
+		let seed = init();
+		if (snap) {
+			const v = snap[fiber.runtime.hydrateI];
+			fiber.runtime.hydrateI += 1;
+			if (v !== void 0) seed = v;
+		}
+		return Atom.make(seed);
+	});
+	const handle = wrapHandle(a, fiber);
+	if (fresh && fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
+	return handle;
+};
+const atom = Object.assign(makeAtom, { lazy: atomLazy });
+const { batch } = Atom;
+
+//#endregion
+//#region src/interpret.ts
+const isInstruction = (x) => isObject(x) && x.$$ilhaOp === 1;
+const interpret = (gen, fiber) => {
+	const iter = gen();
+	const resume = (send, thrown) => {
+		if (fiber.closed) return;
+		withFiber(fiber, () => {
+			if (fiber.inFlight) throw new Error("ilha: re-enter while Instruction in flight");
+			let step;
+			try {
+				step = thrown === void 0 ? iter.next(send) : iter.throw(thrown);
+			} catch (error) {
+				fiber.fail(asFailure(error));
+				return;
+			}
+			if (step.done) {
+				if (step.value !== void 0) fiber.paint(step.value);
+				return;
+			}
+			let effect;
+			if (isInstruction(step.value)) ({effect} = step.value);
+			else if (Effect.isEffect(step.value)) effect = step.value;
+			if (effect) {
+				fiber.inFlight = true;
+				fiber.run(effect, (a) => {
+					fiber.inFlight = false;
+					resume(a);
+				}, (e) => {
+					fiber.inFlight = false;
+					resume(void 0, new Error(failureMessage(e)));
+				});
+				return;
+			}
+			fiber.paint(step.value);
+			resume();
+		});
+	};
+	resume();
+};
+
+//#endregion
+//#region src/events.ts
+const ACTION_CALL$1 = Symbol.for("ilha.actionCall");
+const eventTypeFromProp = (key) => {
+	if (key.length < 4) return;
+	let type;
+	if (/^on[A-Z]/u.test(key)) type = key.slice(2).toLowerCase();
+	else if (/^on[a-z]{3,}$/u.test(key)) type = key.slice(2).toLowerCase();
+	else return;
+	return type.length >= 3 ? type : void 0;
+};
+const isEventProp = (key) => eventTypeFromProp(key) !== void 0;
+const bindEvents = (node, props, fiber) => {
+	const el = node;
+	el.__ilhaProps = props;
+	el.__ilhaEvents ??= /* @__PURE__ */ new Set();
+	for (const key of Object.keys(props)) {
+		const type = eventTypeFromProp(key);
+		if (!type) continue;
+		if (el.__ilhaEvents.has(type)) continue;
+		el.__ilhaEvents.add(type);
+		if (fiber.runtime.ssr) {
+			const fn = props[key];
+			if (!isFunction(fn)) continue;
+			const branded = fn[ACTION_CALL$1];
+			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;
+			continue;
+		}
+		el.addEventListener(type, (ev) => {
+			if (fiber.closed) return;
+			const fn = el.__ilhaProps?.[key];
+			if (!isFunction(fn)) return;
+			const out = fn(ev);
+			if (Effect.isEffect(out)) fiber.run(out);
+		});
+	}
+};
+
+//#endregion
+//#region src/morph.ts
+const PRESERVE_ATTR = "data-morph-preserve";
+const morphKeyOf = (el) => {
+	const k = el.getAttribute(KEY_ATTR);
+	if (k !== null) return `k:${k}`;
+	const s = el.getAttribute(SLOT_ATTR);
+	return s === null ? null : `s:${s}`;
+};
+const shouldPreserveMorphAttr = (el, name) => {
+	if (name === "value" || name === "checked" || name === "selected") return true;
+	if (name === PRESERVE_ATTR) return el.hasAttribute(PRESERVE_ATTR);
+	const custom = el.getAttribute(PRESERVE_ATTR);
+	if (custom !== null) {
+		for (const token of custom.split(/\s+/u)) if (token === name) return true;
+	}
+	return false;
+};
+const syncAttributes = (from, to) => {
+	for (const { name, value } of to.attributes) {
+		if (shouldPreserveMorphAttr(from, name)) continue;
+		if (from.getAttribute(name) !== value) from.setAttribute(name, value);
+	}
+	const names = [];
+	for (const { name } of from.attributes) names.push(name);
+	for (const name of names) {
+		if (shouldPreserveMorphAttr(from, name)) continue;
+		if (!to.hasAttribute(name)) from.removeAttribute(name);
+	}
+};
+const snapshotFocus = () => {
+	if (globalThis.document === void 0) return null;
+	const active = document.activeElement;
+	if (!(active instanceof HTMLElement) || active === document.body) return null;
+	let selection = null;
+	try {
+		if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) selection = {
+			dir: active.selectionDirection,
+			end: active.selectionEnd,
+			start: active.selectionStart
+		};
+	} catch {}
+	return {
+		active,
+		selection
+	};
+};
+const restoreFocus = (snapshot) => {
+	if (!snapshot || !snapshot.active.isConnected) return;
+	try {
+		if (document.activeElement !== snapshot.active) snapshot.active.focus({ preventScroll: true });
+		const sel = snapshot.selection;
+		if (sel && sel.start !== null) {
+			const el = snapshot.active;
+			if (el.selectionStart !== sel.start || el.selectionEnd !== sel.end) el.setSelectionRange(sel.start, sel.end, sel.dir ?? "none");
+		}
+	} catch {}
+};
+const buildKeyedIndex = (parent) => {
+	let fromKeyed = null;
+	for (const child of parent.children) {
+		const k = morphKeyOf(child);
+		if (k !== null) {
+			fromKeyed ??= /* @__PURE__ */ new Map();
+			if (!fromKeyed.has(k)) fromKeyed.set(k, child);
+		}
+	}
+	return fromKeyed;
+};
+const collectKeys = (parent) => {
+	const keys = /* @__PURE__ */ new Set();
+	for (const child of parent.children) {
+		const k = morphKeyOf(child);
+		if (k !== null) keys.add(k);
+	}
+	return keys;
+};
+const morphInput = (fromEl, toEl) => {
+	const hadChecked = fromEl.hasAttribute("checked");
+	const hadValue = fromEl.getAttribute("value");
+	syncAttributes(fromEl, toEl);
+	const hasChecked = toEl.hasAttribute("checked");
+	if (hasChecked !== hadChecked) fromEl.checked = hasChecked;
+	const newValue = toEl.getAttribute("value");
+	if (newValue !== hadValue) fromEl.value = newValue ?? "";
+};
+const morphTextarea = (fromEl, toEl) => {
+	const newText = toEl.textContent ?? "";
+	if (fromEl.textContent !== newText) {
+		fromEl.textContent = newText;
+		fromEl.value = newText;
+	}
+};
+const morphSelect = (fromEl, toEl, api) => {
+	const before = /* @__PURE__ */ new Map();
+	const fromSelect = fromEl;
+	for (const o of fromSelect.options) before.set(o, {
+		attr: o.hasAttribute("selected"),
+		live: o.selected
+	});
+	syncAttributes(fromEl, toEl);
+	api.morphChildren(fromEl, toEl);
+	const options = [...fromSelect.options];
+	if (options.some((o) => o.hasAttribute("selected") !== (before.get(o)?.attr ?? false))) for (const o of options) o.selected = o.hasAttribute("selected");
+	else for (const o of options) {
+		const prev = before.get(o);
+		if (prev && o.selected !== prev.live) o.selected = prev.live;
+	}
+};
+const morphElementPair = (fromEl, toEl, api) => {
+	if (fromEl.localName !== toEl.localName) {
+		fromEl.replaceWith(toEl);
+		return;
+	}
+	const slotId = toEl.getAttribute(SLOT_ATTR);
+	if (slotId !== null && fromEl.getAttribute("data-ilha-slot") === slotId) return;
+	if (fromEl.localName === "input") {
+		morphInput(fromEl, toEl);
+		return;
+	}
+	if (fromEl.localName === "select") {
+		morphSelect(fromEl, toEl, api);
+		return;
+	}
+	syncAttributes(fromEl, toEl);
+	if (fromEl.localName === "textarea") morphTextarea(fromEl, toEl);
+	else api.morphChildren(fromEl, toEl);
+};
+const alignKeyedNode = (fromParent, fromNode, toNode, fromKeyed, toKeys) => {
+	const toKey = toNode.nodeType === 1 ? morphKeyOf(toNode) : null;
+	let current = fromNode;
+	if (toKey !== null) {
+		const match = fromKeyed.get(toKey);
+		if (match) {
+			fromKeyed.delete(toKey);
+			if (match !== current) {
+				current?.before(match);
+				if (!current) fromParent.append(match);
+				current = match;
+			}
+		}
+	}
+	if (current instanceof Element) {
+		const fromKey = morphKeyOf(current);
+		if (fromKey !== null && fromKey !== toKey && toKeys.has(fromKey)) {
+			current.before(toNode);
+			return "continue";
+		}
+	}
+	return current;
+};
+const api = { morphChildren: (fromParent, toParent) => {
+	const toNodes = [...toParent.childNodes];
+	const fromKeyed = buildKeyedIndex(fromParent);
+	const toKeys = fromKeyed === null ? null : collectKeys(toParent);
+	for (let i = 0; i < toNodes.length; i += 1) {
+		const toNode = toNodes[i];
+		if (!toNode) continue;
+		let fromNode = fromParent.childNodes[i];
+		if (fromKeyed !== null && toKeys !== null) {
+			const aligned = alignKeyedNode(fromParent, fromNode, toNode, fromKeyed, toKeys);
+			if (aligned === "continue") continue;
+			fromNode = aligned;
+		}
+		if (!fromNode) {
+			fromParent.append(toNode);
+			continue;
+		}
+		if (fromNode.nodeType !== toNode.nodeType) {
+			fromNode.replaceWith(toNode);
+			continue;
+		}
+		if (fromNode.nodeType === 3 || fromNode.nodeType === 8) {
+			if (fromNode.nodeValue !== toNode.nodeValue) fromNode.nodeValue = toNode.nodeValue;
+			continue;
+		}
+		if (fromNode.nodeType === 1) morphElementPair(fromNode, toNode, api);
+	}
+	while (fromParent.childNodes.length > toNodes.length) fromParent.lastChild?.remove();
+} };
+const morphInner = (from, to) => {
+	const focus = snapshotFocus();
+	api.morphChildren(from, to);
+	restoreFocus(focus);
+};
+
+//#endregion
+//#region src/security.ts
+const SAFE_CSS_PROP_RE = /^(?:-{2}[a-zA-Z][a-zA-Z0-9-]*|-?[a-zA-Z][a-zA-Z0-9-]*)$/u;
+const URL_ATTRS = /* @__PURE__ */ new Set([
+	"href",
+	"src",
+	"srcset",
+	"imagesrcset",
+	"action",
+	"formaction",
+	"cite",
+	"data",
+	"poster"
+]);
+const SAFE_DATA_IMAGE_RE = /^data:image\/(?<fmt>png|jpe?g|gif|webp|avif)[;,]/iu;
+const UNSAFE_SCHEME_RE = /^(?:javascript|vbscript):/iu;
+const DATA_IMAGE_CONTEXTS = /* @__PURE__ */ new Set([
+	"img:src",
+	"source:srcset",
+	"link:imagesrcset"
+]);
+const isBlockedUrlChar = (code) => code <= 32 || code === 160 || code === 5760 || code >= 8192 && code <= 8205 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+const normalizeUrl = (value) => {
+	let out = "";
+	for (const ch of value) {
+		const code = ch.codePointAt(0) ?? 0;
+		if (!isBlockedUrlChar(code)) out += ch;
+	}
+	return out;
+};
+const checkUrl = (normalized, allowDataImage) => {
+	if (UNSAFE_SCHEME_RE.test(normalized)) return false;
+	if (/^data:/iu.test(normalized)) return allowDataImage && SAFE_DATA_IMAGE_RE.test(normalized);
+	return true;
+};
+const isUrlAttributeName = (name) => {
+	const lower = name.toLowerCase();
+	return URL_ATTRS.has(lower) || /:(?<attr>href|src|srcset|imagesrcset|action|formaction|cite|data|poster)$/u.test(lower);
+};
+const isSafeUrlAttrValue = (tagName, attrName, value) => {
+	const attr = attrName.toLowerCase();
+	const allowDataImage = DATA_IMAGE_CONTEXTS.has(`${tagName.toLowerCase()}:${attr}`) && !attr.startsWith("srcset") && attr !== "imagesrcset";
+	if (/^(?:srcset|imagesrcset)$/iu.test(attr)) return value.split(",").every((candidate) => {
+		const url = candidate.trim().split(/\s+/u)[0] ?? "";
+		return url === "" || checkUrl(normalizeUrl(url), false);
+	});
+	return checkUrl(normalizeUrl(value), allowDataImage);
+};
+const isSafeStyleValue = (str) => {
+	if (/[<>{};]/u.test(str) || /expression\(/iu.test(str) || /javascript:/iu.test(str) || /data:/iu.test(str)) return false;
+	if (/\\/u.test(str)) return false;
+	const urlRe = /url\s*\(\s*(?<inner>[^)]+)\s*\)/giu;
+	let m;
+	while ((m = urlRe.exec(str)) !== null) {
+		const inner = (m.groups?.inner ?? "").trim().replaceAll(/^['"]|['"]$/gu, "");
+		if (!checkUrl(normalizeUrl(inner), false)) return false;
+	}
+	return true;
+};
+const serializeStyleEntries = (value) => Object.entries(value).map(([k, v]) => {
+	if (!SAFE_CSS_PROP_RE.test(k)) return "";
+	const prop = k.replaceAll(/[A-Z]/gu, (m) => `-${m.toLowerCase()}`);
+	const str = String(v);
+	if (!isSafeStyleValue(str)) return "";
+	return `${prop}:${str}`;
+}).filter(Boolean).join(";");
+const serializeStyleAttr = (value) => {
+	if (isString(value)) {
+		const obj = {};
+		for (const decl of value.split(";")) {
+			const colon = decl.indexOf(":");
+			if (colon === -1) continue;
+			const prop = decl.slice(0, colon).trim();
+			const val = decl.slice(colon + 1).trim();
+			if (prop) obj[prop] = val;
+		}
+		return serializeStyleEntries(obj);
+	}
+	return serializeStyleEntries(value);
+};
+
+//#endregion
+//#region src/start.ts
+const isGen = (x) => {
+	if (x === null || x === void 0) return false;
+	const g = x;
+	return isFunction(g.next) && isFunction(g.throw);
+};
+const finish = (fiber, view) => {
+	if (fiber.closed) return;
+	if (view !== void 0) fiber.paint(view);
+};
+const runSetup = (fiber, fn) => {
+	const disposeRenderSub = () => {
+		fiber.renderSub?.();
+		fiber.renderSub = void 0;
+	};
+	const api = {
+		commit: (out, deps) => {
+			if (isGen(out)) {
+				disposeRenderSub();
+				interpret((() => out), fiber);
+				return;
+			}
+			disposeRenderSub();
+			if (!fiber.runtime.ssr) fiber.renderSub = subscribeRenderDeps(fiber, deps, () => api.render());
+			withFiber(fiber, () => {
+				finish(fiber, out);
+			});
+		},
+		render: () => {
+			if (fiber.closed) return;
+			fiber.runtime.begin();
+			beginPrimitiveFrame(fiber);
+			withTrackGetRun(fiber, () => fn(), ({ value: out, deps }) => {
+				try {
+					api.commit(out, deps);
+				} catch (error) {
+					withFiber(fiber, () => fiber.fail(asFailure(error)));
+				} finally {
+					fiber.runtime.end();
+				}
+			}, (e) => {
+				withFiber(fiber, () => fiber.fail(asFailure(e)));
+				fiber.runtime.end();
+			});
+		}
+	};
+	try {
+		api.render();
+	} catch (error) {
+		fiber.fail(asFailure(error));
+	}
+};
+
+//#endregion
+//#region src/paint-core.ts
+const disposeHoles = (fiber, opts) => {
+	const keep = [];
+	for (const h of fiber.holes) {
+		if (opts?.morph && h.keepOnMorph) {
+			keep.push(h);
+			continue;
+		}
+		h.dispose();
+	}
+	fiber.holes = keep;
+};
+const findReusableAtomHost = (fiber, atom) => {
+	for (const h of fiber.holes) if (h.atom === atom && h.host?.isConnected && h.holeFiber && !h.holeFiber.closed) return {
+		hole: h.holeFiber,
+		host: h.host
+	};
+};
+const emptyUnsub = () => {};
+const isTextish = (view) => isString(view) || isNumber(view) || isBigInt(view);
+const isIterableView = (view) => {
+	if (Array.isArray(view)) return true;
+	if (!view || !isObject(view)) return false;
+	return Symbol.iterator in view;
+};
+const styleCss = (v) => {
+	if (isString(v) || isObject(v)) return serializeStyleAttr(v);
+	return "";
+};
+const isThenable = (value) => {
+	if (!isObject(value) && !isFunction(value)) return false;
+	return isFunction(value.then);
+};
+const writeAttr = (el, k, v) => {
+	if (v === false || v === null || v === void 0) {
+		el.removeAttribute(k);
+		return;
+	}
+	const str = v === true ? "" : String(v);
+	if (isUrlAttributeName(k) && !isSafeUrlAttrValue(el.tagName, k, str)) return;
+	el.setAttribute(k, str);
+};
+const isSkippedPropKey = (k) => k === "children" || k === "key" || k === "ref" || k.toLowerCase() === "srcdoc" || isEventProp(k) || /^on[A-Z]/u.test(k);
+/**
+* The painter shared by DOM mount and SSR: props, materialization, holes, and
+* keyed reconciliation. Host differences live in `PaintOps`.
+*/
+const createPainter = (ops) => {
+	const applyFormControl = (el, key, v, fiber) => {
+		const setProp = (x) => ops.setFormControl(el, key, x);
+		if (isAtomHandle(v)) {
+			const memo = el;
+			if (memo.__ilhaVal === v) return;
+			memo.__ilhaVal = v;
+			const unsub = fiber.registry.subscribe(v.atom, setProp, { immediate: true });
+			fiber.holes.push({ dispose: unsub });
+		} else setProp(v);
+	};
+	const trackHole = (parent, hole, extra, meta) => {
+		parent.holes.push({
+			atom: meta?.atom,
+			dispose() {
+				extra?.();
+				if (meta?.host) ops.disconnect(meta.host);
+				closeFiber(hole);
+			},
+			holeFiber: hole,
+			host: meta?.host ? ops.asElement(meta.host) : void 0,
+			keepOnMorph: !!(meta?.atom && meta?.host) || !!meta?.keyed
+		});
+	};
+	const insert = (fiber, nodes) => {
+		for (const n of nodes) ops.appendRoot(fiber.root, n);
+	};
+	const applyProps = (el, props, fiber) => {
+		for (const [k, v] of Object.entries(props)) {
+			if (isSkippedPropKey(k)) continue;
+			if (k === "className") {
+				el.setAttribute("class", String(v ?? ""));
+				continue;
+			}
+			if (k === "htmlFor") {
+				el.setAttribute("for", String(v ?? ""));
+				continue;
+			}
+			if (k === "style" && v !== null && v !== void 0 && v !== false) {
+				const css = styleCss(v);
+				if (css) ops.setStyle(el, css);
+				continue;
+			}
+			if (k === "value" || k === "checked" || k === "selected") {
+				applyFormControl(el, k, v, fiber);
+				continue;
+			}
+			if (isFunction(v)) continue;
+			writeAttr(el, k, v);
+		}
+		ops.bindEvents(el, props, fiber);
+		const { ref } = props;
+		if (isFunction(ref)) {
+			const refFn = ref;
+			refFn(ops.asElement(el));
+			fiber.holes.push({ dispose: () => refFn(null) });
+		}
+	};
+	const paintFns = {
+		keyedPaintHole: () => {},
+		materialize: () => []
+	};
+	const api = {
+		applyProps,
+		insert,
+		materialize: (view, fiber) => paintFns.materialize(view, fiber),
+		openHole: (parent) => {
+			const id = parent.runtime.nextHole();
+			const host = ops.createSlotHost(String(id));
+			const child = makeFiber(parent.runtime, ops.asRoot(host), (f, v) => api.paintHole(f, v), { onFail: (e) => {
+				console.error(e);
+				api.paintHole(child, errorView(e));
+			} });
+			return {
+				fiber: child,
+				nodes: [host]
+			};
+		},
+		paintHole: (fiber, view) => {
+			if (view === KEEP) return;
+			let frame = fiber.islandFrame;
+			if (!frame) {
+				frame = {
+					i: 0,
+					slots: []
+				};
+				fiber.islandFrame = frame;
+			}
+			frame.i = 0;
+			const list = Array.isArray(view) ? view : null;
+			if (list && list.length > 0 && list.every((v) => isVNode(v) && v.key !== null && v.key !== void 0)) {
+				paintFns.keyedPaintHole(fiber, list);
+				return;
+			}
+			disposeHoles(fiber);
+			ops.clearRoot(fiber.root);
+			api.insert(fiber, api.materialize(view, fiber));
+		}
+	};
+	const materializeAtom = (view, fiber) => {
+		const reused = findReusableAtomHost(fiber, view.atom);
+		if (reused) return [ops.createSlotHost(reused.host.getAttribute(SLOT_ATTR))];
+		const { fiber: hole, nodes } = api.openHole(fiber);
+		const [host] = nodes;
+		if (!host) return nodes;
+		let unsub = emptyUnsub;
+		fiber.runtime.later(() => {
+			if (hole.closed) return;
+			let keep;
+			unsub = fiber.registry.subscribe(view.atom, (v) => {
+				if (hole.closed) return;
+				const next = unwrap(v, keep);
+				if (next === KEEP) return;
+				keep = next;
+				api.paintHole(hole, next);
+			}, { immediate: true });
+		});
+		trackHole(fiber, hole, () => unsub(), {
+			atom: view.atom,
+			host
+		});
+		return nodes;
+	};
+	const materializeStream = (view, fiber) => {
+		const { fiber: hole, nodes } = api.openHole(fiber);
+		const src = fiber.runtime.ssr ? view.pipe(Stream.take(1)) : view;
+		const effect = Effect.gen(function* streamPaint() {
+			const result = yield* Effect.result(Stream.runForEach(src, (v) => Effect.sync(() => {
+				if (!hole.closed) api.paintHole(hole, v);
+			})));
+			if (result._tag === "Failure" && !hole.closed) api.paintHole(hole, String(result.failure));
+		});
+		hole.run(effect, fiber.runtime.ssr ? emptyUnsub : void 0);
+		trackHole(fiber, hole);
+		return nodes;
+	};
+	const materializeIsland = (type, props, fiber) => {
+		let frame = fiber.islandFrame;
+		if (!frame) {
+			frame = {
+				i: 0,
+				slots: []
+			};
+			fiber.islandFrame = frame;
+		}
+		const { i } = frame;
+		frame.i = i + 1;
+		const existing = frame.slots[i];
+		if (existing && existing.type === type && existing.host.isConnected && isFunction(existing.updateProps)) {
+			existing.updateProps(props);
+			return [ops.asNode(existing.host)];
+		}
+		existing?.unmount?.();
+		const tag = isString(type[ISLAND_SLOT_TAG]) ? type[ISLAND_SLOT_TAG] : "div";
+		const el = ops.createElement(tag);
+		el.dataset.ilha = "";
+		const mountFn = type[ISLAND_MOUNT_INTERNAL];
+		if (isFunction(mountFn)) {
+			const handle = mountFn(ops.asElement(el), props);
+			const slot = {
+				host: ops.asElement(el),
+				type,
+				unmount: handle?.unmount,
+				updateProps: handle?.updateProps
+			};
+			frame.slots[i] = slot;
+			fiber.holes.push({
+				dispose: () => {
+					ops.disconnect(el);
+					handle?.unmount?.();
+					if (frame.slots[i] === slot) frame.slots[i] = void 0;
+				},
+				keepOnMorph: true
+			});
+		}
+		return [el];
+	};
+	const materializeComponent = (view, type, fiber) => {
+		const props = {
+			...view.props,
+			children: view.children
+		};
+		const branded = type;
+		if (branded[ISLAND] === true) return materializeIsland(branded, props, fiber);
+		const k = view.key === null || view.key === void 0 ? void 0 : String(view.key);
+		const reuse = k ? fiber.keyedHoles?.get(k) : void 0;
+		if (reuse && !reuse.closed) {
+			if (reuse.propsBox) reuse.propsBox.current = props;
+			const next = withFiber(fiber, () => type(reuse.propsBox?.current ?? props));
+			if (next && !isThenable(next) && !isSetupFn(next)) reuse.paint(next);
+			return [ops.asNode(reuse.root)];
+		}
+		const { fiber: hole, nodes } = api.openHole(fiber);
+		hole.propsBox = { current: props };
+		if (k) {
+			fiber.keyedHoles ??= /* @__PURE__ */ new Map();
+			fiber.keyedHoles.set(k, hole);
+		}
+		fiber.runtime.later(() => {
+			if (hole.closed) return;
+			const box = hole.propsBox;
+			if (!box) return;
+			runSetup(hole, () => type(box.current));
+		});
+		trackHole(fiber, hole, void 0, k ? { keyed: true } : void 0);
+		return nodes;
+	};
+	const materializeElement = (view, fiber) => {
+		const el = ops.createElement(view.type);
+		if (view.key !== null && view.key !== void 0) el.setAttribute(KEY_ATTR, String(view.key));
+		api.applyProps(el, view.props, fiber);
+		fiber.keyedHoles ??= /* @__PURE__ */ new Map();
+		const childFiber = {
+			...fiber,
+			holes: fiber.holes,
+			keyedHoles: fiber.keyedHoles,
+			root: ops.asRoot(el)
+		};
+		for (const c of view.children) for (const n of api.materialize(c, childFiber)) el.append(n);
+		return [el];
+	};
+	const materializeVNode = (view, fiber) => {
+		if (view.type === Fragment) return view.children.flatMap((c) => api.materialize(c, fiber));
+		if (isFunction(view.type)) return materializeComponent(view, view.type, fiber);
+		return materializeElement(view, fiber);
+	};
+	paintFns.materialize = (view, fiber) => {
+		if (skip(view)) return [];
+		if (isTextish(view)) return [ops.createText(String(view))];
+		if (isAtomHandle(view)) return materializeAtom(view, fiber);
+		if (Stream.isStream(view)) return materializeStream(view, fiber);
+		if (isSetupFn(view)) {
+			const { fiber: hole, nodes } = api.openHole(fiber);
+			fiber.runtime.later(() => {
+				if (!hole.closed) runSetup(hole, view);
+			});
+			trackHole(fiber, hole);
+			return nodes;
+		}
+		if (isVNode(view)) return materializeVNode(view, fiber);
+		if (isIterableView(view)) return [...view].flatMap((c) => api.materialize(c, fiber));
+		return [ops.createText(String(view))];
+	};
+	paintFns.keyedPaintHole = (fiber, views) => {
+		const prev = fiber.keyedHoles ?? /* @__PURE__ */ new Map();
+		const keep = new Set(views.map((v) => String(v.key)));
+		for (const [k, h] of prev) if (!keep.has(k)) closeFiber(h);
+		const next = /* @__PURE__ */ new Map();
+		const nodes = [];
+		for (const v of views) {
+			const k = String(v.key);
+			const reuse = prev.get(k);
+			if (reuse && !reuse.closed) {
+				next.set(k, reuse);
+				nodes.push(ops.asNode(reuse.root));
+				continue;
+			}
+			const made = api.materialize(v, fiber);
+			const hole = fiber.keyedHoles?.get(k);
+			if (hole) next.set(k, hole);
+			nodes.push(...made);
+		}
+		fiber.keyedHoles = next;
+		ops.clearRoot(fiber.root);
+		api.insert(fiber, nodes);
+	};
+	return {
+		applyProps: api.applyProps,
+		disposeHoles: (fiber, opts) => disposeHoles(fiber, opts),
+		insert: api.insert,
+		materialize: api.materialize,
+		paintHole: api.paintHole
+	};
+};
+
+//#endregion
+//#region src/paint.ts
+const noopDisconnect = () => {};
+const core$1 = createPainter({
+	appendRoot: (root, node) => root.append(node),
+	asElement: (el) => el,
+	asNode: (host) => host,
+	asRoot: (el) => el,
+	bindEvents,
+	clearRoot: (root) => {
+		if (root instanceof Element) root.replaceChildren();
+	},
+	createElement: (tag) => document.createElement(tag),
+	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,
+	setFormControl: (el, key, v) => {
+		const node = el;
+		if (key === "value") node.value = String(v ?? "");
+		else if (key === "checked") node.checked = Boolean(v);
+		else node.selected = Boolean(v);
+	},
+	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)) el.append(n);
+};
+const paintMorphLive = (fiber, view) => {
+	if (!fiber.liveEl) return;
+	core$1.disposeHoles(fiber, { morph: true });
+	core$1.applyProps(fiber.liveEl, view.props, fiber);
+	const tmp = document.createElement(fiber.liveEl.localName);
+	for (const c of view.children) for (const n of core$1.materialize(c, fiber)) tmp.append(n);
+	morphInner(fiber.liveEl, tmp);
+	refreshAllAtomHosts(fiber);
+	pruneDisconnectedAtomHoles(fiber);
+};
+const paint$1 = (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);
+	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 paintError$1 = (fiber, e) => {
+	console.error(e);
+	paint$1(fiber, errorView(e));
+};
+
+//#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 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);
+	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) => n.kind === "text" ? n.text : 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 defer$1 = () => {
+	const { promise, resolve } = Promise.withResolvers();
+	return {
+		promise,
+		resolve: () => {
+			resolve(null);
+		}
+	};
+};
+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 ssrOps = {
+	appendRoot: (root, node) => ssrAs(root).append(node),
+	asElement: (el) => ssrAs(el),
+	asNode: (host) => ssrAs(host),
+	asRoot: (el) => ssrAs(el),
+	bindEvents: bindSsrEvents,
+	clearRoot: (root) => ssrAs(root).replaceChildren(),
+	createElement: createSsrElement,
+	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;
+	},
+	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 core = createPainter(ssrOps);
+const paint = (fiber, view) => {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	core.disposeHoles(fiber);
+	ssrOps.clearRoot(fiber.root);
+	core.insert(fiber, core.materialize(view, fiber));
+};
+const paintError = (fiber, e) => {
+	console.error(e);
+	paint(fiber, errorView(e));
+};
+const attachSsr = (fn, opts) => {
+	const root = createSsrRoot();
+	const runtime = makeRuntime({
+		ssr: true,
+		ssrCapture: opts?.ssrCapture === true
+	});
+	const { promise: ready, resolve } = defer$1();
+	const fiber = makeFiber(runtime, ssrAs(root), paint, { onFail: (e) => {
+		opts?.onError?.(e);
+		paintError(fiber, e);
+		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 defer = () => {
+	const { promise, resolve } = Promise.withResolvers();
+	return {
+		promise,
+		resolve: () => {
+			resolve(null);
+		}
+	};
+};
+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 });
+	const { promise: ready, resolve } = defer();
+	const fiber = makeFiber(runtime, el, paint$1, { onFail: (e) => {
+		opts?.onError?.(e);
+		paintError$1(fiber, e);
+		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 { batch as a, isAtomHandle as c, makeFiber as d, atom as i, closeFiber as l, renderToString as n, handleOwner as o, interpret as r, instr as s, mount as t, getFiber as u };