pudui 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1505 @@
+import { c as jsxDEV, d as normalizeChildren, f as readRawChildHtml, l as isEmptyChild, n as Raw, o as isVNode, r as createElement, s as jsx, t as Fragment, u as isRawChild } from "./vnode-Lr-Tpypk.mjs";
+import { a as isRawStartCommentData, g as readDangerouslySetInnerHTML, h as isPrimitiveValue, i as isRawEndCommentData, m as isChildlessElement, n as isHydrateMetaCommentData, o as parseHydrateMetaCommentData, p as attributeName, r as isHydrateStartCommentData, s as parseHydrateStartCommentData, t as isHydrateEndCommentData, v as toKebabCase } from "./hydration-markers-DdjOvH6g.mjs";
+import { a as isComponent, d as resolveComponent, f as setComponentProps, h as invariant, i as finishComponentRender, l as renderComponentErrorOutput, m as fail, n as beginComponentRender, o as queueComponentMount, p as subscribeComponent, r as createComponent, s as readComponentHydrateMeta, t as Component, u as renderComponentOutput } from "./component-D3kwgmef.mjs";
+//#region src/core/hydration.ts
+/**
+* Checks whether a value is a hydrated child boundary wrapper.
+*
+* @param value Value to inspect.
+* @returns `true` when the value stores hydration boundary state.
+*/
+function isHydratedChildren(value) {
+	return typeof value === "object" && value !== null && "b" in value;
+}
+/**
+* Creates a hydrated child wrapper from boundary metadata.
+*
+* @param boundary Hydration boundary metadata.
+* @returns Hydrated child wrapper.
+*/
+function createHydratedChildren(boundary) {
+	return { b: boundary };
+}
+/**
+* Replaces the boundary metadata stored by a hydrated child wrapper.
+*
+* @param children Hydrated child wrapper to update.
+* @param boundary Next hydration boundary metadata.
+*/
+function updateHydratedChildrenBoundary(children, boundary) {
+	children.b = boundary;
+}
+//#endregion
+//#region src/runtime/props.ts
+/**
+* Patches DOM attributes and selected properties from old props to new props.
+*
+* @param element Element to patch.
+* @param oldProps Previous intrinsic props.
+* @param newProps Next intrinsic props.
+*/
+function patchProps(element, oldProps, newProps) {
+	for (const [rawName, value] of Object.entries(newProps)) {
+		if (shouldSkipProp(rawName)) continue;
+		const name = attributeName(rawName);
+		if (rawName === "style") {
+			patchStyle(element, oldProps.style, value);
+			continue;
+		}
+		const oldAttributeValue = attributeValue(readPropValue(oldProps, rawName));
+		const newAttributeValue = attributeValue(value);
+		if (oldAttributeValue !== newAttributeValue) if (newAttributeValue === void 0) element.removeAttribute(name);
+		else element.setAttribute(name, newAttributeValue);
+	}
+	for (const rawName of Object.keys(oldProps)) {
+		if (shouldSkipProp(rawName) || readPropValue(newProps, rawName) !== void 0) continue;
+		if (rawName === "style") {
+			if (oldProps.style != null) element.removeAttribute("style");
+		} else if (attributeValue(oldProps[rawName]) !== void 0) element.removeAttribute(attributeName(rawName));
+	}
+	if (element instanceof HTMLInputElement) {
+		if ("checked" in newProps && (element.type === "checkbox" || element.type === "radio")) element.checked = newProps.checked === true;
+	}
+}
+function shouldSkipProp(rawName) {
+	return " children dangerouslySetInnerHTML key ref ".includes(" " + rawName + " ") || rawName.startsWith("on");
+}
+function readPropValue(props, rawName) {
+	const value = props[rawName];
+	if (value !== void 0) return value;
+	if (rawName === "class") return props.className;
+	if (rawName === "className") return props.class;
+	if (rawName === "for") return props.htmlFor;
+	if (rawName === "htmlFor") return props.for;
+}
+function attributeValue(value) {
+	if (value === true) return "";
+	if (isPrimitiveValue(value)) return String(value);
+}
+function patchStyle(element, oldStyle, newStyle) {
+	if (newStyle == null) {
+		if (oldStyle != null) element.removeAttribute("style");
+		return;
+	}
+	const style = newStyle;
+	if (oldStyle) {
+		for (const [name, value] of Object.entries(oldStyle)) if (value != null && style[name] == null) element.style.removeProperty(toKebabCase(name));
+	}
+	const htmlElement = element;
+	for (const [name, value] of Object.entries(style)) {
+		if (value == null) continue;
+		const oldValue = oldStyle?.[name];
+		if (oldValue != null && oldValue == value) continue;
+		setStyle(htmlElement, name, value);
+	}
+}
+function setStyle(element, name, value) {
+	const propertyName = toKebabCase(name);
+	const propertyValue = String(value);
+	element.style.setProperty(propertyName, propertyValue);
+}
+//#endregion
+//#region src/runtime/refs.ts
+/**
+* Queues ref callbacks to run after an element is committed.
+*
+* @param element Element passed to the ref callbacks.
+* @param ref Ref callback or nested ref callbacks.
+* @param effects Commit effect queues.
+* @param cleanups Cleanup list that receives returned ref cleanups.
+*/
+function collectRefEffects(element, ref, effects, cleanups) {
+	if (!ref) return;
+	effects.r.push(() => {
+		runRefValue(element, ref, cleanups);
+	});
+}
+function runRefValue(element, ref, cleanups) {
+	if (!Array.isArray(ref)) {
+		const cleanup = ref(element);
+		if (typeof cleanup === "function") cleanups.push(cleanup);
+		return;
+	}
+	for (const nestedRef of ref) runRefValue(element, nestedRef, cleanups);
+}
+/**
+* Runs commit effects in order.
+*
+* @param effects Effects to run.
+*/
+function runEffects(effects) {
+	for (const effect of effects) effect();
+}
+/**
+* Runs ref cleanups in reverse registration order.
+*
+* @param cleanups Cleanup callbacks to run.
+*/
+function runCleanups(cleanups) {
+	for (let index = cleanups.length - 1; index >= 0; index--) cleanups[index]();
+}
+//#endregion
+//#region src/client.ts
+const textRenderNodeKind = 0;
+const arrayRenderNodeKind = 1;
+const componentRenderNodeKind = 2;
+const elementRenderNodeKind = 3;
+const hydratedRenderNodeKind = 4;
+const rawRenderNodeKind = 5;
+const skippedHydrationRenderNodeKind = 6;
+const activeHydrationBoundaries = /* @__PURE__ */ new WeakMap();
+const stylesheetPromisesByDocument = /* @__PURE__ */ new WeakMap();
+const loadedStylesheetsByDocument = /* @__PURE__ */ new WeakMap();
+let pendingHydrationBoundaryRefreshes;
+function renderContextWithOwner(context, owner) {
+	return context.owner === owner ? context : {
+		...context,
+		owner
+	};
+}
+/**
+* Creates a ref that wires a DOM event listener to an element.
+*
+* Each time the event fires, the previous handler invocation for that element
+* is aborted and the new invocation receives a fresh `AbortSignal`. This makes
+* async event handlers straightforward to cancel during rapid input.
+*
+* @param type DOM event name to listen for.
+* @param handler Callback invoked for each event with a cancellation signal.
+* @param options Options passed to `addEventListener`.
+* @returns A ref callback that installs and removes the listener.
+*
+* @example
+* ```tsx
+* <button
+*   ref={event("click", async (_event, signal) => {
+*     await save({ signal });
+*   })}
+* >
+*   Save
+* </button>
+* ```
+*/
+function event(type, handler, options) {
+	return (element) => {
+		const listener = (event) => {
+			const newController = new AbortController();
+			const target = event.currentTarget ?? event.target ?? window;
+			target._puduiAbortController?.abort();
+			target._puduiAbortController = newController;
+			return handler(event, newController.signal);
+		};
+		element.addEventListener(type, listener, options);
+		return () => {
+			element.removeEventListener(type, listener, options);
+		};
+	};
+}
+/**
+* Mounts a child tree into a DOM container.
+*
+* The container's existing children are replaced on the initial render. Later
+* calls to `rerender()` patch the DOM in place when possible.
+*
+* @param child Child tree to render.
+* @param container DOM element or fragment to own.
+* @returns A root controller for rerendering or unmounting.
+*
+* @example
+* ```tsx
+* import { render } from "pudui";
+*
+* const root = render(<main>Hello</main>, document.body);
+* root.rerender(<main>Updated</main>);
+* ```
+*/
+function render(child, container) {
+	let currentChild = child;
+	let mounted = true;
+	let renderNode;
+	const root = new Component({ render() {
+		return currentChild;
+	} });
+	const commit = () => {
+		if (!mounted) return false;
+		if (renderNode !== void 0) {
+			const pendingStylesheets = waitForConnectedStylesheets(ownerDocumentFor(container));
+			if (pendingStylesheets !== void 0) return pendingStylesheets.then(commit);
+		}
+		const effects = {
+			m: [],
+			r: []
+		};
+		const context = {
+			document: ownerDocumentFor(container),
+			effects,
+			owner: void 0,
+			scheduleUpdate: commit
+		};
+		if (renderNode === void 0) {
+			renderNode = childToRenderNode(root, context);
+			container.replaceChildren(renderNodeToFragment(renderNode));
+		} else renderNode = patchRenderNode(renderNode, root, context);
+		runEffects(effects.r);
+		runEffects(effects.m);
+		return true;
+	};
+	commit();
+	return {
+		rerender(nextChild) {
+			currentChild = nextChild;
+			commit();
+		},
+		unmount() {
+			mounted = false;
+			if (renderNode !== void 0) {
+				cleanupRenderNode(renderNode);
+				renderNode = void 0;
+			}
+			container.replaceChildren();
+		}
+	};
+}
+/**
+* Hydrates server-rendered Pudui boundaries in a document or element.
+*
+* The root scans for hydration comments emitted by `renderToString()` and uses
+* `options.load` to import component factories when a boundary becomes active.
+*
+* @param root Document, element, or fragment containing server-rendered markup.
+* @param options Hydration loader options.
+* @returns A root controller for rerendering or unmounting.
+*
+* @example
+* ```tsx
+* import { hydrate } from "pudui";
+* import { load } from "pudui/vite-runtime";
+*
+* hydrate(document, { load });
+* ```
+*/
+function hydrate(root, options) {
+	const hydrationRoot = createHydrationRoot(root, options);
+	hydrationRoot.hydrate();
+	return hydrationRoot.root;
+}
+function createHydrationRoot(container, options) {
+	let currentChild;
+	let mounted = true;
+	let renderNode;
+	let boundaryRoots = [];
+	let hydrationRequest = 0;
+	const document = ownerDocumentFor(container);
+	const commit = () => {
+		if (!mounted || renderNode === void 0 || currentChild === void 0) return false;
+		const pendingStylesheets = waitForConnectedStylesheets(document);
+		if (pendingStylesheets !== void 0) return pendingStylesheets.then(commit);
+		const effects = {
+			m: [],
+			r: []
+		};
+		renderNode = patchRenderNode(renderNode, currentChild, {
+			document,
+			effects,
+			hydrateOptions: options,
+			owner: void 0,
+			scheduleUpdate: commit
+		});
+		runEffects(effects.r);
+		runEffects(effects.m);
+		return true;
+	};
+	const hydrateBoundaries = () => {
+		const request = ++hydrationRequest;
+		boundaryRoots = hydrateRootBoundaries(container, options, (hydrationRoot) => {
+			if (!mounted || request !== hydrationRequest || renderNode !== void 0) {
+				hydrationRoot.u();
+				return;
+			}
+			boundaryRoots.push(hydrationRoot);
+		});
+	};
+	return {
+		hydrate() {
+			hydrateBoundaries();
+		},
+		root: {
+			rerender(nextChild) {
+				currentChild = nextChild;
+				if (container instanceof Document && isRawChild(nextChild)) {
+					const request = ++hydrationRequest;
+					const html = readRawChildHtml(nextChild);
+					const pendingStylesheets = waitForHtmlStylesheets(container, html);
+					const replace = () => {
+						if (!mounted || request !== hydrationRequest) return;
+						cleanupBoundaryHydrationRoots(boundaryRoots, { removeContents: false });
+						boundaryRoots = [];
+						if (renderNode !== void 0) {
+							cleanupRenderNode(renderNode);
+							renderNode = void 0;
+						}
+						patchDocumentWithHtml(container, html);
+						hydrateBoundaries();
+					};
+					if (pendingStylesheets === void 0) replace();
+					else pendingStylesheets.then(replace);
+					return;
+				}
+				hydrationRequest++;
+				cleanupBoundaryHydrationRoots(boundaryRoots);
+				boundaryRoots = [];
+				if (renderNode === void 0) {
+					const effects = {
+						m: [],
+						r: []
+					};
+					renderNode = childToRenderNode(nextChild, {
+						document,
+						effects,
+						hydrateOptions: options,
+						owner: void 0,
+						scheduleUpdate: commit
+					});
+					container.replaceChildren(renderNodeToFragment(renderNode));
+					runEffects(effects.r);
+					runEffects(effects.m);
+				} else commit();
+			},
+			unmount() {
+				mounted = false;
+				hydrationRequest++;
+				cleanupBoundaryHydrationRoots(boundaryRoots);
+				boundaryRoots = [];
+				if (renderNode !== void 0) {
+					cleanupRenderNode(renderNode);
+					renderNode = void 0;
+				}
+				container.replaceChildren();
+			}
+		}
+	};
+}
+function hydrateBoundary(initialBoundary, factory, options) {
+	let boundary = initialBoundary;
+	let hydratedChildren = createHydratedChildren(boundary);
+	let component = createHydratedComponent(boundary, factory, hydratedChildren);
+	const document = boundary.s.ownerDocument;
+	let mounted = true;
+	let renderNode;
+	const commit = () => {
+		if (!mounted || renderNode === void 0) return false;
+		const pendingStylesheets = waitForConnectedStylesheets(document);
+		if (pendingStylesheets !== void 0) return pendingStylesheets.then(commit);
+		const effects = {
+			m: [],
+			r: []
+		};
+		renderNode = patchRenderNode(renderNode, component, {
+			document,
+			effects,
+			hydrateOptions: options,
+			owner: void 0,
+			scheduleUpdate: commit
+		});
+		runEffects(effects.r);
+		runEffects(effects.m);
+		return true;
+	};
+	const hydrate = () => {
+		const parent = boundary.s.parentNode;
+		if (!parent) return;
+		const effects = {
+			m: [],
+			r: []
+		};
+		renderNode = hydrateComponentToDom(component, {
+			document,
+			effects,
+			hydrateOptions: options,
+			owner: void 0,
+			scheduleUpdate: commit
+		}, boundary.s.nextSibling, component, parent, boundary.s, boundary.e).r;
+		runEffects(effects.r);
+		runEffects(effects.m);
+	};
+	const hydrationRoot = {
+		r(index, props, key) {
+			const nextBoundary = {
+				...boundary,
+				i: index,
+				k: key,
+				p: props
+			};
+			if (boundary.k !== key) {
+				if (renderNode !== void 0) cleanupRenderNode(renderNode);
+				boundary = nextBoundary;
+				hydratedChildren = createHydratedChildren(boundary);
+				component = createHydratedComponent(boundary, factory, hydratedChildren);
+				hydrate();
+				return;
+			}
+			boundary = nextBoundary;
+			updateHydratedChildrenBoundary(hydratedChildren, boundary);
+			setHydratedComponentProps(component, boundary, hydratedChildren);
+			if (renderNode !== void 0) cleanupRenderNode(renderNode);
+			hydrate();
+		},
+		s: boundary.s,
+		u(options) {
+			mounted = false;
+			activeHydrationBoundaries.delete(boundary.s);
+			if (renderNode !== void 0) {
+				cleanupRenderNode(renderNode);
+				renderNode = void 0;
+			}
+			if (options?.removeContents !== false) removeBoundaryContents(boundary);
+		}
+	};
+	activeHydrationBoundaries.set(boundary.s, hydrationRoot);
+	hydrate();
+	return hydrationRoot;
+}
+function createHydratedComponent(boundary, factory, children) {
+	return createComponent(factory, hydratedComponentProps(boundary, children));
+}
+function setHydratedComponentProps(component, boundary, children) {
+	setComponentProps(component, hydratedComponentProps(boundary, children));
+}
+function hydratedComponentProps(boundary, children) {
+	return {
+		...boundary.p,
+		children
+	};
+}
+function hydrateRootBoundaries(root, options, onAsyncHydrationRoot) {
+	const [boundaries, hydrateMeta] = findHydrationBoundaries(root);
+	const hydrationRoots = [];
+	for (const boundary of boundaries) {
+		const meta = hydrateMeta.get(boundary.i);
+		if (meta === void 0) fail("hydrate metadata");
+		const loaded = options.load(meta);
+		if (isPromiseLike(loaded)) loaded.then((factory) => {
+			onAsyncHydrationRoot(hydrateBoundary(boundary, factory, options));
+		}, () => {});
+		else hydrationRoots.push(hydrateBoundary(boundary, loaded, options));
+	}
+	return hydrationRoots;
+}
+function isPromiseLike(value) {
+	return typeof value?.then === "function";
+}
+function cleanupBoundaryHydrationRoots(hydrationRoots, options) {
+	for (const hydrationRoot of hydrationRoots) hydrationRoot.u(options);
+	hydrationRoots.length = 0;
+}
+function childToRenderNode(child, context) {
+	if (isHydratedChildren(child)) return hydratedChildrenToRenderNode(child, context.document);
+	if (isEmptyChild(child) || isPrimitiveValue(child)) return textToRenderNode(child, context.document);
+	if (isRawChild(child)) return rawToRenderNode(child, context.document, context.hydrateOptions);
+	if (Array.isArray(child)) return arrayToRenderNode(child, context);
+	if (isComponent(child)) return componentToRenderNode(child, context);
+	if (isVNode(child)) {
+		if (typeof child.type === "function") return childToRenderNode(resolveComponent(child, context.owner), context);
+		return elementToRenderNode(child, context);
+	}
+	return textToRenderNode(null, context.document);
+}
+function hydrateChildToDom(child, context, currentNode, rootComponent, parent) {
+	if (isHydratedChildren(child)) return hydrateHydratedChildren(child, currentNode, parent);
+	if (isEmptyChild(child) || isPrimitiveValue(child)) return hydrateTextToDom(child, currentNode, parent);
+	if (isRawChild(child)) return hydrateRawToDom(child, context, currentNode, parent);
+	if (Array.isArray(child)) {
+		let nextNode = currentNode;
+		const start = insertMarker(parent, nextNode);
+		const children = [];
+		for (const nestedChild of normalizeHydratedChildren(child)) {
+			const result = hydrateChildToDom(nestedChild, context, nextNode, rootComponent, parent);
+			nextNode = result.n;
+			children.push(result.r);
+		}
+		const end = insertMarker(parent, nextNode);
+		return {
+			n: nextNode,
+			r: {
+				c: children,
+				e: end,
+				k: arrayRenderNodeKind,
+				s: start
+			}
+		};
+	}
+	if (isComponent(child)) {
+		if (child !== rootComponent && readComponentHydrateMeta(child) !== void 0) return hydrateSkippedBoundary(currentNode, parent);
+		return hydrateComponentToDom(child, context, currentNode, rootComponent, parent);
+	}
+	if (isVNode(child)) {
+		if (typeof child.type === "function") return hydrateChildToDom(resolveComponent(child, context.owner), context, currentNode, rootComponent, parent);
+		return hydrateElementToDom(child, context, currentNode, rootComponent, parent);
+	}
+	return hydrateTextToDom(null, currentNode, parent);
+}
+function hydrateElementToDom(vnode, context, currentNode, rootComponent, parent) {
+	const element = nextHydratableNode(currentNode);
+	if (!(element instanceof Element) || element.localName !== vnode.type) {
+		const node = elementToRenderNode(vnode, context);
+		insertRenderNode(parent, node, currentNode);
+		return {
+			n: currentNode,
+			r: node
+		};
+	}
+	let child;
+	if (!isChildlessElement(vnode.type) && readDangerouslySetInnerHTML(vnode.props) === void 0) child = hydrateChildToDom(vnode.props.children ?? null, context, element.firstChild, rootComponent, element).r;
+	const node = {
+		c: child,
+		k: elementRenderNodeKind,
+		n: element,
+		r: [],
+		v: snapshotHostVNode(vnode)
+	};
+	collectRefEffects(element, vnode.props.ref, context.effects, node.r);
+	return {
+		n: element.nextSibling,
+		r: node
+	};
+}
+function hydrateComponentToDom(component, context, currentNode, rootComponent, parent, start, end) {
+	const componentStart = start ?? insertMarker(parent, currentNode);
+	const unsubscribe = subscribeComponent(component, context.scheduleUpdate);
+	let result;
+	try {
+		renderComponentChild(component, context.effects, (renderedChild) => {
+			result = hydrateChildToDom(renderedChild, renderContextWithOwner(context, component), currentNode, rootComponent, parent);
+			return result;
+		});
+	} catch (reason) {
+		unsubscribe();
+		throw reason;
+	}
+	if (result === void 0) {
+		unsubscribe();
+		fail("hydrate result");
+	}
+	const componentEnd = end ?? insertMarker(parent, result.n);
+	return {
+		n: end ? end.nextSibling : result.n,
+		r: {
+			c: result.r,
+			e: componentEnd,
+			k: componentRenderNodeKind,
+			s: componentStart,
+			u: unsubscribe,
+			v: component
+		}
+	};
+}
+function hydrateTextToDom(value, currentNode, parent) {
+	const textNode = nextHydratableNode(currentNode);
+	if (textNode?.nodeType === Node.TEXT_NODE) return {
+		n: textNode.nextSibling,
+		r: {
+			k: textRenderNodeKind,
+			n: textNode
+		}
+	};
+	const node = ownerDocumentFor(parent).createTextNode(textValue(value));
+	parent.insertBefore(node, currentNode);
+	return {
+		n: currentNode,
+		r: {
+			k: textRenderNodeKind,
+			n: node
+		}
+	};
+}
+function hydrateRawToDom(raw, context, currentNode, parent) {
+	const start = nextHydratableNode(currentNode);
+	if (isRawStartComment(start)) {
+		const end = findDelimitedEnd(start, isRawStartComment, isRawEndComment);
+		if (end) return {
+			n: end.nextSibling,
+			r: hydrateRawRenderNode({
+				e: end,
+				h: [],
+				k: rawRenderNodeKind,
+				r: raw,
+				s: start
+			}, context.hydrateOptions)
+		};
+	}
+	const node = rawToRenderNode(raw, context.document, context.hydrateOptions);
+	insertRenderNode(parent, node, currentNode);
+	return {
+		n: currentNode,
+		r: node
+	};
+}
+function hydrateHydratedChildren(children, currentNode, parent) {
+	const start = insertMarker(parent, currentNode);
+	children.n = currentNode;
+	let node = currentNode;
+	while (node && node !== children.b.e) node = node.nextSibling;
+	return {
+		n: node,
+		r: {
+			c: children,
+			e: insertMarker(parent, node),
+			k: hydratedRenderNodeKind,
+			s: start
+		}
+	};
+}
+function hydrateSkippedBoundary(currentNode, parent) {
+	const start = findNextHydrateStart(currentNode);
+	const end = start ? findDelimitedEnd(start, isHydrateStartComment, isHydrateEndComment) : void 0;
+	if (!start || !end) return hydrateTextToDom(null, currentNode, parent);
+	return {
+		n: end.nextSibling,
+		r: {
+			e: end,
+			k: skippedHydrationRenderNodeKind,
+			s: start
+		}
+	};
+}
+function normalizeHydratedChildren(children) {
+	const normalized = [];
+	let text = "";
+	for (const child of normalizeChildren(children)) {
+		if (isPrimitiveValue(child)) {
+			text += String(child);
+			continue;
+		}
+		if (text) {
+			normalized.push(text);
+			text = "";
+		}
+		normalized.push(child);
+	}
+	if (text) normalized.push(text);
+	return normalized;
+}
+function patchRenderNode(node, nextChild, context) {
+	const replace = () => replaceRenderNode(node, nextChild, context);
+	if (isHydratedChildren(nextChild)) {
+		if (node.k === hydratedRenderNodeKind && node.c === nextChild) return node;
+		return replace();
+	}
+	if (isEmptyChild(nextChild) || isPrimitiveValue(nextChild)) {
+		if (node.k === textRenderNodeKind) {
+			const nextValue = textValue(nextChild);
+			if (node.n.data !== nextValue) node.n.data = nextValue;
+			return node;
+		}
+		return replace();
+	}
+	if (isRawChild(nextChild)) {
+		if (node.k === rawRenderNodeKind) return patchRawRenderNode(node, nextChild, context);
+		return replace();
+	}
+	if (Array.isArray(nextChild)) {
+		if (node.k === arrayRenderNodeKind) return patchArrayRenderNode(node, nextChild, context);
+		return replace();
+	}
+	if (isComponent(nextChild)) {
+		if (node.k === componentRenderNodeKind && node.v === nextChild) return patchComponentRenderNode(node, nextChild, context);
+		return replace();
+	}
+	if (isVNode(nextChild)) {
+		if (typeof nextChild.type === "function") return patchRenderNode(node, resolveComponent(nextChild, context.owner), context);
+		const vnode = nextChild;
+		if (node.k === elementRenderNodeKind && node.v.type === vnode.type && node.v.key === vnode.key) return patchElementRenderNode(node, vnode, context);
+		return replace();
+	}
+	return patchRenderNode(node, null, context);
+}
+function patchArrayRenderNode(node, nextChildren, context) {
+	const normalizedChildren = normalizeChildren(nextChildren);
+	if (shouldPatchKeyedArray(node.c, normalizedChildren)) return patchKeyedArrayRenderNode(node, normalizedChildren, context);
+	const sharedLength = Math.min(node.c.length, normalizedChildren.length);
+	for (let index = 0; index < sharedLength; index++) node.c[index] = patchRenderNode(node.c[index], normalizedChildren[index], context);
+	const parent = node.e.parentNode;
+	const addedChildren = [];
+	for (let index = sharedLength; index < normalizedChildren.length; index++) {
+		if (!parent) break;
+		const child = childToRenderNode(normalizedChildren[index], context);
+		node.c.push(child);
+		addedChildren.push(child);
+	}
+	if (parent && addedChildren.length > 0) {
+		const fragment = context.document.createDocumentFragment();
+		for (const child of addedChildren) appendRenderNode(fragment, child);
+		parent.insertBefore(fragment, node.e);
+	}
+	const removedChildren = node.c.splice(normalizedChildren.length);
+	for (let index = removedChildren.length - 1; index >= 0; index--) {
+		const child = removedChildren[index];
+		cleanupRenderNode(child);
+	}
+	const firstRemovedChild = removedChildren[0];
+	const lastRemovedChild = removedChildren.at(-1);
+	if (firstRemovedChild && lastRemovedChild) removeNodeRange(renderNodeStart(firstRemovedChild), renderNodeEnd(lastRemovedChild));
+	return node;
+}
+function patchKeyedArrayRenderNode(node, normalizedChildren, context) {
+	const parent = node.e.parentNode;
+	const oldEntries = /* @__PURE__ */ new Map();
+	for (let index = 0; index < node.c.length; index++) oldEntries.set(readRenderNodeKey(node.c[index]), {
+		i: index,
+		n: node.c[index]
+	});
+	const nextNodes = [];
+	const oldIndexes = [];
+	for (const child of normalizedChildren) {
+		const key = readChildKey(child);
+		const oldEntry = oldEntries.get(key);
+		if (oldEntry) {
+			oldEntries.delete(key);
+			nextNodes.push(patchRenderNode(oldEntry.n, child, context));
+			oldIndexes.push(oldEntry.i + 1);
+		} else {
+			nextNodes.push(childToRenderNode(child, context));
+			oldIndexes.push(0);
+		}
+	}
+	for (const { n: removedNode } of oldEntries.values()) {
+		cleanupRenderNode(removedNode);
+		removeRenderNode(removedNode);
+	}
+	if (parent) {
+		const stableIndexes = lis(oldIndexes);
+		let stableCursor = stableIndexes.length - 1;
+		let anchor = node.e;
+		for (let index = nextNodes.length - 1; index >= 0; index--) {
+			const child = nextNodes[index];
+			if (stableIndexes[stableCursor] === index) stableCursor--;
+			else insertRenderNode(parent, child, anchor);
+			anchor = renderNodeStart(child);
+		}
+	}
+	node.c = nextNodes;
+	return node;
+}
+function shouldPatchKeyedArray(oldNodes, nextChildren) {
+	const firstOld = oldNodes[0];
+	const firstNext = nextChildren[0];
+	if (firstOld?.k !== elementRenderNodeKind || firstOld.v.key === void 0 || !isVNode(firstNext) || firstNext.key === void 0) return false;
+	if (oldNodes.length <= nextChildren.length) {
+		for (let index = 0; index < oldNodes.length; index++) if (readRenderNodeKey(oldNodes[index]) !== readChildKey(nextChildren[index])) return true;
+		return false;
+	}
+	return true;
+}
+function readChildKey(child) {
+	return isVNode(child) ? child.key : void 0;
+}
+function readRenderNodeKey(node) {
+	return node.k === elementRenderNodeKind ? node.v.key : void 0;
+}
+function lis(values) {
+	const p = Array.from({ length: values.length });
+	const t = [];
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		if (value === 0) continue;
+		let low = 0;
+		let high = t.length;
+		while (low < high) {
+			const middle = low + high >> 1;
+			if (values[t[middle]] < value) low = middle + 1;
+			else high = middle;
+		}
+		p[index] = low > 0 ? t[low - 1] : -1;
+		t[low] = index;
+	}
+	let cursor = t.at(-1) ?? -1;
+	for (let index = t.length - 1; index >= 0; index--) {
+		t[index] = cursor;
+		cursor = p[cursor] ?? -1;
+	}
+	return t;
+}
+function patchComponentRenderNode(node, component, context) {
+	return renderComponentChild(component, context.effects, (renderedChild) => {
+		node.c = patchRenderNode(node.c, renderedChild, renderContextWithOwner(context, component));
+		return node;
+	});
+}
+function patchRawRenderNode(node, raw, context) {
+	if (readRawChildHtml(node.r) === readRawChildHtml(raw)) {
+		node.r = raw;
+		return node;
+	}
+	const parent = node.s.parentNode;
+	if (parent !== null && parent === node.e.parentNode) patchDomChildren(parent, node.s.nextSibling, htmlToFragment(parent, readRawChildHtml(raw)).childNodes, context.document, node.e);
+	node.h = node.h.filter((hydrationRoot) => {
+		if (hydrationRoot.s.parentNode !== null) return true;
+		hydrationRoot.u({ removeContents: false });
+		return false;
+	});
+	node.r = raw;
+	if (context.hydrateOptions !== void 0) hydrateRawRenderNode(node, context.hydrateOptions);
+	return node;
+}
+function patchElementRenderNode(node, vnode, context) {
+	const refChanged = node.v.props.ref !== vnode.props.ref;
+	if (refChanged) {
+		runCleanups(node.r);
+		node.r = [];
+	}
+	patchProps(node.n, node.v.props, vnode.props);
+	if (!isChildlessElement(vnode.type)) {
+		const nextInnerHTML = readDangerouslySetInnerHTML(vnode.props);
+		const previousInnerHTML = readDangerouslySetInnerHTML(node.v.props);
+		if (nextInnerHTML !== void 0) {
+			if (node.c !== void 0) {
+				cleanupRenderNode(node.c);
+				node.c = void 0;
+			}
+			if (previousInnerHTML !== nextInnerHTML) patchDomChildren(node.n, node.n.firstChild, htmlToFragment(node.n, nextInnerHTML).childNodes, context.document);
+		} else if (previousInnerHTML !== void 0) {
+			node.n.textContent = "";
+			node.c = childToRenderNode(vnode.props.children ?? null, context);
+			insertRenderNode(node.n, node.c, null);
+		} else if (node.c !== void 0) node.c = patchRenderNode(node.c, vnode.props.children ?? null, context);
+		else {
+			node.c = childToRenderNode(vnode.props.children ?? null, context);
+			insertRenderNode(node.n, node.c, null);
+		}
+	}
+	node.v = snapshotHostVNode(vnode);
+	if (refChanged) collectRefEffects(node.n, vnode.props.ref, context.effects, node.r);
+	return node;
+}
+function replaceRenderNode(node, nextChild, context) {
+	const parent = renderNodeStart(node).parentNode;
+	const nextSibling = renderNodeEnd(node).nextSibling;
+	const replacement = childToRenderNode(nextChild, context);
+	cleanupRenderNode(node);
+	removeRenderNode(node);
+	if (parent) insertRenderNode(parent, replacement, nextSibling);
+	return replacement;
+}
+function textToRenderNode(value, document) {
+	return {
+		k: textRenderNodeKind,
+		n: document.createTextNode(textValue(value))
+	};
+}
+function rawToRenderNode(raw, document, hydrateOptions) {
+	const node = {
+		e: createMarker(document),
+		h: [],
+		k: rawRenderNodeKind,
+		r: raw,
+		s: createMarker(document)
+	};
+	if (hydrateOptions) queueRawHydration(node, hydrateOptions);
+	return node;
+}
+function queueRawHydration(node, hydrateOptions) {
+	Promise.resolve().then(() => {
+		if (isRawRenderNodeConnected(node)) hydrateRawRenderNode(node, hydrateOptions);
+	});
+}
+function hydrateRawRenderNode(node, hydrateOptions) {
+	hydrateRawBoundaries(node, hydrateOptions).then((hydrationRoots) => {
+		if (!isRawRenderNodeConnected(node)) {
+			for (const hydrationRoot of hydrationRoots) hydrationRoot.u();
+			return;
+		}
+		node.h = hydrationRoots;
+	}, () => {});
+	return node;
+}
+async function hydrateRawBoundaries(node, hydrateOptions) {
+	const [boundaries, hydrateMeta] = findHydrationBoundariesBetween(node.s, node.e);
+	const hydrationRoots = [];
+	for (const boundary of boundaries) {
+		if (!isRawRenderNodeConnected(node)) break;
+		const activeRoot = activeHydrationBoundaries.get(boundary.s);
+		if (activeRoot !== void 0) {
+			hydrationRoots.push(activeRoot);
+			continue;
+		}
+		const meta = hydrateMeta.get(boundary.i);
+		if (meta === void 0) fail("raw metadata");
+		const factory = await hydrateOptions.load(meta);
+		if (!isRawRenderNodeConnected(node)) break;
+		hydrationRoots.push(hydrateBoundary(boundary, factory, hydrateOptions));
+	}
+	return hydrationRoots;
+}
+function isRawRenderNodeConnected(node) {
+	return !!node.s.parentNode && node.s.parentNode === node.e.parentNode;
+}
+function htmlToFragment(parent, html) {
+	const range = ownerDocumentFor(parent).createRange();
+	if (parent instanceof Element || parent instanceof DocumentFragment) range.selectNodeContents(parent);
+	else range.selectNode(parent);
+	return range.createContextualFragment(html);
+}
+function patchDocumentWithHtml(document, html) {
+	const parsed = new DOMParser().parseFromString(html, "text/html");
+	patchDocumentType(document, parsed);
+	patchElementAttributes(document.documentElement, parsed.documentElement);
+	patchDocumentSection(document, document.head, parsed.head);
+	patchDocumentSection(document, document.body, parsed.body);
+}
+function patchDocumentType(document, parsed) {
+	if (parsed.doctype === null) {
+		document.doctype?.remove();
+		return;
+	}
+	const current = document.doctype;
+	if (current?.name === parsed.doctype.name && current.publicId === parsed.doctype.publicId && current.systemId === parsed.doctype.systemId) return;
+	const next = document.implementation.createDocumentType(parsed.doctype.name, parsed.doctype.publicId, parsed.doctype.systemId);
+	if (current) document.replaceChild(next, current);
+	else document.insertBefore(next, document.documentElement);
+}
+function patchDocumentSection(document, current, parsed) {
+	patchElementAttributes(current, parsed);
+	if (current === document.head) patchHeadChildren(document, parsed);
+	else patchDomChildren(current, current.firstChild, parsed.childNodes, document);
+}
+function patchHeadChildren(document, parsed) {
+	const reusedHeadNodes = /* @__PURE__ */ new Set();
+	patchDomChildren(document.head, document.head.firstChild, parsed.childNodes, document, void 0, (parsedNode) => {
+		const persistentNode = findPersistentHeadNode(document, parsedNode, reusedHeadNodes);
+		if (persistentNode !== void 0) reusedHeadNodes.add(persistentNode);
+		return persistentNode;
+	});
+}
+function findPersistentHeadNode(document, parsedNode, reusedHeadNodes) {
+	if (!(parsedNode instanceof Element)) return;
+	for (const child of document.head.children) {
+		if (reusedHeadNodes.has(child) || !isPersistentHeadNodeMatch(document, child, parsedNode)) continue;
+		return child;
+	}
+}
+function isPersistentHeadNodeMatch(document, current, parsed) {
+	if (current instanceof HTMLLinkElement && parsed instanceof HTMLLinkElement && current.relList.contains("stylesheet") && parsed.relList.contains("stylesheet")) return stylesheetHref(document, stylesheetLinkHref(current)) === stylesheetHref(document, stylesheetLinkHref(parsed));
+	if (current instanceof HTMLScriptElement && parsed instanceof HTMLScriptElement && scriptSource(current) && scriptSource(parsed)) return scriptHref(document, scriptSource(current)) === scriptHref(document, scriptSource(parsed));
+	return false;
+}
+function scriptHref(document, src) {
+	try {
+		return new URL(src, document.baseURI).href;
+	} catch {
+		return new URL(src, location.href).href;
+	}
+}
+function scriptSource(script) {
+	return script.getAttribute("src") ?? script.src;
+}
+function patchDomChildren(parent, anchor, parsedChildren, document, end, findReusableNode) {
+	const flushRefreshes = pendingHydrationBoundaryRefreshes === void 0;
+	if (flushRefreshes) pendingHydrationBoundaryRefreshes = [];
+	for (const parsedChild of parsedChildren) {
+		anchor = skipUnmatchedEmptyTextNodes(anchor, parsedChild, end);
+		const reusableNode = findReusableNode?.(parsedChild);
+		let child;
+		if (reusableNode !== void 0) child = patchDomNode(reusableNode, parsedChild, document);
+		else if (anchor && anchor !== end && canPatchDomNode(anchor, parsedChild)) child = patchDomNode(anchor, parsedChild, document);
+		else child = document.importNode(parsedChild, true);
+		if (child === anchor) {
+			anchor = child.nextSibling;
+			continue;
+		}
+		parent.insertBefore(child, anchor === end ? end : anchor);
+	}
+	removeSiblings(anchor, end);
+	if (flushRefreshes) {
+		const refreshes = pendingHydrationBoundaryRefreshes;
+		pendingHydrationBoundaryRefreshes = void 0;
+		for (const start of refreshes ?? []) refreshHydrationBoundary(start);
+	}
+}
+function skipUnmatchedEmptyTextNodes(anchor, parsedChild, end) {
+	while (anchor && anchor !== end && isEmptyTextNode(anchor) && !canPatchDomNode(anchor, parsedChild)) {
+		const next = anchor.nextSibling;
+		anchor.parentNode?.removeChild(anchor);
+		anchor = next;
+	}
+	return anchor;
+}
+function removeSiblings(anchor, end) {
+	while (anchor && anchor !== end) {
+		const next = anchor.nextSibling;
+		anchor.parentNode?.removeChild(anchor);
+		anchor = next;
+	}
+}
+function patchDomNode(current, parsed, document) {
+	if (!canPatchDomNode(current, parsed)) {
+		const replacement = document.importNode(parsed, true);
+		current.parentNode?.replaceChild(replacement, current);
+		return replacement;
+	}
+	if (current.nodeType === Node.TEXT_NODE || current.nodeType === Node.COMMENT_NODE) {
+		if (current.nodeValue !== parsed.nodeValue) {
+			current.nodeValue = parsed.nodeValue;
+			if (current.nodeType === Node.COMMENT_NODE) refreshActiveHydrationBoundary(current);
+		}
+		return current;
+	}
+	if (current instanceof Element && parsed instanceof Element) {
+		patchElementAttributes(current, parsed);
+		if (!isChildlessElement(current.localName)) patchDomChildren(current, current.firstChild, parsed.childNodes, document);
+		patchFormElementProperties(current, parsed);
+	}
+	return current;
+}
+function refreshActiveHydrationBoundary(start) {
+	if (pendingHydrationBoundaryRefreshes) pendingHydrationBoundaryRefreshes.push(start);
+	else refreshHydrationBoundary(start);
+}
+function refreshHydrationBoundary(start) {
+	const hydrationRoot = activeHydrationBoundaries.get(start);
+	if (hydrationRoot === void 0) return;
+	const marker = parseHydrateStartComment(start);
+	if (marker) hydrationRoot.r(marker.i, marker.p, marker.k);
+}
+function canPatchDomNode(current, parsed) {
+	if (current.nodeType !== parsed.nodeType) return false;
+	if (current instanceof Element && parsed instanceof Element) return current.namespaceURI === parsed.namespaceURI && current.localName === parsed.localName;
+	return true;
+}
+function isEmptyTextNode(node) {
+	return node.nodeType === Node.TEXT_NODE && node.nodeValue === "";
+}
+function patchElementAttributes(current, parsed) {
+	for (const name of current.getAttributeNames()) if (!parsed.hasAttribute(name)) current.removeAttribute(name);
+	for (const { name, value } of parsed.attributes) if (current.getAttribute(name) !== value) current.setAttribute(name, value);
+}
+function patchFormElementProperties(current, parsed) {
+	if (current instanceof HTMLInputElement && parsed instanceof HTMLInputElement) {
+		if (current.type === "checkbox" || current.type === "radio") {
+			current.checked = parsed.hasAttribute("checked");
+			return;
+		}
+		current.value = parsed.getAttribute("value") ?? "";
+	} else if (current instanceof HTMLTextAreaElement && parsed instanceof HTMLTextAreaElement) current.value = parsed.value;
+	else if (current instanceof HTMLOptionElement && parsed instanceof HTMLOptionElement) current.selected = parsed.hasAttribute("selected");
+}
+function waitForHtmlStylesheets(document, html) {
+	const parsed = new DOMParser().parseFromString(html, "text/html");
+	const hrefs = [];
+	for (const link of parsed.querySelectorAll("link[href]")) if (isLoadBlockingStylesheet(link)) hrefs.push(stylesheetLinkHref(link));
+	return waitForStylesheets(document, hrefs, true);
+}
+function waitForConnectedStylesheets(document) {
+	const hrefs = [];
+	for (const link of document.querySelectorAll("link[href]")) if (isLoadBlockingStylesheet(link)) hrefs.push(stylesheetLinkHref(link));
+	return waitForStylesheets(document, hrefs, false);
+}
+function waitForStylesheets(document, hrefs, createMissingLinks) {
+	const pendingStylesheets = [];
+	for (const href of hrefs) {
+		const pendingStylesheet = waitForStylesheet(document, href, createMissingLinks);
+		if (pendingStylesheet !== void 0) pendingStylesheets.push(pendingStylesheet);
+	}
+	if (pendingStylesheets.length === 0) return;
+	return Promise.all(pendingStylesheets).then(() => {});
+}
+function waitForStylesheet(document, href, createMissingLink) {
+	const absoluteHref = stylesheetHref(document, href);
+	const loadedStylesheets = ensureLoadedStylesheets(document);
+	if (loadedStylesheets.has(absoluteHref)) return;
+	let link = findStylesheetLink(document, absoluteHref);
+	if (link?.sheet) {
+		loadedStylesheets.add(absoluteHref);
+		return;
+	}
+	const stylesheetPromises = ensureStylesheetPromises(document);
+	const existingPromise = stylesheetPromises.get(absoluteHref);
+	if (existingPromise !== void 0) return existingPromise;
+	if (link === void 0) {
+		if (!createMissingLink || document.head === null) return;
+		link = document.createElement("link");
+		link.rel = "stylesheet";
+		link.href = absoluteHref;
+		document.head.append(link);
+	}
+	const promise = new Promise((resolve) => {
+		const finish = () => {
+			link.removeEventListener("load", finish);
+			link.removeEventListener("error", finish);
+			loadedStylesheets.add(absoluteHref);
+			stylesheetPromises.delete(absoluteHref);
+			resolve();
+		};
+		link.addEventListener("load", finish);
+		link.addEventListener("error", finish);
+		if (link.sheet) finish();
+	});
+	stylesheetPromises.set(absoluteHref, promise);
+	return promise;
+}
+function stylesheetHref(document, href) {
+	try {
+		return new URL(href, document.baseURI).href;
+	} catch {
+		return new URL(href, location.href).href;
+	}
+}
+function stylesheetLinkHref(link) {
+	return link.getAttribute("href") ?? link.href;
+}
+function isLoadBlockingStylesheet(link) {
+	if (!link.relList.contains("stylesheet") || link.disabled) return false;
+	const media = link.media.trim();
+	if (!media || media === "all") return true;
+	return typeof matchMedia === "undefined" || matchMedia(media).matches;
+}
+function findStylesheetLink(document, href, excluded = /* @__PURE__ */ new Set()) {
+	for (const link of document.querySelectorAll("link[href]")) if (!excluded.has(link) && isLoadBlockingStylesheet(link) && stylesheetHref(document, stylesheetLinkHref(link)) === href) return link;
+}
+function ensureStylesheetPromises(document) {
+	let stylesheetPromises = stylesheetPromisesByDocument.get(document);
+	if (stylesheetPromises === void 0) {
+		stylesheetPromises = /* @__PURE__ */ new Map();
+		stylesheetPromisesByDocument.set(document, stylesheetPromises);
+	}
+	return stylesheetPromises;
+}
+function ensureLoadedStylesheets(document) {
+	let loadedStylesheets = loadedStylesheetsByDocument.get(document);
+	if (loadedStylesheets === void 0) {
+		loadedStylesheets = /* @__PURE__ */ new Set();
+		loadedStylesheetsByDocument.set(document, loadedStylesheets);
+	}
+	return loadedStylesheets;
+}
+function textValue(value) {
+	return isPrimitiveValue(value) ? String(value) : "";
+}
+function arrayToRenderNode(children, context) {
+	return {
+		c: normalizeChildren(children).map((child) => childToRenderNode(child, context)),
+		e: createMarker(context.document),
+		k: arrayRenderNodeKind,
+		s: createMarker(context.document)
+	};
+}
+function componentToRenderNode(component, context) {
+	const unsubscribe = subscribeComponent(component, context.scheduleUpdate);
+	let child;
+	try {
+		renderComponentChild(component, context.effects, (renderedChild) => {
+			child = childToRenderNode(renderedChild, renderContextWithOwner(context, component));
+			return child;
+		});
+	} catch (reason) {
+		unsubscribe();
+		throw reason;
+	}
+	if (child === void 0) {
+		unsubscribe();
+		fail("render node");
+	}
+	return {
+		c: child,
+		e: createMarker(context.document),
+		k: componentRenderNodeKind,
+		s: createMarker(context.document),
+		u: unsubscribe,
+		v: component
+	};
+}
+function elementToRenderNode(vnode, context) {
+	const element = context.document.createElement(vnode.type);
+	let child;
+	patchProps(element, {}, vnode.props);
+	if (!isChildlessElement(vnode.type)) {
+		const innerHTML = readDangerouslySetInnerHTML(vnode.props);
+		if (innerHTML !== void 0) element.innerHTML = innerHTML;
+		else {
+			child = childToRenderNode(vnode.props.children ?? null, context);
+			insertRenderNode(element, child, null);
+		}
+	}
+	const node = {
+		c: child,
+		k: elementRenderNodeKind,
+		n: element,
+		r: [],
+		v: snapshotHostVNode(vnode)
+	};
+	collectRefEffects(element, vnode.props.ref, context.effects, node.r);
+	return node;
+}
+function snapshotHostVNode(vnode) {
+	const { style } = vnode.props;
+	if (!style) return vnode;
+	return {
+		...vnode,
+		props: {
+			...vnode.props,
+			style: { ...style }
+		}
+	};
+}
+function hydratedChildrenToRenderNode(children, document) {
+	const start = createMarker(document);
+	const end = createMarker(document);
+	const fragment = document.createDocumentFragment();
+	fragment.append(start);
+	appendHydratedChildren(fragment, children);
+	fragment.append(end);
+	return {
+		c: children,
+		e: end,
+		k: hydratedRenderNodeKind,
+		s: start
+	};
+}
+function nextHydratableNode(node) {
+	let currentNode = node;
+	while (isHydrateMetaComment(currentNode)) currentNode = currentNode.nextSibling;
+	return currentNode;
+}
+function findNextHydrateStart(node) {
+	let currentNode = node;
+	while (currentNode) {
+		if (isHydrateStartComment(currentNode)) return currentNode;
+		if (!isHydrateMetaComment(currentNode)) return;
+		currentNode = currentNode.nextSibling;
+	}
+}
+function findDelimitedEnd(start, isStart, isEnd) {
+	let depth = 0;
+	let currentNode = start;
+	while (currentNode) {
+		if (isStart(currentNode)) depth++;
+		else if (isEnd(currentNode)) {
+			depth--;
+			if (depth === 0) return currentNode;
+		}
+		currentNode = currentNode.nextSibling;
+	}
+}
+function removeBoundaryContents(boundary) {
+	removeDelimitedContents(boundary.s, boundary.e);
+}
+function insertMarker(parent, before) {
+	const marker = createMarker(ownerDocumentFor(parent));
+	parent.insertBefore(marker, before?.parentNode === parent ? before : null);
+	return marker;
+}
+function createMarker(document) {
+	return document.createTextNode("");
+}
+function insertRenderNode(parent, node, before) {
+	parent.insertBefore(renderNodeToFragment(node), before);
+}
+function renderNodeToFragment(node) {
+	const fragment = ownerDocumentFor(renderNodeStart(node)).createDocumentFragment();
+	appendRenderNode(fragment, node);
+	return fragment;
+}
+function appendRenderNode(parent, node) {
+	switch (node.k) {
+		case arrayRenderNodeKind:
+			parent.appendChild(node.s);
+			for (const child of node.c) appendRenderNode(parent, child);
+			parent.appendChild(node.e);
+			return;
+		case componentRenderNodeKind:
+			parent.appendChild(node.s);
+			appendRenderNode(parent, node.c);
+			parent.appendChild(node.e);
+			return;
+		case elementRenderNodeKind:
+			parent.appendChild(node.n);
+			return;
+		case hydratedRenderNodeKind:
+			parent.appendChild(node.s);
+			appendHydratedChildren(parent, node.c);
+			parent.appendChild(node.e);
+			return;
+		case rawRenderNodeKind:
+			if (node.s.parentNode && node.s.parentNode === node.e.parentNode) appendNodeRange(parent, node.s, node.e);
+			else {
+				parent.appendChild(node.s);
+				parent.appendChild(htmlToFragment(parent, readRawChildHtml(node.r)));
+				parent.appendChild(node.e);
+			}
+			return;
+		case skippedHydrationRenderNodeKind:
+			appendNodeRange(parent, node.s, node.e);
+			return;
+		case textRenderNodeKind:
+			parent.appendChild(node.n);
+			return;
+	}
+}
+function appendHydratedChildren(parent, children) {
+	let node = children.n;
+	while (node && node !== children.b.e) {
+		const nextNode = node.nextSibling;
+		parent.appendChild(node);
+		node = nextNode;
+	}
+}
+function appendNodeRange(parent, start, end) {
+	let child = start;
+	while (child) {
+		const next = child === end ? null : child.nextSibling;
+		parent.appendChild(child);
+		if (child === end) return;
+		child = next;
+	}
+}
+function removeRenderNode(node) {
+	removeNodeRange(renderNodeStart(node), renderNodeEnd(node));
+}
+function removeDelimitedContents(start, end) {
+	const first = start.nextSibling;
+	const last = end.previousSibling;
+	if (first && last && first !== end && last !== start) removeNodeRange(first, last);
+}
+function removeNodeRange(start, end) {
+	const parent = start.parentNode;
+	if (!parent || parent !== end.parentNode) return;
+	let node = start;
+	while (node) {
+		const next = node === end ? null : node.nextSibling;
+		parent.removeChild(node);
+		node = next;
+	}
+}
+function cleanupRenderNode(node) {
+	switch (node.k) {
+		case arrayRenderNodeKind:
+			for (let index = node.c.length - 1; index >= 0; index--) cleanupRenderNode(node.c[index]);
+			return;
+		case componentRenderNodeKind:
+			node.u();
+			cleanupRenderNode(node.c);
+			return;
+		case elementRenderNodeKind:
+			runCleanups(node.r);
+			node.r = [];
+			if (node.c !== void 0) cleanupRenderNode(node.c);
+			return;
+		case rawRenderNodeKind:
+			for (const hydrationRoot of node.h) hydrationRoot.u();
+			node.h = [];
+			return;
+		case hydratedRenderNodeKind:
+		case skippedHydrationRenderNodeKind:
+		case textRenderNodeKind: return;
+	}
+}
+function renderNodeStart(node) {
+	return node.k === elementRenderNodeKind || node.k === textRenderNodeKind ? node.n : node.s;
+}
+function renderNodeEnd(node) {
+	return node.k === elementRenderNodeKind || node.k === textRenderNodeKind ? node.n : node.e;
+}
+function ownerDocumentFor(node) {
+	if (node instanceof Document) return node;
+	invariant(node.ownerDocument, "owner document");
+	return node.ownerDocument;
+}
+function renderComponentChild(component, effects, renderChild) {
+	beginComponentRender(component);
+	try {
+		const refEffectStart = effects.r.length;
+		const mountEffectStart = effects.m.length;
+		try {
+			const result = renderChild(renderComponentOutput(component));
+			queueComponentMount(component, effects.m);
+			return result;
+		} catch (reason) {
+			effects.r.splice(refEffectStart);
+			effects.m.splice(mountEffectStart);
+			beginComponentRender(component);
+			const result = renderChild(renderComponentErrorOutput(component, reason));
+			queueComponentMount(component, effects.m);
+			return result;
+		}
+	} finally {
+		finishComponentRender(component);
+	}
+}
+function findHydrationBoundaries(root) {
+	const walker = (root instanceof Document ? root : root.ownerDocument).createTreeWalker(root, NodeFilter.SHOW_COMMENT);
+	const hydrateMeta = /* @__PURE__ */ new Map();
+	const boundaries = [];
+	const stack = [];
+	let currentNode = walker.nextNode();
+	while (currentNode) {
+		collectHydrationBoundary(currentNode, hydrateMeta, boundaries, stack);
+		currentNode = walker.nextNode();
+	}
+	return [boundaries, hydrateMeta];
+}
+function findHydrationBoundariesBetween(start, end) {
+	const hydrateMeta = /* @__PURE__ */ new Map();
+	const boundaries = [];
+	const stack = [];
+	let node = start.nextSibling;
+	while (node && node !== end) {
+		collectHydrationBoundariesIn(node, hydrateMeta, boundaries, stack);
+		node = node.nextSibling;
+	}
+	return [boundaries, hydrateMeta];
+}
+function collectHydrationBoundary(comment, hydrateMeta, boundaries, stack) {
+	const meta = parseHydrateMetaComment(comment);
+	if (meta) {
+		hydrateMeta.set(meta.i, meta.v);
+		return;
+	}
+	const boundaryStart = parseHydrateStartComment(comment);
+	if (boundaryStart) stack.push({
+		i: boundaryStart.i,
+		k: boundaryStart.k,
+		p: boundaryStart.p,
+		s: comment
+	});
+	else if (isHydrateEndComment(comment)) {
+		const startedBoundary = stack.pop();
+		if (startedBoundary) boundaries.push({
+			...startedBoundary,
+			e: comment
+		});
+	}
+}
+function collectHydrationBoundariesIn(root, hydrateMeta, boundaries, stack) {
+	if (root.nodeType === Node.COMMENT_NODE) collectHydrationBoundary(root, hydrateMeta, boundaries, stack);
+	const walker = ownerDocumentFor(root).createTreeWalker(root, NodeFilter.SHOW_COMMENT);
+	let currentNode = walker.nextNode();
+	while (currentNode) {
+		collectHydrationBoundary(currentNode, hydrateMeta, boundaries, stack);
+		currentNode = walker.nextNode();
+	}
+}
+function parseHydrateMetaComment(comment) {
+	return parseHydrateMetaCommentData(comment.data);
+}
+function parseHydrateStartComment(comment) {
+	return parseHydrateStartCommentData(comment.data);
+}
+function isHydrateMetaComment(node) {
+	return isCommentData(node, isHydrateMetaCommentData);
+}
+function isHydrateStartComment(node) {
+	return isCommentData(node, isHydrateStartCommentData);
+}
+function isHydrateEndComment(node) {
+	return isCommentData(node, isHydrateEndCommentData);
+}
+function isRawStartComment(node) {
+	return isCommentData(node, isRawStartCommentData);
+}
+function isRawEndComment(node) {
+	return isCommentData(node, isRawEndCommentData);
+}
+function isCommentData(node, isMarkerCommentData) {
+	return node?.nodeType === Node.COMMENT_NODE && isMarkerCommentData(node.data);
+}
+//#endregion
+export { Component, Fragment, Raw, createElement, event, hydrate, isComponent, isVNode, jsx, jsx as jsxs, jsxDEV, render };