ilha 0.15.1 → 0.16.0

package/dist/paint-core-D9VO-oUM.js

@@ -1,1659 +0,0 @@
-import { S as toError, _ as isString, a as ISLAND, b as asFailure, c as KEEP, f as errorView, g as isObject, h as isNumber, i as Fragment, l as KEY_ATTR, m as isFunction, n as isSetupFn, o as ISLAND_MOUNT_INTERNAL, p as isBigInt, r as isVNode, s as ISLAND_SLOT_TAG, u as SLOT_ATTR, v as skip, x as failureMessage, y as unwrap } from "./vnode-BHUY61Rm.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 * as Cause from "effect/Cause";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import * as Registry from "effect/reactivity/AtomRegistry";
-import * as Scope from "effect/Scope";
-
-//#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$1.provideService(Registry.AtomRegistry, registry));
-const runInScope = (effect, registry, scope, onOk, onErr, onDone) => {
-	const provided = provide(effect, registry);
-	const f = Effect$1.runFork(onOk || onDone ? provided.pipe(Effect$1.onExit((ex) => Effect$1.sync(() => {
-		onDone?.();
-		if (Exit.isSuccess(ex)) onOk?.(ex.value);
-		else if (!Cause.hasInterruptsOnly(ex.cause)) onErr?.(Cause.squash(ex.cause));
-	}))) : provided);
-	Effect$1.runSync(Scope.addFinalizer(scope, Fiber.interrupt(f)));
-};
-/** Clear render subscriptions and child holes without closing the fiber scope. */
-const clearFiberView = (fiber) => {
-	fiber.renderSub?.();
-	fiber.renderSub = void 0;
-	for (const slot of fiber.watchSlots ?? []) slot?.dispose();
-	fiber.watchSlots = [];
-	fiber.watchI = 0;
-	fiber.primitives = void 0;
-	fiber.primitiveI = 0;
-	for (const release of fiber.primitiveHolds ?? []) release();
-	fiber.primitiveHolds = void 0;
-	fiber.islandFrame = void 0;
-	fiber.keyedHoles = void 0;
-	for (const h of fiber.holes) h.dispose();
-	fiber.holes = [];
-};
-const closeFiber = (fiber) => {
-	if (fiber.closed) return;
-	fiber.closed = true;
-	fiber.trackRestore?.();
-	fiber.trackRestore = void 0;
-	fiber.handleError = void 0;
-	clearFiberView(fiber);
-	Effect$1.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$1.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;
-		},
-		onError: opts?.onError,
-		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,
-		parent: opts?.parent,
-		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;
-};
-/** Walk this fiber and ancestors for an error boundary handler. */
-const reportFiberError = (fiber, error) => {
-	let current = fiber;
-	while (current) {
-		const { handleError } = current;
-		if (handleError) {
-			handleError(error);
-			return true;
-		}
-		current = current.parent;
-	}
-	return false;
-};
-/**
-* Open a mount's root fiber. A failing root component reports to
-* `runtime.onError`, paints the error view, and settles the mount.
-*/
-const makeRootFiber = ({ runtime, root, paint, settle }) => {
-	const fiber = makeFiber(runtime, root, paint, { onFail: (e) => {
-		const error = toError(e);
-		runtime.onError?.(error);
-		console.error(error);
-		fiber.paint(errorView(error));
-		settle();
-	} });
-	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;
-/** Key-order-insensitive deep equality for JSON-shaped values. */
-const structuralEqual = Equal.equals;
-let trackGet;
-const trackStack = [];
-/** Read atoms inside `fn` without subscribing the active render. Sync only. */
-const untrack = (fn) => {
-	const prev = trackGet;
-	trackGet = void 0;
-	try {
-		return fn();
-	} finally {
-		trackGet = prev;
-	}
-};
-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;
-	let { componentFrame } = fiber;
-	if (!componentFrame) {
-		componentFrame = {
-			i: 0,
-			slots: []
-		};
-		fiber.componentFrame = componentFrame;
-	}
-	const usedComponents = componentFrame.i;
-	if (usedComponents < componentFrame.slots.length) {
-		for (let j = usedComponents; j < componentFrame.slots.length; j += 1) {
-			const slot = componentFrame.slots[j];
-			if (slot) {
-				const { hole } = slot;
-				if (!hole.closed) {
-					const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
-					if (idx === -1) closeFiber(hole);
-					else {
-						const [removed] = fiber.holes.splice(idx, 1);
-						removed?.dispose();
-					}
-				}
-			}
-			componentFrame.slots[j] = void 0;
-		}
-		componentFrame.slots.length = usedComponents;
-	}
-	componentFrame.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
-	};
-};
-/**
-* Keep a component's own state atom in the registry while its fiber lives.
-*
-* The registry drops an atom nothing subscribes to. State that a handler
-* writes and the view never reads would otherwise reset between events.
-*/
-const holdState = (fiber, atom) => {
-	if (!fiber.runtime.ssr) {
-		fiber.primitiveHolds ??= [];
-		fiber.primitiveHolds.push(fiber.registry.mount(atom));
-	}
-	return atom;
-};
-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;
-		const seen = fiber.renderGen;
-		fiber.runtime.later(() => {
-			scheduled = false;
-			if (fiber.renderGen !== seen) return;
-			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, options) => {
-	const fiber = getFiber();
-	const snap = fiber.runtime.hydrateValues;
-	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
-		let seed = init;
-		if (snap && !Atom.isAtom(init) && !Effect$1.isEffect(init) && !Stream$1.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$1.isEffect(seed) || Stream$1.isStream(seed)) return Atom.make(seed);
-		const made = Atom.make(seed);
-		const eq = options?.equals;
-		if (eq === void 0) return holdState(fiber, made);
-		const equalsFn = eq === "structural" ? structuralEqual : eq;
-		return holdState(fiber, Atom.withEquality(made, equalsFn));
-	});
-	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 holdState(fiber, 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$1.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/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.renderGen = (fiber.renderGen ?? 0) + 1;
-			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/events.ts
-const ACTION_CALL = 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 dispatch = (el, type, ev) => {
-	const fiber = el.__ilhaFiber;
-	if (!fiber || fiber.closed) return;
-	const fn = el.__ilhaHandlers?.get(type);
-	if (!isFunction(fn)) return;
-	const out = fn(ev);
-	if (Effect$1.isEffect(out)) fiber.run(out);
-};
-/** One native listener per type; it reads the latest handler at dispatch. */
-const listen = (el, type) => {
-	el.__ilhaEvents ??= /* @__PURE__ */ new Set();
-	if (el.__ilhaEvents.has(type)) return;
-	el.__ilhaEvents.add(type);
-	el.addEventListener(type, (ev) => {
-		dispatch(el, type, ev);
-	});
-};
-const bindSsrActions = (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 bindEvents = (node, props, fiber) => {
-	const el = node;
-	if (fiber.runtime.ssr) {
-		bindSsrActions(el, props, fiber);
-		return;
-	}
-	const handlers = /* @__PURE__ */ new Map();
-	for (const key of Object.keys(props)) {
-		const type = eventTypeFromProp(key);
-		if (type && !handlers.has(type)) handlers.set(type, props[key]);
-	}
-	el.__ilhaHandlers = handlers;
-	el.__ilhaFiber = fiber;
-	for (const type of handlers.keys()) listen(el, type);
-};
-/**
-* The morph kept `live` in place of the freshly rendered `fresh`: hand the
-* render's handlers to the live node, so closures never go stale and handlers
-* added on a later render still fire.
-*/
-const adoptEvents = (live, fresh) => {
-	const from = fresh;
-	if (!from.__ilhaFiber) return;
-	const to = live;
-	to.__ilhaHandlers = from.__ilhaHandlers;
-	to.__ilhaFiber = from.__ilhaFiber;
-	for (const type of from.__ilhaHandlers?.keys() ?? []) listen(to, type);
-};
-
-//#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}`;
-};
-/** Whether `data-morph-preserve` on `el` lists `token`. */
-const hasPreserveToken = (el, token) => {
-	const custom = el.getAttribute(PRESERVE_ATTR);
-	if (custom === null) return false;
-	for (const listed of custom.split(/\s+/u)) if (listed === token) return true;
-	return false;
-};
-const shouldPreserveMorphAttr = (el, name) => {
-	if (name === "value" || name === "checked" || name === "selected") return true;
-	if (name === PRESERVE_ATTR) return el.hasAttribute(PRESERVE_ATTR);
-	return hasPreserveToken(el, name);
-};
-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 (name === "open" && !to.hasAttribute("open")) continue;
-		if (shouldPreserveMorphAttr(from, name)) continue;
-		if (!to.hasAttribute(name)) from.removeAttribute(name);
-	}
-};
-/** Deepest focused element, looking through open shadow roots. */
-const deepActiveElement = () => {
-	let active = document.activeElement;
-	while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
-	return active;
-};
-const snapshotRanges = (active) => {
-	if (!active.isContentEditable) return null;
-	const sel = document.getSelection();
-	if (!sel || sel.rangeCount === 0) return null;
-	const ranges = [];
-	for (let i = 0; i < sel.rangeCount; i += 1) {
-		const range = sel.getRangeAt(i);
-		if (active.contains(range.startContainer)) ranges.push(range.cloneRange());
-	}
-	return ranges.length > 0 ? ranges : null;
-};
-const snapshotFocus = () => {
-	if (globalThis.document === void 0) return null;
-	const active = deepActiveElement();
-	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,
-		ranges: snapshotRanges(active),
-		selection
-	};
-};
-const restoreRanges = (ranges) => {
-	const sel = document.getSelection();
-	if (!sel || !ranges.every((r) => r.startContainer.isConnected)) return;
-	sel.removeAllRanges();
-	for (const r of ranges) sel.addRange(r);
-};
-const restoreFocus = (snapshot) => {
-	if (!snapshot || !snapshot.active.isConnected) return;
-	try {
-		if (deepActiveElement() !== snapshot.active) {
-			snapshot.active.focus({ preventScroll: true });
-			if (snapshot.ranges) restoreRanges(snapshot.ranges);
-		}
-		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 STAND_IN_ATTR = "data-ilha-reuse";
-const standIns = /* @__PURE__ */ new WeakMap();
-/** Live nodes with an outstanding stand-in: the morph must not consume them. */
-const claimed = /* @__PURE__ */ new WeakSet();
-/** Placeholder for a connected live node inside a scratch render tree. */
-const standInFor = (live) => {
-	const el = document.createElementNS(live.namespaceURI, live.localName);
-	for (const name of [SLOT_ATTR, KEY_ATTR]) {
-		const v = live.getAttribute(name);
-		if (v !== null) el.setAttribute(name, v);
-	}
-	el.setAttribute(STAND_IN_ATTR, "");
-	standIns.set(el, live);
-	claimed.add(live);
-	return el;
-};
-const liveOf = (node) => {
-	const live = standIns.get(node);
-	if (!live) return node;
-	claimed.delete(live);
-	return live;
-};
-/**
-* Insert `node` before `ref`. Connected nodes move with `moveBefore` where the
-* browser has it, so they keep focus, iframe, dialog, and element state.
-*/
-const place = (parent, node, ref) => {
-	if (node === ref || node.parentNode === parent && node.nextSibling === ref) return;
-	if (node.isConnected && parent.isConnected && parent.moveBefore) try {
-		parent.moveBefore(node, ref);
-		return;
-	} catch {}
-	if (ref) ref.before(node);
-	else parent.append(node);
-};
-/** Swap stand-ins nested in `node` (now in the document) for live nodes. */
-const resolveNested = (node) => {
-	if (!(node instanceof Element) || !node.firstElementChild) return;
-	const nested = node.querySelectorAll(`[${STAND_IN_ATTR}]`);
-	for (const s of nested) {
-		const live = liveOf(s);
-		if (live !== s && s.parentNode) {
-			place(s.parentNode, live, s);
-			s.remove();
-		}
-	}
-};
-/**
-* Put a rendered node into the live tree: stand-ins become their live nodes,
-* and stand-ins nested in fresh subtrees resolve once the subtree is attached.
-*/
-const insertRendered = (parent, node, ref) => {
-	const live = liveOf(node);
-	place(parent, live, ref);
-	if (live === node) resolveNested(node);
-};
-/** Longest increasing run of old indexes: those nodes never move. */
-const stableSet = (nodes, oldIndex) => {
-	const tails = [];
-	const prev = [];
-	for (let i = 0; i < nodes.length; i += 1) {
-		const node = nodes[i];
-		const idx = node ? oldIndex.get(node) : void 0;
-		if (idx === void 0) {
-			prev.push(-1);
-			continue;
-		}
-		let lo = 0;
-		let hi = tails.length;
-		while (lo < hi) {
-			const mid = Math.floor((lo + hi) / 2);
-			const tail = nodes[tails[mid] ?? 0];
-			if ((tail ? oldIndex.get(tail) ?? 0 : 0) < idx) lo = mid + 1;
-			else hi = mid;
-		}
-		prev.push(lo > 0 ? tails[lo - 1] ?? -1 : -1);
-		tails[lo] = i;
-	}
-	const stable = /* @__PURE__ */ new Set();
-	let k = tails.length > 0 ? tails.at(-1) ?? -1 : -1;
-	while (k >= 0) {
-		const node = nodes[k];
-		if (node) stable.add(node);
-		k = prev[k] ?? -1;
-	}
-	return stable;
-};
-/**
-* Make `parent`'s children exactly `nodes` with the fewest moves. Nodes that
-* keep their relative order stay attached; removed nodes leave first.
-*/
-const placeChildren = (parent, rendered) => {
-	const focus = snapshotFocus();
-	const nodes = rendered.map(liveOf);
-	const wanted = new Set(nodes);
-	const oldIndex = /* @__PURE__ */ new Map();
-	let child = parent.firstChild;
-	while (child) {
-		const next = child.nextSibling;
-		if (wanted.has(child)) oldIndex.set(child, oldIndex.size);
-		else child.remove();
-		child = next;
-	}
-	const stable = stableSet(nodes, oldIndex);
-	let next = null;
-	for (let i = nodes.length - 1; i >= 0; i -= 1) {
-		const node = nodes[i];
-		if (!node) continue;
-		if (!stable.has(node)) {
-			place(parent, node, next);
-			if (!oldIndex.has(node)) resolveNested(node);
-		}
-		next = node;
-	}
-	restoreFocus(focus);
-};
-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) => {
-	syncAttributes(fromEl, toEl);
-	const from = fromEl;
-	const to = toEl;
-	const toChecked = toEl.hasAttribute("checked");
-	if (toChecked !== fromEl.hasAttribute("checked")) {
-		if (toChecked) fromEl.setAttribute("checked", "");
-		else fromEl.removeAttribute("checked");
-	}
-	if (toChecked && from.checked !== to.checked) from.checked = to.checked;
-	const toValue = toEl.getAttribute("value");
-	if (toValue !== fromEl.getAttribute("value")) {
-		if (toValue === null) fromEl.removeAttribute("value");
-		else fromEl.setAttribute("value", toValue);
-	}
-	if (toValue !== null && from.value !== to.value) from.value = to.value;
-};
-const morphTextarea = (fromEl, toEl) => {
-	syncAttributes(fromEl, toEl);
-	const from = fromEl;
-	const to = toEl;
-	if (to.textContent !== "" || from.textContent !== to.textContent) {
-		if (from.value !== to.value) from.value = to.value;
-		if (from.textContent !== to.textContent) from.textContent = to.textContent;
-	}
-};
-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;
-	}
-};
-/** Rendered element → the live element the morph kept in its place. */
-const adoptedBy = /* @__PURE__ */ new WeakMap();
-/** The element a rendered element ended up as in the document. */
-const committedElement = (el) => adoptedBy.get(el) ?? el;
-/** `live` stays in the document for `fresh`: move the render's bindings. */
-const adopt = (live, fresh) => {
-	adoptedBy.set(fresh, live);
-	adoptEvents(live, fresh);
-};
-/**
-* A contenteditable the render leaves empty is uncontrolled: the user's
-* content (and caret) survives, like an uncontrolled textarea.
-*/
-const isUncontrolledEditable = (from, to) => {
-	const mode = to.getAttribute("contenteditable");
-	return mode !== null && mode !== "false" && !to.hasChildNodes() && from.getAttribute("contenteditable") === mode;
-};
-/** Swap `fromNode` for a rendered node without ever detaching live nodes. */
-const replaceRendered = (fromNode, toNode) => {
-	const parent = fromNode.parentNode;
-	if (!parent) return;
-	insertRendered(parent, toNode, fromNode);
-	fromNode.remove();
-};
-const morphElementPair = (fromEl, toEl, api) => {
-	if (fromEl.localName !== toEl.localName) {
-		replaceRendered(fromEl, toEl);
-		return;
-	}
-	const toSlot = toEl.getAttribute(SLOT_ATTR);
-	const fromSlot = fromEl.getAttribute(SLOT_ATTR);
-	if (toSlot !== null && fromSlot === toSlot) return;
-	if (toSlot !== null) {
-		replaceRendered(fromEl, toEl);
-		return;
-	}
-	adopt(fromEl, toEl);
-	if (fromEl.localName === "input") {
-		morphInput(fromEl, toEl);
-		return;
-	}
-	if (fromEl.localName === "select") {
-		morphSelect(fromEl, toEl, api);
-		return;
-	}
-	const keepChildren = hasPreserveToken(fromEl, "children") || hasPreserveToken(toEl, "children") || isUncontrolledEditable(fromEl, toEl);
-	syncAttributes(fromEl, toEl);
-	if (keepChildren) return;
-	if (fromEl.localName === "textarea") morphTextarea(fromEl, toEl);
-	else api.morphChildren(fromEl, toEl);
-};
-/** Keyed node the new render drops and no stand-in still needs. */
-const isStaleKeyed = (node, toKeys) => {
-	if (!(node instanceof Element) || claimed.has(node)) return false;
-	const key = morphKeyOf(node);
-	return key !== null && !toKeys.has(key);
-};
-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);
-			while (current && current !== match && isStaleKeyed(current, toKeys)) {
-				const next = current.nextSibling;
-				current.remove();
-				current = next ?? void 0;
-			}
-			if (match !== current) {
-				place(fromParent, match, current ?? null);
-				current = match;
-			}
-		}
-	}
-	if (current instanceof Element) {
-		const fromKey = morphKeyOf(current);
-		if (fromKey !== null && fromKey !== toKey && toKeys.has(fromKey)) {
-			insertRendered(fromParent, toNode, current);
-			return "continue";
-		}
-	}
-	return current;
-};
-const morphChild = ({ api, fromParent, fromNode, toNode }) => {
-	if (standIns.has(toNode)) {
-		insertRendered(fromParent, toNode, fromNode ?? null);
-		return;
-	}
-	if (!fromNode || claimed.has(fromNode)) {
-		insertRendered(fromParent, toNode, fromNode ?? null);
-		return;
-	}
-	if (fromNode.nodeType !== toNode.nodeType) {
-		replaceRendered(fromNode, toNode);
-		return;
-	}
-	if (fromNode.nodeType === 3 || fromNode.nodeType === 8) {
-		if (fromNode.nodeValue !== toNode.nodeValue) fromNode.nodeValue = toNode.nodeValue;
-		return;
-	}
-	if (fromNode.nodeType === 1) morphElementPair(fromNode, toNode, api);
-};
-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;
-		}
-		morphChild({
-			api,
-			fromNode,
-			fromParent,
-			toNode
-		});
-	}
-	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/unsafe.ts
-/**
-* Mark a string as pre-rendered HTML and paint it without escaping.
-* Use it for markup you built or sanitized yourself — SVG from an external
-* library, Markdown rendered to HTML, embed codes. Never pass untrusted
-* user input: unlike interpolated strings, this content is not escaped and
-* scripts inserted this way do not run, but event attributes and other
-* markup still apply.
-*/
-const unsafe = (html) => ({
-	$$ilhaUnsafe: 1,
-	html
-});
-const isUnsafeHtml = (x) => {
-	if (!isObject(x)) return false;
-	return x.$$ilhaUnsafe === 1;
-};
-
-//#endregion
-//#region src/paint-core.ts
-const SVG_NS = "http://www.w3.org/2000/svg";
-const MATHML_NS = "http://www.w3.org/1998/Math/MathML";
-const HTML_NS = "http://www.w3.org/1999/xhtml";
-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 parentNsOf = (root) => {
-	if ("namespaceURI" in root) return root.namespaceURI ?? null;
-	return null;
-};
-const elementNs = (lower, parentNs) => {
-	if (lower === "svg") return SVG_NS;
-	if (lower === "math") return MATHML_NS;
-	if (lower === "foreignobject") return HTML_NS;
-	if (parentNs === "http://www.w3.org/2000/svg" || parentNs === "http://www.w3.org/1998/Math/MathML") return parentNs;
-};
-const canMorphRoot = (root) => typeof Element !== "undefined" && typeof document !== "undefined" && root instanceof Element && root.childNodes.length > 0;
-/** Close a child hole through the parent's hole list, so it disposes once. */
-const releaseHole = (fiber, hole) => {
-	const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
-	if (idx === -1) closeFiber(hole);
-	else {
-		const [removed] = fiber.holes.splice(idx, 1);
-		removed?.dispose();
-	}
-};
-const sweepComponentSlots = (fiber) => {
-	const cframe = fiber.componentFrame;
-	if (!cframe) return;
-	const { slots } = cframe;
-	for (let j = cframe.i; j < slots.length; j += 1) {
-		const s = slots[j];
-		if (s && !s.hole.closed) releaseHole(fiber, s.hole);
-		slots[j] = void 0;
-	}
-	slots.length = cframe.i;
-};
-/** Close the keyed components the paint that just ran did not reach. */
-const sweepKeyedHoles = (fiber) => {
-	const { keyedHoles, keyedGen } = fiber;
-	if (!keyedHoles) return;
-	for (const [k, hole] of keyedHoles) {
-		if (!hole.closed && hole.keyedSeen === keyedGen) continue;
-		keyedHoles.delete(k);
-		if (!hole.closed) releaseHole(fiber, hole);
-	}
-};
-/**
-* Run `fn` as one paint of `fiber`: the keyed components it materializes stay
-* alive, and the ones it no longer reaches are closed afterwards.
-*/
-const pass = (fiber, fn) => {
-	fiber.keyedHoles ??= /* @__PURE__ */ new Map();
-	fiber.keyedGen = (fiber.keyedGen ?? 0) + 1;
-	fn();
-	sweepKeyedHoles(fiber);
-};
-/**
-* Dispose a hole fiber's child holes before it repaints, except the component
-* and island holes the repaint can reuse: positional children, keyed
-* children, and islands. Reuse pushes new props instead of remounting, and the
-* sweeps that end the paint close whatever it did not reach.
-*/
-const keepReusableHoles = (fiber, cframe, frame) => {
-	const kept = /* @__PURE__ */ new Set();
-	for (const s of cframe.slots) if (s && !s.hole.closed) kept.add(s.hole);
-	for (const hole of fiber.keyedHoles?.values() ?? []) if (!hole.closed) kept.add(hole);
-	const keptIslands = new Set(frame.slots);
-	const keep = [];
-	for (const h of fiber.holes) {
-		if (h.holeFiber && kept.has(h.holeFiber) || h.islandSlot && keptIslands.has(h.islandSlot)) {
-			keep.push(h);
-			continue;
-		}
-		h.dispose();
-	}
-	fiber.holes = keep;
-};
-/** Shallow equality of two prop bags, children compared item by item. */
-const sameProps = (prev, next) => {
-	if (!prev) return false;
-	const keys = Object.keys(next);
-	if (keys.length !== Object.keys(prev).length) return false;
-	return keys.every((k) => {
-		const a = prev[k];
-		const b = next[k];
-		if (k === "children" && Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((x, i) => Object.is(x, b[i]));
-		return Object.is(a, b);
-	});
-};
-/**
-* Rerun a reused component hole with new props, in its own fiber. The props
-* box is updated in place, so every render closure of the hole reads the
-* latest props, including a self-render queued while an async render ran.
-*/
-const rerunHole = (hole, run, props) => {
-	const box = hole.propsBox ?? { current: props };
-	box.current = props;
-	hole.propsBox = box;
-	runSetup(hole, () => run(box.current));
-};
-/**
-* Run a new component hole's first render after the paint that opened it. A
-* repaint that reached the hole first already rendered it with newer props.
-*/
-const mountHoleLater = (fiber, hole, run) => {
-	fiber.runtime.later(() => {
-		const box = hole.propsBox;
-		if (hole.closed || hole.renderGen !== void 0 || !box) return;
-		runSetup(hole, () => run(box.current));
-	});
-};
-const warnedKeys = /* @__PURE__ */ new Set();
-const warnDuplicateKey = (key) => {
-	if (warnedKeys.has(key)) return;
-	warnedKeys.add(key);
-	console.warn(`ilha: key "${key}" is used by more than one component in the same parent component; keys must be unique there. The duplicate keeps its state by position instead.`);
-};
-const sweepIslandSlots = (fiber) => {
-	const frame = fiber.islandFrame;
-	if (!frame) return;
-	const active = new Set(frame.slots.slice(0, frame.i));
-	const keep = [];
-	for (const h of fiber.holes) {
-		if (h.islandSlot && !active.has(h.islandSlot)) {
-			h.dispose();
-			continue;
-		}
-		keep.push(h);
-	}
-	fiber.holes = keep;
-	frame.slots.length = Math.min(frame.slots.length, frame.i);
-};
-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 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) => {
-	let paintDepth = 0;
-	const pendingRefs = [];
-	const commit = (fn) => {
-		paintDepth += 1;
-		try {
-			fn();
-		} finally {
-			paintDepth -= 1;
-			if (paintDepth === 0) for (const run of pendingRefs.splice(0)) run();
-		}
-	};
-	const applyFormControl = (el, key, v, fiber) => {
-		const setProp = (x) => ops.setFormControl(ops.committed(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();
-				if (memo.__ilhaVal === v) memo.__ilhaVal = void 0;
-			} });
-		} 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 (ops.setProp?.(el, k, v) === true) 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;
-			const attach = () => refFn(ops.asElement(ops.committed(el)));
-			if (paintDepth > 0) pendingRefs.push(attach);
-			else attach();
-			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) => {
-					const error = toError(e);
-					if (reportFiberError(child, error)) return;
-					parent.runtime.onError?.(error);
-					console.error(error);
-					api.paintHole(child, errorView(error));
-				},
-				parent
-			});
-			return {
-				fiber: child,
-				nodes: [host]
-			};
-		},
-		paintHole: (fiber, view) => {
-			if (view === KEEP) return;
-			commit(() => {
-				pass(fiber, () => {
-					let frame = fiber.islandFrame;
-					if (!frame) {
-						frame = {
-							i: 0,
-							slots: []
-						};
-						fiber.islandFrame = frame;
-					}
-					frame.i = 0;
-					let cframe = fiber.componentFrame;
-					if (!cframe) {
-						cframe = {
-							i: 0,
-							slots: []
-						};
-						fiber.componentFrame = cframe;
-					}
-					cframe.i = 0;
-					const list = Array.isArray(view) ? view : null;
-					if (list && list.length > 0 && list.every((v) => isVNode(v) && isFunction(v.type) && v.key !== null && v.key !== void 0)) {
-						paintFns.keyedPaintHole(fiber, list);
-						sweepComponentSlots(fiber);
-						sweepIslandSlots(fiber);
-						return;
-					}
-					keepReusableHoles(fiber, cframe, frame);
-					const fresh = api.materialize(view, fiber);
-					if (canMorphRoot(fiber.root)) {
-						const tmp = document.createElement("div");
-						for (const n of fresh) tmp.append(n);
-						morphInner(fiber.root, tmp);
-					} else ops.placeChildren(fiber.root, fresh);
-					sweepComponentSlots(fiber);
-					sweepIslandSlots(fiber);
-				});
-			});
-		}
-	};
-	const materializeAtom = (view, fiber) => {
-		const reused = findReusableAtomHost(fiber, view.atom);
-		if (reused) return [ops.reuseNode(reused.host)];
-		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$1.take(1)) : view;
-		const effect = Effect$1.gen(function* streamPaint() {
-			const result = yield* Effect$1.result(Stream$1.runForEach(src, (v) => Effect$1.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.reuseNode(existing.host)];
-		}
-		if (existing) {
-			const idx = fiber.holes.findIndex((h) => h.islandSlot === existing);
-			if (idx === -1) existing.unmount?.();
-			else {
-				const [removed] = fiber.holes.splice(idx, 1);
-				removed?.dispose();
-			}
-		}
-		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;
-				},
-				islandSlot: slot,
-				keepOnMorph: true
-			});
-		}
-		return [el];
-	};
-	const materializeUnkeyedComponent = (run, type, props, fiber) => {
-		let { componentFrame: cframe } = fiber;
-		if (!cframe) {
-			cframe = {
-				i: 0,
-				slots: []
-			};
-			fiber.componentFrame = cframe;
-		}
-		const at = cframe.i;
-		cframe.i = at + 1;
-		const existing = cframe.slots[at];
-		if (existing) {
-			const { hole } = existing;
-			if (existing.type === type && !hole.closed) {
-				rerunHole(hole, run, props);
-				return [ops.reuseNode(hole.root)];
-			}
-			if (!hole.closed) releaseHole(fiber, hole);
-		}
-		const { fiber: hole, nodes } = api.openHole(fiber);
-		hole.propsBox = { current: props };
-		hole.componentType = type;
-		cframe.slots[at] = {
-			hole,
-			type
-		};
-		mountHoleLater(fiber, hole, run);
-		trackHole(fiber, hole, void 0, { keyed: true });
-		return nodes;
-	};
-	const materializeKeyedComponent = ({ run, type, props, key, fiber }) => {
-		let reuse = fiber.keyedHoles?.get(key);
-		const gen = fiber.keyedGen;
-		if (reuse && !reuse.closed && reuse.keyedSeen === gen) {
-			warnDuplicateKey(key);
-			return materializeUnkeyedComponent(run, type, props, fiber);
-		}
-		if (reuse && !reuse.closed && reuse.componentType !== type) {
-			fiber.keyedHoles?.delete(key);
-			releaseHole(fiber, reuse);
-			reuse = void 0;
-		}
-		if (reuse && !reuse.closed) {
-			reuse.keyedSeen = gen;
-			if (!sameProps(reuse.propsBox?.current, props)) rerunHole(reuse, run, props);
-			return [ops.reuseNode(reuse.root)];
-		}
-		const { fiber: khole, nodes: knodes } = api.openHole(fiber);
-		khole.propsBox = { current: props };
-		khole.componentType = type;
-		khole.keyedSeen = gen;
-		fiber.keyedHoles?.set(key, khole);
-		mountHoleLater(fiber, khole, run);
-		trackHole(fiber, khole, void 0, { keyed: true });
-		return knodes;
-	};
-	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 run = type;
-		if (view.key === null || view.key === void 0) return materializeUnkeyedComponent(run, type, props, fiber);
-		return materializeKeyedComponent({
-			fiber,
-			key: String(view.key),
-			props,
-			run,
-			type
-		});
-	};
-	const materializeElement = (view, fiber) => {
-		const tag = view.type;
-		const lower = tag.toLowerCase();
-		const ns = elementNs(lower, parentNsOf(fiber.root));
-		const el = ops.createElement(tag, ns);
-		if (view.key !== null && view.key !== void 0) el.setAttribute(KEY_ATTR, String(view.key));
-		api.applyProps(el, view.props, fiber);
-		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 [ops.createText("")];
-		if (isUnsafeHtml(view)) return ops.createRaw(view.html, fiber.root);
-		if (isTextish(view)) return [ops.createText(String(view))];
-		if (isAtomHandle(view)) return materializeAtom(view, fiber);
-		if (Stream$1.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 nodes = [];
-		for (const v of views) {
-			const reuse = fiber.keyedHoles?.get(String(v.key));
-			const reusable = reuse && !reuse.closed && reuse.keyedSeen !== fiber.keyedGen && reuse.componentType === v.type;
-			if (reuse && reusable) {
-				reuse.keyedSeen = fiber.keyedGen;
-				const props = {
-					...v.props,
-					children: v.children
-				};
-				if (!sameProps(reuse.propsBox?.current, props)) rerunHole(reuse, v.type, props);
-				nodes.push(ops.asNode(reuse.root));
-				continue;
-			}
-			nodes.push(...api.materialize(v, fiber));
-		}
-		ops.placeChildren(fiber.root, nodes);
-	};
-	return {
-		applyProps: api.applyProps,
-		commit,
-		disposeHoles: (fiber, opts) => disposeHoles(fiber, opts),
-		insert: api.insert,
-		materialize: api.materialize,
-		paintHole: api.paintHole,
-		pass
-	};
-};
-
-//#endregion
-export { makeFiber as C, getFiber as S, makeRuntime as T, structuralEqual as _, morphInner as a, clearFiberView as b, bindEvents as c, interpret as d, atom as f, isAtomHandle as g, instr as h, insertRendered as i, eventTypeFromProp as l, handleOwner as m, unsafe as n, placeChildren as o, batch as p, committedElement as r, standInFor as s, createPainter as t, runSetup as u, untrack as v, makeRootFiber as w, closeFiber as x, wrapHandle as y };