@bgub/fig-reconciler 0.0.1

package/dist/index.js

@@ -0,0 +1,3719 @@
+import { devtoolsTypeName } from "./devtools.js";
+import { Fragment } from "@bgub/fig";
+import { collectChildren, dataResourceKeysForError, invalidChildError, isActivity, isAssets, isContext, isErrorBoundary, isPortal, isSuspense, isThenable, isValidElement, isViewTransition, readThenable, setCurrentDataStore, setCurrentDispatcher, setTransitionHandler } from "@bgub/fig/internal";
+//#region src/fiber-work.ts
+const StoreConsistencyFlag = 2048;
+const ContextPropagationFlag = 1024;
+const NotHoistedFlag = 8192;
+const ViewTransitionStaticFlag = 4096;
+const StaticFlagsMask = ViewTransitionStaticFlag;
+function childSubtreeFlags(node) {
+	return node.flags & -8459 | node.subtreeFlags;
+}
+function clearTransientFlags(node) {
+	node.flags &= StaticFlagsMask;
+	node.subtreeFlags &= StaticFlagsMask;
+}
+//#endregion
+//#region src/commit-index.ts
+function createCommitIndex() {
+	return [];
+}
+function commitIndexCheckpoint(index) {
+	return index.length;
+}
+function recordCommitWork(index, node, flags = 0) {
+	node.flags |= flags;
+	if ((node.flags & 256) !== 0) return;
+	node.flags |= 256;
+	index.push(node);
+}
+function rollbackCommitIndex(index, checkpoint) {
+	if (checkpoint === void 0 || checkpoint >= index.length) return;
+	const start = checkpoint;
+	for (let offset = start; offset < index.length; offset += 1) index[offset].flags &= -257;
+	index.length = checkpoint;
+}
+function clearCommitIndex(index) {
+	for (const node of index) node.flags &= -257;
+	index.length = 0;
+}
+function tagFor(element) {
+	if (typeof element.type === "string") return 1;
+	if (element.type === Fragment) return 4;
+	if (isAssets(element.type)) return 9;
+	if (isContext(element.type)) return 5;
+	if (isSuspense(element.type)) return 6;
+	if (isActivity(element.type)) return 10;
+	if (isErrorBoundary(element.type)) return 7;
+	if (isViewTransition(element.type)) return 11;
+	return 3;
+}
+function isEffectHook(kind) {
+	return kind <= 2;
+}
+const priorityTimeouts = {
+	[1]: -1,
+	[2]: 250,
+	[3]: 5e3,
+	[4]: 1e4,
+	[5]: 1073741823
+};
+const frameInterval = 5;
+function compare(a, b) {
+	return a.expirationTime - b.expirationTime || a.id - b.id;
+}
+var MinHeap = class {
+	items = [];
+	push(value) {
+		this.items.push(value);
+		this.siftUp(this.items.length - 1);
+	}
+	peek() {
+		return this.items[0] ?? null;
+	}
+	pop() {
+		const first = this.items[0];
+		const last = this.items.pop();
+		if (first === void 0 || last === void 0) return null;
+		if (first !== last) {
+			this.items[0] = last;
+			this.siftDown(0);
+		}
+		return first;
+	}
+	siftUp(index) {
+		const value = this.items[index];
+		while (index > 0) {
+			const parentIndex = index - 1 >>> 1;
+			const parent = this.items[parentIndex];
+			if (compare(parent, value) <= 0) return;
+			this.items[parentIndex] = value;
+			this.items[index] = parent;
+			index = parentIndex;
+		}
+	}
+	siftDown(index) {
+		const length = this.items.length;
+		const value = this.items[index];
+		while (index < length) {
+			const leftIndex = index * 2 + 1;
+			const rightIndex = leftIndex + 1;
+			let smallest = index;
+			if (leftIndex < length && compare(this.items[leftIndex], this.items[smallest]) < 0) smallest = leftIndex;
+			if (rightIndex < length && compare(this.items[rightIndex], this.items[smallest]) < 0) smallest = rightIndex;
+			if (smallest === index) return;
+			this.items[index] = this.items[smallest];
+			this.items[smallest] = value;
+			index = smallest;
+		}
+	}
+};
+const taskQueue = new MinHeap();
+let taskId = 1;
+let messageLoopRunning = false;
+let needsPaint = false;
+let startTime = -1;
+let actQueue = null;
+let actScopeDepth = 0;
+let flushingActQueue = false;
+const actFlushLimit = 1e3;
+function now() {
+	return globalThis.performance?.now?.() ?? Date.now();
+}
+function shouldYieldToHost() {
+	return needsPaint || now() - startTime >= frameInterval;
+}
+function requestPaint() {
+	needsPaint = true;
+}
+function scheduleCallback(priority, callback) {
+	const task = {
+		id: taskId++,
+		callback,
+		expirationTime: now() + priorityTimeouts[priority]
+	};
+	if (actQueue !== null) {
+		actQueue.push(task);
+		return { cancel() {
+			task.callback = null;
+		} };
+	}
+	taskQueue.push(task);
+	requestHostCallback();
+	return { cancel() {
+		task.callback = null;
+	} };
+}
+async function act(callback) {
+	const previousActQueue = actQueue;
+	const previousActScopeDepth = actScopeDepth;
+	const queue = previousActQueue ?? [];
+	actQueue = queue;
+	actScopeDepth = previousActScopeDepth + 1;
+	try {
+		const result = await callback();
+		actScopeDepth = previousActScopeDepth;
+		if (previousActScopeDepth === 0) try {
+			await flushActQueueUntilSettled(queue);
+		} finally {
+			actQueue = previousActQueue;
+		}
+		else actQueue = previousActQueue;
+		return result;
+	} catch (error) {
+		actScopeDepth = previousActScopeDepth;
+		actQueue = previousActQueue;
+		throw error;
+	}
+}
+async function flushActQueueUntilSettled(queue) {
+	for (let flushes = 0; flushes < actFlushLimit; flushes += 1) {
+		flushActQueue(queue);
+		await Promise.resolve();
+		if (hasActWork(queue)) continue;
+		await waitForActMacrotask();
+		if (!hasActWork(queue)) {
+			queue.length = 0;
+			return;
+		}
+	}
+	throw new Error("act() exceeded the scheduled work flush limit.");
+}
+function flushActQueue(queue) {
+	if (flushingActQueue) return;
+	flushingActQueue = true;
+	try {
+		let task = takeNextActTask(queue);
+		while (task !== null) {
+			const callback = task.callback;
+			if (callback !== null) {
+				task.callback = null;
+				needsPaint = false;
+				startTime = now();
+				const continuation = callback();
+				if (typeof continuation === "function") {
+					task.callback = continuation;
+					queue.push(task);
+				}
+			}
+			task = takeNextActTask(queue);
+		}
+	} finally {
+		flushingActQueue = false;
+	}
+}
+function hasActWork(queue) {
+	return queue.some((task) => task.callback !== null);
+}
+function takeNextActTask(queue) {
+	let nextIndex = -1;
+	for (let index = 0; index < queue.length; index += 1) {
+		const task = queue[index];
+		if (task.callback === null) continue;
+		if (nextIndex === -1 || compare(task, queue[nextIndex]) < 0) nextIndex = index;
+	}
+	if (nextIndex === -1) {
+		queue.length = 0;
+		return null;
+	}
+	const [task] = queue.splice(nextIndex, 1);
+	return task;
+}
+function waitForActMacrotask() {
+	return new Promise((resolve) => {
+		if (typeof setImmediate === "function") setImmediate(resolve);
+		else setTimeout(resolve, 0);
+	});
+}
+function requestHostCallback() {
+	if (messageLoopRunning) return;
+	messageLoopRunning = true;
+	scheduleHostCallback();
+}
+function performWorkUntilDeadline() {
+	needsPaint = false;
+	startTime = now();
+	let hasMoreWork = false;
+	try {
+		hasMoreWork = flushWork(startTime);
+	} finally {
+		if (hasMoreWork) scheduleHostCallback();
+		else messageLoopRunning = false;
+	}
+}
+let channel = null;
+const scheduleHostCallback = typeof setImmediate === "function" ? () => void setImmediate(performWorkUntilDeadline) : typeof MessageChannel === "function" ? () => {
+	if (channel === null) {
+		channel = new MessageChannel();
+		channel.port1.onmessage = () => performWorkUntilDeadline();
+	}
+	channel.port2.postMessage(null);
+} : () => void setTimeout(performWorkUntilDeadline, 0);
+function flushWork(currentTime) {
+	let task = taskQueue.peek();
+	while (task !== null) {
+		if (task.expirationTime > currentTime && shouldYieldToHost()) break;
+		const callback = task.callback;
+		if (callback === null) taskQueue.pop();
+		else {
+			task.callback = null;
+			const continuation = callback();
+			if (typeof continuation === "function") task.callback = continuation;
+			else if (task === taskQueue.peek()) taskQueue.pop();
+		}
+		task = taskQueue.peek();
+	}
+	return task !== null;
+}
+const RetryLane1 = 1 << 22;
+const SelectiveHydrationLane = 1 << 26;
+const OffscreenLane = 1 << 29;
+const DeferredLane = 1 << 30;
+const AllTransitionLanes = 4194048;
+const RetryLanes = 62914560;
+const syncLaneExpirationMs = 250;
+const transitionLaneExpirationMs = 5e3;
+let currentUpdateLane = 32;
+let nextTransitionLane = 256;
+let nextRetryLane = RetryLane1;
+let asyncTransitionLanes = 0;
+const asyncTransitionLaneCounts = createLaneMap(0);
+function createLaneMap(initial) {
+	return Array.from({ length: 31 }, () => initial);
+}
+function mergeLanes(a, b) {
+	return a | b;
+}
+function includesSomeLane(set, subset) {
+	return (set & subset) !== 0;
+}
+function getHighestPriorityLane(lanes) {
+	return lanes & -lanes;
+}
+function getHighestPriorityLanes(lanes) {
+	const lane = getHighestPriorityLane(lanes);
+	if (includesSomeLane(4194048, lane)) return lanes & AllTransitionLanes;
+	if (includesSomeLane(62914560, lane)) return lanes & RetryLanes;
+	return lane;
+}
+function getNextLanes(root, wipLanes = 0) {
+	const pending = root.pendingLanes;
+	if (pending === 0) return 0;
+	const unblocked = pending & ~root.suspendedLanes;
+	const pinged = pending & root.pingedLanes;
+	let next = root.expiredLanes & unblocked;
+	if (next === 0) {
+		next = getHighestPriorityLanes(unblocked);
+		if (next === 0) {
+			const expiredPinged = root.expiredLanes & pinged;
+			next = expiredPinged !== 0 ? expiredPinged : getHighestPriorityLanes(pinged);
+		}
+	}
+	if (next === 0) return 0;
+	if (wipLanes !== 0 && wipLanes !== next && !includesSomeLane(root.expiredLanes, wipLanes) && getHighestPriorityLane(next) >= getHighestPriorityLane(wipLanes)) return wipLanes;
+	return getEntangledLanes(root, next);
+}
+function getEntangledLanes(root, lanes) {
+	let entangled = lanes;
+	let visited = 0;
+	let laneSet = entangled & root.entangledLanes;
+	while (laneSet !== 0) {
+		const index = laneToIndex(laneSet);
+		const lane = 1 << index;
+		entangled |= root.entanglements[index];
+		visited |= lane;
+		laneSet = entangled & root.entangledLanes & ~visited;
+	}
+	return entangled;
+}
+function markRootUpdated(root, lane) {
+	root.pendingLanes |= lane;
+	if (lane !== 268435456) {
+		root.suspendedLanes = 0;
+		root.pingedLanes = 0;
+	}
+}
+function markRootFinished(root, remainingLanes) {
+	const noLongerPending = root.pendingLanes & ~remainingLanes;
+	root.pendingLanes = remainingLanes;
+	root.suspendedLanes = 0;
+	root.pingedLanes = 0;
+	root.expiredLanes &= remainingLanes;
+	root.entangledLanes &= remainingLanes;
+	let lanes = noLongerPending;
+	while (lanes !== 0) {
+		const index = laneToIndex(lanes);
+		const lane = 1 << index;
+		root.entanglements[index] = 0;
+		root.expirationTimes[index] = -1;
+		lanes &= ~lane;
+	}
+}
+function markRootSuspended(root, lanes) {
+	root.suspendedLanes |= lanes;
+	root.pingedLanes &= ~lanes;
+	let laneSet = lanes;
+	while (laneSet !== 0) {
+		const index = laneToIndex(laneSet);
+		const lane = 1 << index;
+		root.expirationTimes[index] = -1;
+		laneSet &= ~lane;
+	}
+}
+function markRootPinged(root, lanes) {
+	root.pingedLanes |= root.suspendedLanes & lanes;
+}
+function markRootEntangled(root, lanes) {
+	root.entangledLanes |= lanes;
+	let laneSet = lanes;
+	while (laneSet !== 0) {
+		const index = laneToIndex(laneSet);
+		const lane = 1 << index;
+		root.entanglements[index] |= lanes;
+		laneSet &= ~lane;
+	}
+}
+function markStarvedLanesAsExpired(root, currentTime) {
+	let lanes = root.pendingLanes & -62914561;
+	while (lanes !== 0) {
+		const index = laneToIndex(lanes);
+		const lane = 1 << index;
+		const expiration = root.expirationTimes[index];
+		if (expiration === -1) {
+			if (!includesSomeLane(root.suspendedLanes, lane) || includesSomeLane(root.pingedLanes, lane)) root.expirationTimes[index] = computeExpirationTime(lane, currentTime);
+		} else if (expiration <= currentTime) root.expiredLanes |= lane;
+		lanes &= ~lane;
+	}
+}
+function claimNextTransitionLane() {
+	const lane = nextTransitionLane;
+	nextTransitionLane <<= 1;
+	if (!includesSomeLane(261888, nextTransitionLane)) nextTransitionLane = 256;
+	return lane;
+}
+function claimNextRetryLane() {
+	const lane = nextRetryLane;
+	nextRetryLane <<= 1;
+	if (!includesSomeLane(62914560, nextRetryLane)) nextRetryLane = RetryLane1;
+	return lane;
+}
+function isSyncLane(lane) {
+	return includesSomeLane(3, lane);
+}
+function includesOnlyTransitions(lanes) {
+	return (lanes & AllTransitionLanes) === lanes;
+}
+function getLaneSchedulerPriority(lane) {
+	if (includesSomeLane(3, lane)) return 1;
+	if (includesSomeLane(76, lane)) return 2;
+	if (includesSomeLane(71303088, lane)) return 3;
+	if (includesSomeLane(62914560, lane)) return 4;
+	return 5;
+}
+function requestUpdateLane() {
+	if (currentUpdateLane === 32 && asyncTransitionLanes !== 0) return getHighestPriorityLane(asyncTransitionLanes);
+	return currentUpdateLane;
+}
+function runWithPriority(lane, callback) {
+	const previousLane = currentUpdateLane;
+	currentUpdateLane = lane;
+	try {
+		return callback();
+	} finally {
+		currentUpdateLane = previousLane;
+	}
+}
+function runWithTransition(callback) {
+	return runWithTransitionLane(includesSomeLane(4194048, currentUpdateLane) ? currentUpdateLane : claimNextTransitionLane(), callback);
+}
+function runWithTransitionLane(lane, callback) {
+	const result = runWithPriority(lane, callback);
+	if (isThenable(result)) {
+		const release = trackAsyncTransitionLane(lane);
+		result.then(release, release);
+	}
+	return result;
+}
+function trackAsyncTransitionLane(lane) {
+	const index = laneToIndex(lane);
+	asyncTransitionLaneCounts[index] += 1;
+	asyncTransitionLanes |= lane;
+	return () => releaseAsyncTransitionLane(lane, index);
+}
+function releaseAsyncTransitionLane(lane, index) {
+	asyncTransitionLaneCounts[index] = Math.max(0, asyncTransitionLaneCounts[index] - 1);
+	if (asyncTransitionLaneCounts[index] === 0) asyncTransitionLanes &= ~lane;
+}
+function computeExpirationTime(lane, currentTime) {
+	if (includesSomeLane(79, lane)) return currentTime + syncLaneExpirationMs;
+	if (includesSomeLane(4194224, lane)) return currentTime + transitionLaneExpirationMs;
+	return -1;
+}
+function laneToIndex(lanes) {
+	return 31 - Math.clz32(lanes);
+}
+//#endregion
+//#region src/fiber-traversal.ts
+function walkFiberForest(node, visitor) {
+	walkFiberTree(node, true, visitor);
+}
+function walkFiberSubtree(node, visitor) {
+	walkFiberTree(node, false, visitor);
+}
+function walkFiberTree(node, includeRootSiblings, visitor) {
+	const stack = [];
+	let cursor = node;
+	while (cursor !== null) {
+		const shouldDescend = visitor(cursor) !== false && cursor.child !== null;
+		if ((includeRootSiblings || cursor !== node) && cursor.sibling !== null) stack.push(cursor.sibling);
+		cursor = shouldDescend ? cursor.child : stack.pop() ?? null;
+	}
+}
+//#endregion
+//#region src/hook-queue.ts
+function mergeQueues(baseQueue, pendingQueue) {
+	if (baseQueue === null) return pendingQueue;
+	const baseFirst = baseQueue.next;
+	baseQueue.next = pendingQueue.next;
+	pendingQueue.next = baseFirst;
+	return pendingQueue;
+}
+function cloneUpdateNode(update) {
+	const clone = {
+		action: update.action,
+		lane: update.lane,
+		next: null
+	};
+	clone.next = clone;
+	return clone;
+}
+function cloneQueue(queue) {
+	return queue === null ? null : cloneQueueNodes(queue);
+}
+function cloneQueueNodes(queue) {
+	let clone = null;
+	let update = queue.next;
+	do {
+		clone = mergeQueues(clone, cloneUpdateNode(update));
+		update = update.next;
+	} while (update !== queue.next);
+	return clone;
+}
+function clearQueueLanes(queue) {
+	let update = queue.next;
+	do {
+		update.lane = 0;
+		update = update.next;
+	} while (update !== queue.next);
+}
+//#endregion
+//#region src/host-content.ts
+const EmptyHostTextContent = Symbol("fig.empty-host-text-content");
+const NonTextHostContent = Symbol("fig.non-text-host-content");
+function hostTextContent(children) {
+	const text = hostTextContentPart(children);
+	return typeof text === "string" ? text : null;
+}
+function hostChildren(props) {
+	if (!hasUnsafeHTML(props)) return props.children;
+	if (hasRenderableChild(props.children)) throw new Error("Host elements cannot have both unsafeHTML and children.");
+	return null;
+}
+function hasUnsafeHTML(props) {
+	return !emptyValue(props.unsafeHTML);
+}
+function hasRenderableChild(node) {
+	if (Array.isArray(node)) return node.some(hasRenderableChild);
+	return !emptyChild(node);
+}
+function emptyValue(value) {
+	return value === null || value === void 0 || value === false;
+}
+function emptyChild(value) {
+	return value === null || value === void 0 || typeof value === "boolean";
+}
+function hostTextContentPart(node) {
+	if (Array.isArray(node)) {
+		let hasText = false;
+		let text = "";
+		for (const child of node) {
+			const childText = hostTextContentPart(child);
+			if (childText === NonTextHostContent) return NonTextHostContent;
+			if (childText === EmptyHostTextContent) continue;
+			hasText = true;
+			text += childText;
+		}
+		return hasText ? text : EmptyHostTextContent;
+	}
+	if (node === null || node === void 0 || typeof node === "boolean") return EmptyHostTextContent;
+	if (typeof node === "string" || typeof node === "number") return String(node);
+	if (isValidElement(node) || isPortal(node)) return NonTextHostContent;
+	throw invalidChildError(node);
+}
+//#endregion
+//#region src/root-data-store.ts
+const DataStoreFactorySymbol = Symbol.for("fig.data-store-factory");
+function createRootDataStore(host) {
+	let inner = null;
+	let buffered = null;
+	let disposed = false;
+	function installStore(resource) {
+		if (inner !== null) return inner;
+		if (disposed) throw new Error("Data resource APIs require a live Fig root.");
+		const factory = resource[DataStoreFactorySymbol];
+		if (factory === void 0) throw new Error("Data resource APIs require @bgub/fig.");
+		inner = factory(host);
+		if (buffered !== null) inner.hydrate(buffered);
+		buffered = null;
+		return inner;
+	}
+	const store = {
+		hydrate(entries) {
+			if (inner !== null) {
+				inner.hydrate(entries);
+				return;
+			}
+			(buffered ??= []).push(...entries);
+		},
+		run(callback) {
+			if (inner !== null) return inner.run(callback);
+			const previousStore = setCurrentDataStore(store);
+			try {
+				return callback();
+			} finally {
+				setCurrentDataStore(previousStore);
+			}
+		},
+		readData(resource, args, owner) {
+			return installStore(resource).readData(resource, args, owner);
+		},
+		preloadData(resource, ...args) {
+			installStore(resource).preloadData(resource, ...args);
+		},
+		invalidateData(resource, ...args) {
+			installStore(resource).invalidateData(resource, ...args);
+		},
+		invalidateDataError(error) {
+			return inner?.invalidateDataError(error) ?? false;
+		},
+		invalidateDataKey(key) {
+			inner?.invalidateDataKey(key);
+		},
+		invalidateDataPrefix(prefix) {
+			inner?.invalidateDataPrefix(prefix);
+		},
+		refreshData(resource, ...args) {
+			return installStore(resource).refreshData(resource, ...args);
+		},
+		commitDataDependencies(owner, previousOwner) {
+			inner?.commitDataDependencies(owner, previousOwner);
+		},
+		deleteDataOwner(owner) {
+			inner?.deleteDataOwner(owner);
+		},
+		releaseDataOwner(owner) {
+			inner?.releaseDataOwner(owner);
+		},
+		resetDataDependencies(owner) {
+			inner?.resetDataDependencies(owner);
+		},
+		dispose() {
+			disposed = true;
+			inner?.dispose();
+			inner = null;
+			buffered = null;
+		},
+		inspectDataEntries() {
+			return inner?.inspectDataEntries() ?? [];
+		},
+		snapshot() {
+			return inner?.snapshot() ?? buffered?.slice() ?? [];
+		}
+	};
+	return store;
+}
+//#endregion
+//#region src/index.ts
+function runWithEventPriority(priority, callback) {
+	return runWithPriority(eventPriorityLane(priority), callback);
+}
+function eventPriorityLane(priority) {
+	switch (priority) {
+		case "discrete": return 2;
+		case "continuous": return 8;
+		case "default": return 32;
+	}
+}
+function hydrationLaneForPriority(priority) {
+	return priority === "discrete" ? 2 : SelectiveHydrationLane;
+}
+const __DEV__ = false;
+setTransitionHandler(runWithTransition);
+const NoActionStateError = Symbol();
+const PreservedSuspense = Symbol("fig.preserved-suspense");
+const NoHydrationInitialElement = Symbol("fig.no-hydration-initial-element");
+var HydrationMismatchError = class extends Error {};
+function createRenderer(host) {
+	const noSuspenseRetries = [];
+	const roots = /* @__PURE__ */ new WeakMap();
+	const mountedRoots = /* @__PURE__ */ new Set();
+	const pendingRoots = /* @__PURE__ */ new Set();
+	const batchedRoots = /* @__PURE__ */ new Set();
+	const abandonedHydrationBoundaries = /* @__PURE__ */ new WeakSet();
+	let batchDepth = 0;
+	let flushingSyncWork = false;
+	let commitDepth = 0;
+	let needsPostCommitSyncFlush = false;
+	let flushingPostCommitSyncWork = false;
+	let nestedPostCommitSyncFlushes = 0;
+	const nestedPostCommitSyncFlushLimit = 50;
+	let currentCommitEffectPhase = null;
+	let hasHiddenBoundaries = false;
+	const hiddenStates = /* @__PURE__ */ new Set();
+	let activityHostConfig = null;
+	let activityHydrationHostConfig = null;
+	let hoistedAssetHostConfig = null;
+	const viewTransitionHost = host.viewTransition ?? null;
+	let renderingFiber = null;
+	let currentHook = null;
+	let workInProgressHook = null;
+	let localIdCounter = 0;
+	let viewTransitionAutoNameCounter = 0;
+	const dispatcher = {
+		useState: updateStateHook,
+		useActionState: updateActionStateHook,
+		useId: updateIdHook,
+		useDeferredValue: updateDeferredValueHook,
+		useMemo: updateMemoHook,
+		useTransition: updateTransitionHook,
+		useReactive(effect, deps) {
+			updateEffectHook(0, effect, deps);
+		},
+		useBeforePaint(effect, deps) {
+			updateEffectHook(1, effect, deps);
+		},
+		useBeforeLayout(effect, deps) {
+			updateEffectHook(2, effect, deps);
+		},
+		useSyncExternalStore: updateExternalStoreHook,
+		useStableEvent: updateStableEventHook,
+		readContext: readContextValue,
+		readData(resource, args) {
+			const fiber = requireRenderingFiber();
+			return rootOf(fiber).dataStore.readData(resource, args, fiber);
+		},
+		preloadData(resource, args) {
+			rootOf(requireRenderingFiber()).dataStore.preloadData(resource, ...args);
+		},
+		readPromise(promise) {
+			return readThenable(promise);
+		}
+	};
+	function createRoot(container, options = {}) {
+		return rootHandle(rootForContainer(container, {
+			kind: "client",
+			options
+		}));
+	}
+	function hydrateRoot(container, children, options = {}) {
+		const root = rootForContainer(container, {
+			kind: "hydration",
+			options
+		});
+		root.hydrationInitialElement = children;
+		updateRoot(root, children);
+		return rootHandle(root);
+	}
+	function rootForContainer(container, request) {
+		if (roots.has(container)) throw duplicateRootError(request.kind);
+		if (request.kind === "hydration") requireHydrationHostConfig();
+		const root = createFiberRoot(container, request.options ?? {});
+		roots.set(container, root);
+		if (request.kind === "hydration") {
+			root.isHydrating = true;
+			root.isHydrationRoot = true;
+			root.needsRootHydrationCompletion = true;
+		}
+		return root;
+	}
+	function createFiberRoot(container, options) {
+		const current = fiber(0, null, null, { children: null }, null);
+		const dataStore = createRootDataStore({
+			getLane: requestUpdateLane,
+			partition: options.dataPartition,
+			schedule(owner, lane) {
+				scheduleFiber(owner, hiddenSubtreeLane(owner, lane));
+			}
+		});
+		const root = {
+			container,
+			current,
+			element: null,
+			identifierPrefix: options.identifierPrefix ?? "",
+			devtools: options.devtools ?? true,
+			pendingLanes: 0,
+			suspendedLanes: 0,
+			pingedLanes: 0,
+			expiredLanes: 0,
+			entangledLanes: 0,
+			entanglements: createLaneMap(0),
+			expirationTimes: createLaneMap(-1),
+			callback: null,
+			callbackPriority: 0,
+			wip: null,
+			finishedWork: null,
+			renderLanes: 0,
+			pendingViewTransitionCommit: false,
+			parkedViewTransitionCommit: false,
+			dataStore,
+			contextValues: /* @__PURE__ */ new Map(),
+			contextStack: [],
+			externalStores: /* @__PURE__ */ new Set(),
+			pendingReactiveEffects: [],
+			reactiveCallback: null,
+			suspendedThenables: /* @__PURE__ */ new WeakMap(),
+			pendingSuspenseRetries: [],
+			attachedSuspenseRetries: /* @__PURE__ */ new WeakMap(),
+			consumedPendingQueues: [],
+			onRecoverableError: options.onRecoverableError ?? noop,
+			onUncaughtError: options.onUncaughtError ?? null,
+			recoverableErrors: [],
+			uncaughtErrorInfo: null,
+			commitEffectPhases: 0,
+			needsCommitDeletions: false,
+			commitIndex: createCommitIndex(),
+			committedCaughtErrors: [],
+			isHydrating: false,
+			isHydrationRoot: false,
+			hydrationParent: null,
+			hydratingSuspenseBoundary: null,
+			hydratingActivityBoundary: null,
+			dehydratedSuspenseCount: 0,
+			dehydratedBoundaries: /* @__PURE__ */ new Map(),
+			needsRootHydrationCompletion: false,
+			nextHydratableInstance: null,
+			clearContainerBeforeCommit: false,
+			hydrationInitialElement: NoHydrationInitialElement
+		};
+		if (options.initialData !== void 0) dataStore.hydrate(options.initialData);
+		current.stateNode = root;
+		return root;
+	}
+	function duplicateRootError(kind) {
+		return /* @__PURE__ */ new Error(`Cannot call ${kind === "hydration" ? "hydrateRoot" : "createRoot"} on a container that already has a Fig root. Use the existing root.render(...) to update it instead.`);
+	}
+	function noop() {}
+	function rootHandle(root) {
+		let unmounted = false;
+		return {
+			data: root.dataStore,
+			render: (children) => {
+				if (unmounted) throw new Error("Cannot update an unmounted root.");
+				updateRoot(root, children);
+			},
+			unmount: () => {
+				if (unmounted) return;
+				unmounted = true;
+				flushSync(() => updateRoot(root, null));
+				root.dataStore.dispose();
+				if (roots.get(root.container) === root) roots.delete(root.container);
+				mountedRoots.delete(root);
+			}
+		};
+	}
+	function hydrateTarget(container, target, priority = "default") {
+		const lane = hydrationLaneForPriority(priority);
+		const root = roots.get(container);
+		if (root === void 0) return "none";
+		if (rootShellPendingHydration(root)) {
+			if (isSyncLane(lane)) performRoot(root, true);
+			if (rootShellPendingHydration(root)) return "blocked";
+		}
+		if (root.dehydratedSuspenseCount === 0) return "none";
+		const boundary = dehydratedBoundaryForTarget(root, target);
+		if (boundary === null) return "none";
+		scheduleFiber(boundary, lane);
+		if (isSyncLane(lane)) performRoot(root, true);
+		return dehydratedBoundaryForTarget(root, target) === null ? "hydrated" : "blocked";
+	}
+	function rootShellPendingHydration(root) {
+		return root.needsRootHydrationCompletion && root.current.child === null;
+	}
+	function dehydratedBoundaryForTarget(root, target) {
+		if (host.getEnclosingSuspenseBoundaryStart === void 0) return findDehydratedSuspenseBoundaryForTarget(root.current.child, target);
+		let start = host.getEnclosingSuspenseBoundaryStart(target);
+		while (start !== null) {
+			const fiber = root.dehydratedBoundaries.get(start) ?? null;
+			if (fiberSuspenseState(fiber)?.kind === "dehydrated") return fiber;
+			start = host.getEnclosingSuspenseBoundaryStart(start);
+		}
+		return null;
+	}
+	function flushSync(callback) {
+		if (renderingFiber !== null) throw new Error("flushSync cannot be called while rendering a component.");
+		try {
+			return runWithPriority(2, callback);
+		} finally {
+			flushSyncWork();
+		}
+	}
+	function flushSyncWork() {
+		if (commitDepth > 0) {
+			needsPostCommitSyncFlush = true;
+			return;
+		}
+		const previousFlushingSyncWork = flushingSyncWork;
+		flushingSyncWork = true;
+		try {
+			for (const root of pendingRoots) if (root.pendingLanes !== 0) {
+				root.callback?.cancel();
+				root.callback = null;
+				root.callbackPriority = 0;
+				performRoot(root, true);
+			} else pendingRoots.delete(root);
+		} finally {
+			flushingSyncWork = previousFlushingSyncWork;
+		}
+	}
+	function flushPostCommitSyncWork() {
+		if (commitDepth > 0 || !needsPostCommitSyncFlush || flushingPostCommitSyncWork) return;
+		flushingPostCommitSyncWork = true;
+		try {
+			do {
+				nestedPostCommitSyncFlushes += 1;
+				if (nestedPostCommitSyncFlushes > nestedPostCommitSyncFlushLimit) throw new Error("Maximum update depth exceeded.");
+				needsPostCommitSyncFlush = false;
+				flushSyncWork();
+			} while (needsPostCommitSyncFlush);
+		} finally {
+			nestedPostCommitSyncFlushes = 0;
+			flushingPostCommitSyncWork = false;
+		}
+	}
+	function batchedUpdates(callback) {
+		batchDepth += 1;
+		try {
+			return callback();
+		} finally {
+			batchDepth -= 1;
+			if (batchDepth === 0) {
+				for (const root of batchedRoots) scheduleRoot(root);
+				batchedRoots.clear();
+			}
+		}
+	}
+	function updateRoot(root, children) {
+		if (shouldClientRenderEarlyHydrationUpdate(root, children)) forceClientRender(root);
+		const lane = requestUpdateLane();
+		root.element = children;
+		markRootPending(root, lane);
+		scheduleOrBatchRoot(root);
+	}
+	function markRootPending(root, lane) {
+		markRootUpdated(root, lane);
+		pendingRoots.add(root);
+		if (currentCommitEffectPhase === 1 && isSyncLane(lane)) needsPostCommitSyncFlush = true;
+	}
+	function markCommitEffectPhase(root, phase) {
+		root.commitEffectPhases |= 1 << phase;
+	}
+	function scheduleOrBatchRoot(root) {
+		if (batchDepth > 0) batchedRoots.add(root);
+		else scheduleRoot(root);
+	}
+	function scheduleRoot(root) {
+		if (root.pendingViewTransitionCommit) return;
+		markStarvedLanesAsExpired(root, now());
+		const nextLanes = getNextLanes(root, root.renderLanes);
+		if (nextLanes === 0) {
+			if (root.pendingLanes === 0) pendingRoots.delete(root);
+			return;
+		}
+		const priorityLane = getHighestPriorityLane(nextLanes);
+		if (root.callback !== null && root.callbackPriority === priorityLane) return;
+		root.callback?.cancel();
+		root.callbackPriority = priorityLane;
+		root.callback = scheduleCallback(getLaneSchedulerPriority(priorityLane), () => {
+			performRoot(root, isSyncLane(priorityLane));
+		});
+	}
+	function performRoot(root, forceSync) {
+		try {
+			performRootWork(root, forceSync);
+		} catch (error) {
+			if (error === PreservedSuspense) {
+				restartRootWork(root);
+				scheduleRoot(root);
+				return;
+			}
+			if (error instanceof HydrationMismatchError) {
+				recoverFromHydrationMismatch(root);
+				return;
+			}
+			if (isThenable(error)) {
+				const suspendedLanes = root.renderLanes;
+				restartRootWork(root);
+				markRootSuspended(root, suspendedLanes);
+				attachPing(root, error, suspendedLanes);
+				scheduleRoot(root);
+				return;
+			}
+			const info = root.uncaughtErrorInfo ?? errorInfoFor(root.current, error);
+			restartRootWork(root);
+			clearRootAfterUncaughtError(root);
+			reportUncaughtError(root, error, info);
+			if (flushingSyncWork) throw error;
+			if (root.onUncaughtError === null) setTimeout(() => {
+				throw error;
+			});
+		}
+	}
+	function recoverFromHydrationMismatch(root) {
+		if (root.hydratingSuspenseBoundary !== null) {
+			recoverFromSuspenseHydrationMismatch(root, root.hydratingSuspenseBoundary);
+			return;
+		}
+		markHydrationRecovery(root, "root");
+		restartRootWork(root);
+		forceClientRender(root);
+		performRoot(root, true);
+	}
+	function recoverFromSuspenseHydrationMismatch(root, boundary) {
+		const current = boundary.alternate ?? boundary;
+		const state = fiberSuspenseState(current);
+		restartRootWork(root);
+		if (state?.kind !== "dehydrated") {
+			markHydrationRecovery(root, "root");
+			forceClientRender(root);
+			performRoot(root, true);
+			return;
+		}
+		markHydrationRecovery(root, "suspense");
+		state.boundary.forceClientRender = true;
+		deactivateHydration(root);
+		scheduleFiber(current, SelectiveHydrationLane);
+		performRoot(root, true);
+	}
+	function markHydrationRecovery(root, recovery) {
+		for (const record of root.recoverableErrors) if (record.info.source === "hydration") record.info.recovery = recovery;
+	}
+	function shouldClientRenderEarlyHydrationUpdate(root, children) {
+		return root.isHydrating && root.current.child === null && root.hydrationInitialElement !== NoHydrationInitialElement && root.hydrationInitialElement !== children;
+	}
+	function forceClientRender(root) {
+		deactivateHydration(root);
+		root.clearContainerBeforeCommit = true;
+		root.hydrationInitialElement = NoHydrationInitialElement;
+	}
+	function performRootWork(root, forceSync) {
+		if (root.pendingViewTransitionCommit) return;
+		if (root.pendingLanes === 0 && root.wip === null) {
+			pendingRoots.delete(root);
+			return;
+		}
+		flushPendingReactiveEffects(root);
+		if (root.parkedViewTransitionCommit) {
+			root.parkedViewTransitionCommit = false;
+			if (!((root.pendingLanes & ~root.renderLanes) !== 0) && root.wip === null && root.finishedWork !== null) {
+				if (commitRoot(root, root.finishedWork)) return;
+				finishRootWork(root);
+				flushPostCommitSyncWork();
+				return;
+			}
+			restartRootWork(root);
+		}
+		const nextLanes = getNextLanes(root, root.renderLanes);
+		if (nextLanes === 0 && root.wip === null) {
+			root.callback = null;
+			root.callbackPriority = 0;
+			return;
+		}
+		if (root.wip !== null && nextLanes !== 0 && nextLanes !== root.renderLanes) restartRootWork(root);
+		if (root.wip === null) {
+			root.renderLanes = nextLanes;
+			root.consumedPendingQueues = [];
+			resetContextStack(root);
+			root.finishedWork = createWorkInProgress(root.current, { children: root.element });
+			root.wip = root.finishedWork;
+			prepareToHydrateRoot(root);
+		}
+		while (root.wip !== null && (forceSync || isSyncLane(getHighestPriorityLane(root.renderLanes)) || !shouldYieldToHost())) root.wip = performUnit(root.wip);
+		if (root.wip !== null) {
+			root.callback = null;
+			root.callbackPriority = 0;
+			scheduleRoot(root);
+			return;
+		}
+		if (root.finishedWork !== null && commitRoot(root, root.finishedWork)) return;
+		finishRootWork(root);
+		flushPostCommitSyncWork();
+	}
+	function finishRootWork(root) {
+		resetRootWork(root);
+		if (root.pendingLanes !== 0) scheduleRoot(root);
+		else pendingRoots.delete(root);
+	}
+	function restartRootWork(root) {
+		restoreConsumedPendingQueues(root);
+		resetRootWork(root);
+	}
+	function resetRootWork(root) {
+		const wasHydratingCompletedBoundary = root.hydrationInitialElement === NoHydrationInitialElement && (root.hydratingSuspenseBoundary !== null || root.hydratingActivityBoundary !== null);
+		root.wip = null;
+		root.finishedWork = null;
+		root.renderLanes = 0;
+		root.callback = null;
+		root.callbackPriority = 0;
+		if (root.pendingSuspenseRetries.length > 0) root.pendingSuspenseRetries = [];
+		clearCommitIndex(root.commitIndex);
+		resetHydrationPointers(root);
+		resetContextStack(root);
+		if (wasHydratingCompletedBoundary) root.isHydrating = false;
+		root.uncaughtErrorInfo = null;
+	}
+	function resetHydrationPointers(root) {
+		root.hydrationParent = null;
+		root.hydratingSuspenseBoundary = null;
+		root.hydratingActivityBoundary = null;
+		root.nextHydratableInstance = null;
+	}
+	function deactivateHydration(root) {
+		root.isHydrating = false;
+		resetHydrationPointers(root);
+	}
+	function performUnit(node) {
+		try {
+			begin(node);
+		} catch (error) {
+			return handleThrownValue(node, error);
+		}
+		if ((node.flags & 16) === 0 && node.child !== null) return node.child;
+		return completeUnit(node);
+	}
+	function handleThrownValue(node, error) {
+		const root = rootOf(node);
+		if (root.hydratingActivityBoundary !== null) abandonActivityHydration(root, error instanceof HydrationMismatchError);
+		if (isThenable(error)) {
+			const boundary = findSuspenseBoundary(node);
+			if (boundary !== null) {
+				unwindContextTo(root, boundary);
+				return captureSuspenseBoundary(boundary, error);
+			}
+			unwindContextTo(root, null);
+			throw error;
+		}
+		if (error instanceof HydrationMismatchError) {
+			unwindContextTo(root, null);
+			throw error;
+		}
+		const boundary = findErrorBoundary(node);
+		if (boundary !== null) {
+			unwindContextTo(root, boundary);
+			return captureErrorBoundary(boundary, error, node);
+		}
+		unwindContextTo(root, null);
+		rootOf(node).uncaughtErrorInfo = errorInfoFor(node, error);
+		throw error;
+	}
+	function completeUnit(node) {
+		let next = node;
+		while (next !== null) {
+			complete(next);
+			if (next.sibling !== null) return next.sibling;
+			next = next.return;
+		}
+		return null;
+	}
+	function begin(node) {
+		const root = rootOf(node);
+		if (node.tag === 6 || node.tag === 7) node.commitIndexCheckpoint = commitIndexCheckpoint(root.commitIndex);
+		if (canBailout(node, root)) {
+			let hasChildWork = includesSomeLane(node.childLanes, root.renderLanes);
+			if (!hasChildWork) hasChildWork = lazilyPropagateParentContextChanges(node, root);
+			if (!hasChildWork) {
+				node.flags |= 16;
+				node.child = node.alternate?.child ?? null;
+				return;
+			}
+			if (node.tag !== 6) {
+				if (node.tag === 5) pushContextProvider(node, root);
+				cloneChildFibers(node);
+				return;
+			}
+		}
+		if (node.tag === 5) pushContextProvider(node, root);
+		const hasOwnWork = includesSomeLane(node.lanes, root.renderLanes);
+		node.lanes &= ~root.renderLanes;
+		if (node.tag === 3) {
+			renderFunction(node, root);
+			return;
+		}
+		if (node.tag === 2) {
+			if (tryHydrateText(node, root)) return;
+			node.stateNode ??= host.createTextInstance(String(node.props.nodeValue));
+			return;
+		}
+		if (node.tag === 1) {
+			const type = String(node.type);
+			const children = hostChildren(node.props);
+			if (tryHydrateInstance(node, root)) {
+				reconcileCurrentChildren(node, children, root);
+				return;
+			}
+			node.stateNode ??= host.createInstance(type, node.props, hostParent(node));
+			reconcileCurrentChildren(node, children === null || shouldUseHostTextContent(node, root) ? null : children, root);
+			return;
+		}
+		if (node.tag === 6) {
+			beginSuspense(node, hasOwnWork);
+			return;
+		}
+		if (node.tag === 7) {
+			beginErrorBoundary(node);
+			return;
+		}
+		if (node.tag === 10 && node.type === null) {
+			beginHiddenBoundary(root, node);
+			return;
+		}
+		if (node.tag === 10) {
+			beginActivity(root, node);
+			return;
+		}
+		if (node.tag === 11) {
+			beginViewTransition(node);
+			return;
+		}
+		if (node.tag === 8) {
+			beginPortal(node);
+			return;
+		}
+		reconcileCurrentChildren(node, node.props.children, root);
+	}
+	function beginViewTransition(node) {
+		node.stateNode ??= { autoName: null };
+		reconcileCurrentChildren(node, node.props.children);
+	}
+	function beginActivity(root, node) {
+		const hidden = activityHidden(node.props);
+		if (hidden) hasHiddenBoundaries = true;
+		const state = ensureFiberActivityState(node);
+		if (state.dehydrated === null && tryDehydrateActivityBoundary(root, node, state)) {
+			if (!hidden) scheduleFiber(node, 32);
+			return;
+		}
+		if (state.dehydrated !== null) {
+			if (hidden) return;
+			hydrateDehydratedActivityBoundary(root, node);
+			return;
+		}
+		beginHiddenBoundary(root, node);
+	}
+	function beginHiddenBoundary(root, node) {
+		const hidden = activityHidden(node.props);
+		if (hidden) hasHiddenBoundaries = true;
+		const hiddenState = node.hiddenState;
+		const previousHidden = node.alternate === null ? false : activityHidden(node.alternate.memoizedProps ?? {});
+		ensureFiberActivityState(node);
+		if (hidden !== previousHidden) node.flags |= 32;
+		if (!hidden && hiddenState?.currentFirstChild != null) node.flags |= 32;
+		if (!hidden && previousHidden) {
+			markSubtreeLanes(node.alternate?.child ?? null, root.renderLanes);
+			if (includesSomeLane(node.childLanes, 536870912) && !includesSomeLane(root.renderLanes, 536870912)) root.renderLanes = mergeLanes(root.renderLanes, OffscreenLane);
+		}
+		reconcile(node, node.props.children, hiddenState?.currentFirstChild ?? node.alternate?.child ?? null, hiddenState?.currentFirstChild != null && node.alternate === null);
+		node.hiddenState = null;
+	}
+	function prepareToHydrateRoot(root) {
+		if (!root.isHydrating) return;
+		const hydrationHost = requireHydrationHostConfig();
+		root.hydrationParent = root.finishedWork;
+		root.nextHydratableInstance = hydrationHost.getFirstHydratableChild(root.container);
+	}
+	function tryHydrateInstance(node, root) {
+		if (!shouldHydrateFiber(root, node)) return false;
+		const hydrationHost = requireHydrationHostConfig();
+		const hydratable = root.nextHydratableInstance;
+		const type = String(node.type);
+		if (isHoistedFiber(node)) {
+			node.flags |= 1;
+			return false;
+		}
+		if (hydratable === null || !hydrationHost.canHydrateInstance(hydratable, type, node.props)) throwHydrationMismatch(root, node, `<${type}>`);
+		node.stateNode = hydratable;
+		recordCommitWork(root.commitIndex, node, 6);
+		root.hydrationParent = node;
+		root.nextHydratableInstance = hydrationHost.getFirstHydratableChild(hydratable, node.props);
+		return true;
+	}
+	function tryHydrateText(node, root) {
+		if (!shouldHydrateFiber(root, node)) return false;
+		const hydrationHost = requireHydrationHostConfig();
+		const hydratable = root.nextHydratableInstance;
+		const text = String(node.props.nodeValue);
+		const suppressHydrationWarning = node.return?.tag === 1 && node.return.props.suppressHydrationWarning === true || canHydratePendingSuspenseTextMismatch(root);
+		if (hydratable === null || !hydrationHost.canHydrateTextInstance(hydratable, text, suppressHydrationWarning)) throwHydrationMismatch(root, node, "text");
+		node.stateNode = hydratable;
+		recordCommitWork(root.commitIndex, node, 2);
+		root.nextHydratableInstance = hydrationHost.getNextHydratableSibling(hydratable);
+		return true;
+	}
+	function shouldHydrateFiber(root, node) {
+		return root.isHydrating && node.alternate === null && node.stateNode === null && !insideHydrationExemptHost(node);
+	}
+	function insideHydrationExemptHost(node) {
+		for (let parent = node.return; parent !== null && parent.alternate === null; parent = parent.return) {
+			if (parent.tag !== 1) continue;
+			return hydrationBypassedHost(parent);
+		}
+		return false;
+	}
+	function completeHydration(node) {
+		const root = rootOf(node);
+		if (node.tag === 6 && (node.flags & 4) !== 0 && root.hydratingSuspenseBoundary === node) {
+			completeDehydratedSuspenseHydration(root, node);
+			return;
+		}
+		if (node.tag === 10 && (node.flags & 4) !== 0 && root.hydratingActivityBoundary === node) {
+			if (root.nextHydratableInstance !== null) throwHydrationMismatch(root, node, void 0, " in Activity");
+			leaveActivityHydration(root, node);
+			return;
+		}
+		if (!root.isHydrating || root.hydrationParent !== node) return;
+		if (root.nextHydratableInstance !== null) throwHydrationMismatch(root, node);
+		const hydrationHost = requireHydrationHostConfig();
+		root.hydrationParent = nextHydrationParent(node.return);
+		root.nextHydratableInstance = node.tag === 1 ? hydrationHost.getNextHydratableSibling(node.stateNode) : null;
+	}
+	function completeDehydratedSuspenseHydration(root, node) {
+		const boundary = dehydratedSuspenseBoundary(node.alternate);
+		if (boundary === null) return;
+		if (boundary.status === "completed" && !boundary.forceClientRender && root.nextHydratableInstance !== boundary.end) throwHydrationMismatch(root, node, void 0, " in Suspense", boundary.id ?? void 0);
+		leaveSuspenseHydration(root, node, boundary);
+	}
+	function nextHydrationParent(node) {
+		for (let parent = node; parent !== null; parent = parent.return) if (parent.tag === 0 || parent.tag === 1 || parent.tag === 6 && (parent.flags & 4) !== 0 && dehydratedSuspenseBoundary(parent.alternate) !== null || parent.tag === 10 && (parent.flags & 4) !== 0 && fiberActivityState(parent)?.dehydrated != null) return parent;
+		return null;
+	}
+	function firstWithinSuspenseBoundary(boundary) {
+		const first = requireHydrationHostConfig().getNextHydratableSibling(boundary.start);
+		return first === boundary.end ? null : first;
+	}
+	function nextAfterSuspenseBoundary(boundary) {
+		return requireHydrationHostConfig().getNextHydratableSibling(boundary.end);
+	}
+	function requireHydrationHostConfig() {
+		if (host.getFirstHydratableChild === void 0 || host.getNextHydratableSibling === void 0 || host.canHydrateInstance === void 0 || host.canHydrateTextInstance === void 0 || host.clearContainer === void 0) throw new Error("Hydration is not supported by this renderer.");
+		return host;
+	}
+	function throwHydrationMismatch(root, node, expected, where = "", boundaryId) {
+		const nothing = root.nextHydratableInstance === null;
+		const message = expected === void 0 ? `found an extra DOM node${where}` : nothing ? `expected ${expected}, but found no DOM node` : `expected ${expected}`;
+		const error = /* @__PURE__ */ new Error(`Hydration mismatch: ${message}.`);
+		queueRecoverableError(root, node, error, {
+			actual: expected === void 0 ? "extra DOM node" : nothing ? "nothing" : "different DOM node",
+			boundaryId,
+			expected,
+			recovery: "root",
+			source: "hydration"
+		});
+		throw new HydrationMismatchError(error.message);
+	}
+	function canBailout(node, root) {
+		return node.alternate !== null && (node.flags & 1) === 0 && node.props === node.alternate.memoizedProps && !includesSomeLane(node.lanes, root.renderLanes) && !contextDependenciesChanged(node, root);
+	}
+	function contextDependenciesChanged(node, root) {
+		const dependencies = node.contextDependencies;
+		if (dependencies === null) return false;
+		for (const dependency of dependencies) if (!Object.is(currentContextValue(root, dependency.context), dependency.memoizedValue)) return true;
+		return false;
+	}
+	function currentContextValue(root, context) {
+		return root.contextValues.has(context) ? root.contextValues.get(context) : context.defaultValue;
+	}
+	function shouldUseHostTextContent(node, root = rootOf(node)) {
+		return host.setTextContent !== void 0 && (!root.isHydrating || hydrationBypassedHost(node)) && !adoptedSingleTextChild(node) && hostTextContent(node.props.children) !== null;
+	}
+	function adoptedSingleTextChild(node) {
+		const child = node.alternate?.child ?? node.child;
+		return child !== null && child.tag === 2 && child.sibling === null;
+	}
+	function hydrationBypassedHost(node) {
+		return node.alternate === null && node.stateNode !== null && (node.flags & 4) === 0;
+	}
+	function isHoistedFiber(node) {
+		if (node.tag !== 1 || host.isHoistedInstance === void 0) return false;
+		if ((node.flags & 8192) !== 0) return false;
+		if (!host.isHoistedInstance(String(node.type), node.props)) {
+			node.flags |= NotHoistedFlag;
+			return false;
+		}
+		requireHoistedAssetHostConfig();
+		return true;
+	}
+	function requireHoistedAssetHostConfig() {
+		if (hoistedAssetHostConfig !== null) return hoistedAssetHostConfig;
+		if (host.isHoistedInstance === void 0 || host.commitHoistedInstance === void 0 || host.removeHoistedInstance === void 0 || host.updateHoistedInstance === void 0) throw new Error("Hoisted assets are not supported by this renderer.");
+		hoistedAssetHostConfig = host;
+		return hoistedAssetHostConfig;
+	}
+	function renderFunction(node, root) {
+		prepareHookRender(node, root);
+		const previousDispatcher = setCurrentDispatcher(dispatcher);
+		const previousDataStore = setCurrentDataStore(root.dataStore);
+		try {
+			reconcileCurrentChildren(node, node.type(node.props), root);
+			if (currentHook !== null) throw hookOrderError("fewer");
+		} finally {
+			setCurrentDataStore(previousDataStore);
+			setCurrentDispatcher(previousDispatcher);
+			renderingFiber = null;
+			currentHook = null;
+			workInProgressHook = null;
+			localIdCounter = 0;
+		}
+	}
+	function prepareHookRender(node, root) {
+		renderingFiber = node;
+		currentHook = node.alternate?.memoizedState ?? null;
+		workInProgressHook = null;
+		localIdCounter = 0;
+		node.memoizedState = null;
+		node.contextDependencies = null;
+		root.dataStore.resetDataDependencies(node);
+		node.dataDependenciesDirty = true;
+		recordCommitWork(root.commitIndex, node);
+	}
+	function beginSuspense(node, hasOwnWork) {
+		const root = rootOf(node);
+		const previousSuspenseState = fiberSuspenseState(node.alternate);
+		node.boundaryState = null;
+		if (previousSuspenseState?.kind === "dehydrated") {
+			if (!hasOwnWork) {
+				node.boundaryState = previousSuspenseState;
+				return;
+			}
+			hydrateDehydratedSuspenseBoundary(node, previousSuspenseState.boundary);
+			return;
+		}
+		if (tryDehydrateSuspenseBoundary(node)) return;
+		node.suspenseQueueStart = root.consumedPendingQueues.length;
+		if (previousSuspenseState === null) {
+			beginSuspensePrimary(node, suspensePrimaryFiber(node.alternate));
+			return;
+		}
+		const currentPrimary = suspensePrimaryFiber(node.alternate);
+		if (currentPrimary !== null) markSubtreeLanes(currentPrimary.child, root.renderLanes);
+		beginSuspensePrimary(node, currentPrimary, previousSuspenseState.primaryChild);
+		appendDeletions(node, suspenseFallbackFiber(node.alternate));
+	}
+	function markSubtreeLanes(node, lanes) {
+		for (let child = node; child !== null; child = child.sibling) {
+			child.lanes = mergeLanes(child.lanes, lanes);
+			child.childLanes = mergeLanes(child.childLanes, lanes);
+			markSubtreeLanes(child.child, lanes);
+		}
+	}
+	function beginSuspensePrimary(boundary, currentPrimary, capturedPrimary = null) {
+		if (capturedPrimary !== null) hasHiddenBoundaries = true;
+		boundary.child = suspensePrimaryWorkInProgress(boundary, currentPrimary, "visible", capturedPrimary);
+	}
+	function suspensePrimaryWorkInProgress(boundary, currentPrimary, mode, capturedPrimary = null) {
+		const props = {
+			mode,
+			children: boundary.props.children
+		};
+		const primary = currentPrimary === null ? fiber(10, null, null, props, null) : createWorkInProgress(currentPrimary, props);
+		primary.hiddenState = { currentFirstChild: capturedPrimary };
+		primary.index = 0;
+		primary.return = boundary;
+		primary.sibling = null;
+		return primary;
+	}
+	function suspenseFallbackWorkInProgress(boundary, currentFallback, index) {
+		const props = { children: boundary.props.fallback };
+		const fallback = currentFallback?.tag === 4 ? createWorkInProgress(currentFallback, props) : fiber(4, null, null, props, null);
+		fallback.index = index;
+		fallback.return = boundary;
+		fallback.sibling = null;
+		if (currentFallback === null) fallback.flags |= 1;
+		return fallback;
+	}
+	function suspensePrimaryFiber(node) {
+		const child = node?.child ?? null;
+		return child?.tag === 10 && child.type === null ? child : null;
+	}
+	function suspenseFallbackFiber(node) {
+		const primary = suspensePrimaryFiber(node);
+		return primary === null ? node?.child ?? null : primary.sibling;
+	}
+	function cloneSuspendedPrimary(node, parent) {
+		let first = null;
+		let previous = null;
+		for (let current = node; current !== null; current = current.sibling) {
+			const clone = createWorkInProgress(current, current.props);
+			clone.return = parent;
+			clone.child = cloneSuspendedPrimary(current.child, clone);
+			clone.sibling = null;
+			clone.lanes = 0;
+			clone.childLanes = 0;
+			if (previous === null) first = clone;
+			else previous.sibling = clone;
+			previous = clone;
+		}
+		return first;
+	}
+	function tryDehydrateSuspenseBoundary(node) {
+		const root = rootOf(node);
+		if (!shouldHydrateFiber(root, node)) return false;
+		if (host.getSuspenseBoundary === void 0) return false;
+		const hydratable = root.nextHydratableInstance;
+		if (hydratable === null) return false;
+		const boundary = host.getSuspenseBoundary(hydratable);
+		if (boundary === null) return false;
+		node.boundaryState = {
+			boundary,
+			kind: "dehydrated",
+			wasPending: boundary.status === "pending"
+		};
+		host.registerSuspenseBoundaryRetry?.(boundary, () => scheduleFiber(node, 32));
+		root.nextHydratableInstance = nextAfterSuspenseBoundary(boundary);
+		return true;
+	}
+	function hydrateDehydratedSuspenseBoundary(node, boundary) {
+		abandonedHydrationBoundaries.delete(node);
+		if (node.alternate !== null) abandonedHydrationBoundaries.delete(node.alternate);
+		if (!boundary.forceClientRender) {
+			if (boundary.status === "completed") {
+				enterSuspenseHydration(node, boundary);
+				node.boundaryState = null;
+				node.flags |= 4;
+				beginSuspensePrimary(node, suspensePrimaryFiber(node.alternate));
+				return;
+			}
+			if (boundary.status === "pending") {
+				node.boundaryState = {
+					boundary,
+					kind: "dehydrated",
+					wasPending: true
+				};
+				return;
+			}
+		}
+		if (boundary.status === "client-rendered") queueClientRenderedSuspenseError(rootOf(node), node, boundary);
+		node.boundaryState = null;
+		node.flags |= 4;
+		beginSuspensePrimary(node, suspensePrimaryFiber(node.alternate));
+	}
+	function queueClientRenderedSuspenseError(root, node, boundary) {
+		const boundaryError = boundary.error;
+		const error = new Error(boundaryError?.message ?? "The server could not finish this Suspense boundary. Switched to client rendering.");
+		if (boundaryError?.digest !== void 0) error.digest = boundaryError.digest;
+		queueRecoverableError(root, node, error, {
+			boundaryId: boundary.id ?? void 0,
+			digest: boundaryError?.digest,
+			recovery: "suspense",
+			source: "server"
+		});
+	}
+	function canHydratePendingSuspenseTextMismatch(root) {
+		const boundary = root.hydratingSuspenseBoundary;
+		const state = fiberSuspenseState(boundary?.alternate);
+		return state?.kind === "dehydrated" && state.wasPending;
+	}
+	function requireActivityHydrationHostConfig() {
+		if (activityHydrationHostConfig !== null) return activityHydrationHostConfig;
+		if (host.getActivityBoundary === void 0 || host.getFirstActivityHydratable === void 0 || host.commitHydratedActivityBoundary === void 0) throw new Error("Activity hydration requires getActivityBoundary, getFirstActivityHydratable, and commitHydratedActivityBoundary.");
+		activityHydrationHostConfig = host;
+		return activityHydrationHostConfig;
+	}
+	function tryDehydrateActivityBoundary(root, node, state) {
+		if (!shouldHydrateFiber(root, node)) return false;
+		if (host.getActivityBoundary === void 0) return false;
+		const hydratable = root.nextHydratableInstance;
+		if (hydratable === null) return false;
+		const boundary = host.getActivityBoundary(hydratable);
+		if (boundary === null) return false;
+		requireActivityHydrationHostConfig();
+		hasHiddenBoundaries = true;
+		state.dehydrated = boundary;
+		root.nextHydratableInstance = requireHydrationHostConfig().getNextHydratableSibling(boundary);
+		return true;
+	}
+	function hydrateDehydratedActivityBoundary(root, node) {
+		enterActivityHydration(root, node);
+		node.flags |= 36;
+		reconcile(node, node.props.children, null, false);
+	}
+	function enterActivityHydration(root, node) {
+		const boundary = dehydratedActivityBoundary(node);
+		if (boundary === null) throw new Error("Expected a dehydrated Activity boundary.");
+		root.isHydrating = true;
+		root.hydrationParent = node;
+		root.hydratingActivityBoundary = node;
+		root.nextHydratableInstance = requireActivityHydrationHostConfig().getFirstActivityHydratable(boundary);
+	}
+	function leaveActivityHydration(root, node) {
+		root.hydrationParent = nextHydrationParent(node.return);
+		root.nextHydratableInstance = null;
+		root.hydratingActivityBoundary = null;
+		root.isHydrating = false;
+	}
+	function abandonActivityHydration(root, forceClientRender = false) {
+		if (forceClientRender) {
+			const state = fiberActivityState(root.hydratingActivityBoundary);
+			if (state !== null) state.dehydrated = null;
+		}
+		deactivateHydration(root);
+	}
+	function enterSuspenseHydration(node, boundary) {
+		const root = rootOf(node);
+		root.isHydrating = true;
+		root.hydrationParent = node;
+		root.hydratingSuspenseBoundary = node;
+		root.nextHydratableInstance = firstWithinSuspenseBoundary(boundary);
+	}
+	function leaveSuspenseHydration(root, node, boundary) {
+		root.hydrationParent = nextHydrationParent(node.return);
+		root.nextHydratableInstance = nextAfterSuspenseBoundary(boundary);
+		root.hydratingSuspenseBoundary = null;
+		root.isHydrating = false;
+	}
+	function beginErrorBoundary(node) {
+		const previousErrorState = fiberErrorBoundaryState(node.alternate);
+		node.boundaryState = previousErrorState;
+		reconcileCurrentChildren(node, previousErrorState === null ? node.props.children : errorBoundaryFallback(node, previousErrorState));
+	}
+	function errorBoundaryFallback(node, state) {
+		const fallback = node.props.fallback;
+		return typeof fallback === "function" ? fallback(state.error, state.info) : fallback;
+	}
+	function beginPortal(node) {
+		reconcileCurrentChildren(node, node.props.children);
+	}
+	function updateStateHook(initialState) {
+		const hook = updateQueuedHook(3, initialState);
+		const queue = hook.queue;
+		const fiber = requireRenderingFiber();
+		queue.dispatch ??= (action) => {
+			if (renderingFiber !== null) throw new Error("State updates are not allowed while rendering a component.");
+			scheduleHookUpdate(fiber, queue, action, requestUpdateLane());
+		};
+		return [hook.memoizedState, queue.dispatch];
+	}
+	function updateActionStateHook(action, initialState) {
+		const hook = updateQueuedHook(4, () => createActionState(action, initialState));
+		const queue = hook.queue;
+		const fiber = requireRenderingFiber();
+		const instance = hook.memoizedState.instance;
+		const nextState = {
+			...hook.memoizedState,
+			action
+		};
+		hook.memoizedState = nextState;
+		if (hook.baseQueue === null) hook.baseState = nextState;
+		else hook.baseState = {
+			...hook.baseState,
+			action
+		};
+		if (queue.dispatch === null) {
+			const updatePending = (delta, lane) => {
+				scheduleHookUpdate(fiber, queue, (state) => ({
+					...state,
+					pending: Math.max(0, state.pending + delta)
+				}), lane);
+			};
+			const finish = (lane, error, ...value) => {
+				scheduleHookUpdate(fiber, queue, (state) => ({
+					...state,
+					error,
+					pending: Math.max(0, state.pending - 1),
+					value: value.length === 0 ? state.value : value[0]
+				}), lane);
+			};
+			queue.dispatch = ((...args) => {
+				if (renderingFiber !== null) throw new Error("Action state updates are not allowed during render.");
+				runLatest(instance, fiber, (signal) => instance.action(instance.value, ...args, signal), updatePending, (lane, value, failed) => {
+					if (failed) finish(lane, value);
+					else finish(lane, NoActionStateError, value);
+				});
+			});
+		}
+		if (hook.memoizedState.error !== NoActionStateError) throw hook.memoizedState.error;
+		return [
+			hook.memoizedState.value,
+			queue.dispatch,
+			hook.memoizedState.pending > 0
+		];
+	}
+	function updateIdHook() {
+		const fiber = requireRenderingFiber();
+		const oldHook = updateHook(5);
+		const id = oldHook === null ? createFiberId(rootOf(fiber), fiber, localIdCounter) : oldHook.memoizedState;
+		localIdCounter += 1;
+		appendHook(createHook(5, id));
+		return id;
+	}
+	function updateMemoHook(calculate, deps) {
+		requireRenderingFiber();
+		const previous = updateHook(8)?.memoizedState;
+		const state = previous !== void 0 && areHookInputsEqual(deps, previous.deps) ? previous : {
+			deps,
+			value: calculate()
+		};
+		appendHook(createHook(8, state));
+		return state.value;
+	}
+	function updateDeferredValueHook(value, initialValue, hasInitialValue) {
+		const fiber = requireRenderingFiber();
+		const oldHook = updateHook(6);
+		let next = oldHook === null ? initialDeferredValue(value, initialValue, hasInitialValue) : oldHook.memoizedState;
+		if (!Object.is(next, value)) if (isTransitionOrDeferredRender(rootOf(fiber))) next = value;
+		else scheduleFiber(fiber, DeferredLane);
+		appendHook(createHook(6, next));
+		return next;
+	}
+	function initialDeferredValue(value, initialValue, hasInitialValue) {
+		return hasInitialValue ? initialValue : value;
+	}
+	function isTransitionOrDeferredRender(root) {
+		return includesOnlyTransitions(root.renderLanes) || includesSomeLane(root.renderLanes, 1073741824);
+	}
+	function updateTransitionHook() {
+		const hook = updateQueuedHook(9, {
+			instance: {
+				controller: null,
+				generation: 0
+			},
+			pendingCount: 0,
+			start: null
+		});
+		const queue = hook.queue;
+		if (hook.memoizedState.start === null) {
+			const fiber = requireRenderingFiber();
+			const updatePending = (delta, lane) => {
+				scheduleHookUpdate(fiber, queue, (state) => ({
+					...state,
+					pendingCount: Math.max(0, state.pendingCount + delta)
+				}), lane);
+			};
+			const instance = hook.memoizedState.instance;
+			hook.memoizedState.start = (callback) => {
+				if (renderingFiber !== null) throw new Error("Transitions cannot be started while rendering a component.");
+				runLatest(instance, fiber, callback, updatePending, (lane, value, failed, asynchronous) => {
+					updatePending(-1, lane);
+					if (failed) {
+						if (!asynchronous) throw value;
+						queueMicrotask(() => {
+							throw value;
+						});
+					}
+				});
+			};
+		}
+		return [hook.memoizedState.pendingCount > 0, hook.memoizedState.start];
+	}
+	function runLatest(instance, fiber, run, updatePending, settled) {
+		if (retireRun(instance)) updatePending(-1, 32);
+		const lane = claimNextTransitionLane();
+		const controller = new AbortController();
+		const generation = instance.generation += 1;
+		instance.controller = controller;
+		updatePending(1, 2);
+		const settle = (value, failed, asynchronous) => {
+			if (generation !== instance.generation) return;
+			instance.controller = null;
+			settled(lane, value, failed, asynchronous);
+		};
+		const store = rootOfOrNull(fiber)?.dataStore;
+		let result;
+		try {
+			const invoke = () => runWithTransitionLane(lane, () => run(controller.signal));
+			result = store === void 0 ? invoke() : store.run(invoke);
+		} catch (error) {
+			settle(error, true, false);
+			return;
+		}
+		if (!isThenable(result)) {
+			settle(result, false, false);
+			return;
+		}
+		result.then((value) => settle(value, false, true), (error) => settle(error, true, true));
+	}
+	function requireRenderingFiber() {
+		if (renderingFiber === null) throw new Error("Hooks can only be called while rendering a component.");
+		return renderingFiber;
+	}
+	function updateQueuedHook(kind, initialState) {
+		const fiber = requireRenderingFiber();
+		const oldHook = updateHook(kind);
+		const hook = oldHook === null ? createHook(kind, resolveInitialState(initialState)) : {
+			...oldHook,
+			next: null
+		};
+		appendHook(hook);
+		const root = rootOf(fiber);
+		const pending = hook.queue.pending;
+		if (pending !== null) hook.baseQueue = consumePendingHookQueue(root, hook, pending);
+		if (hook.baseQueue !== null) processHookQueue(hook, root.renderLanes);
+		return hook;
+	}
+	function updateExternalStoreHook(subscribe, getSnapshot, getServerSnapshot) {
+		const fiber = requireRenderingFiber();
+		const oldHook = updateHook(7);
+		const root = rootOf(fiber);
+		const value = readExternalStoreSnapshot(root, getSnapshot, getServerSnapshot);
+		const state = {
+			getSnapshot,
+			instance: oldHook?.memoizedState.instance ?? {
+				committedSubscribe: null,
+				getSnapshot,
+				owner: null,
+				unsubscribe: null,
+				value
+			},
+			subscribe,
+			value
+		};
+		recordCommitWork(root.commitIndex, fiber, StoreConsistencyFlag);
+		appendHook(createHook(7, state));
+		return value;
+	}
+	function updateStableEventHook(handler) {
+		requireRenderingFiber();
+		const instance = updateHook(10)?.memoizedState.instance ?? createStableEventInstance();
+		appendHook(createHook(10, {
+			instance,
+			next: handler
+		}));
+		return instance.stable;
+	}
+	function createStableEventInstance() {
+		const instance = {
+			controller: null,
+			handler: null,
+			live: false,
+			stable: (...args) => {
+				if (renderingFiber !== null) throw new Error("Stable events cannot be called while rendering a component.");
+				const handler = instance.handler;
+				if (handler === null) throw new Error("Stable events cannot be called before their first commit.");
+				instance.controller?.abort();
+				instance.controller = new AbortController();
+				if (!instance.live) instance.controller.abort();
+				return handler(...args, instance.controller.signal);
+			}
+		};
+		return instance;
+	}
+	function readExternalStoreSnapshot(root, getSnapshot, getServerSnapshot) {
+		if (!root.isHydrating) return getSnapshot();
+		if (getServerSnapshot === void 0) throw new Error("useSyncExternalStore requires getServerSnapshot during hydration.");
+		return getServerSnapshot();
+	}
+	function processHookQueue(hook, renderLanes) {
+		const baseQueue = hook.baseQueue;
+		if (baseQueue === null) return;
+		let state = hook.baseState;
+		let newBaseState = state;
+		let newBaseQueue = null;
+		let update = baseQueue.next;
+		do {
+			if (update.lane !== 0 && !includesSomeLane(renderLanes, update.lane)) {
+				const cloneUpdate = cloneUpdateNode(update);
+				if (newBaseQueue === null) newBaseState = state;
+				newBaseQueue = mergeQueues(newBaseQueue, cloneUpdate);
+			} else {
+				state = typeof update.action === "function" ? update.action(state) : update.action;
+				if (newBaseQueue !== null) {
+					const cloneUpdate = cloneUpdateNode(update);
+					cloneUpdate.lane = 0;
+					newBaseQueue = mergeQueues(newBaseQueue, cloneUpdate);
+				}
+			}
+			update = update.next;
+		} while (update !== baseQueue.next);
+		hook.memoizedState = state;
+		hook.baseState = newBaseQueue === null ? state : newBaseState;
+		hook.baseQueue = newBaseQueue;
+	}
+	function scheduleHookUpdate(fiber, queue, action, lane) {
+		lane = hiddenSubtreeLane(fiber, lane);
+		const update = {
+			action,
+			lane,
+			next: null
+		};
+		update.next = update;
+		queue.pending = mergeQueues(queue.pending, update);
+		scheduleFiber(fiber, lane);
+	}
+	function hiddenSubtreeLane(node, lane) {
+		if (!hasHiddenBoundaries || lane === 536870912) return lane;
+		for (let parent = node.return; parent !== null; parent = parent.return) if (isHiddenBoundaryTag(parent) && fiberActivityState(parent)?.hidden === true) return OffscreenLane;
+		return lane;
+	}
+	function createFiberId(root, fiber, localId) {
+		return `${root.identifierPrefix}fig-${fiberPath(fiber)}-${localId.toString(32)}`;
+	}
+	function fiberPath(fiber) {
+		const parts = [];
+		for (let node = fiber; node !== null && node.tag !== 0; node = node.return) parts.push(node.index.toString(32));
+		return parts.reverse().join("-");
+	}
+	function consumePendingHookQueue(root, hook, pending) {
+		const queue = hook.queue;
+		queue.pending = null;
+		root.consumedPendingQueues.push({
+			queue,
+			pending
+		});
+		return mergeQueues(cloneQueue(hook.baseQueue), cloneQueueNodes(pending));
+	}
+	function appendHook(hook) {
+		if (renderingFiber === null) return;
+		if (workInProgressHook === null) renderingFiber.memoizedState = hook;
+		else workInProgressHook.next = hook;
+		workInProgressHook = hook;
+	}
+	function updateEffectHook(phase, create, deps) {
+		const fiber = requireRenderingFiber();
+		const oldHook = updateHook(phase);
+		const nextDeps = deps ?? null;
+		const previousEffect = oldHook?.memoizedState ?? null;
+		const hasChanged = previousEffect === null || previousEffect.controller === null || previousEffect.controller.signal.aborted || !areHookInputsEqual(nextDeps, previousEffect.deps);
+		const effect = {
+			phase,
+			create,
+			controller: previousEffect?.controller ?? null,
+			deps: nextDeps,
+			owner: fiber,
+			strictRan: __DEV__
+		};
+		appendHook(createHook(phase, effect));
+		if (hasChanged) {
+			fiber.effects ??= [];
+			fiber.effects.push(effect);
+			const root = rootOf(fiber);
+			recordCommitWork(root.commitIndex, fiber, 512);
+			markCommitEffectPhase(root, phase);
+		}
+	}
+	function readContextValue(context) {
+		if (renderingFiber === null) throw new Error("readContext can only be called while rendering a component.");
+		const root = rootOf(renderingFiber);
+		const contextKey = context;
+		const value = currentContextValue(root, contextKey);
+		addContextDependency(renderingFiber, contextKey, value);
+		return value;
+	}
+	function pushContextProvider(node, root = rootOf(node)) {
+		const context = node.type;
+		const values = root.contextValues;
+		const hadPrevious = values.has(context);
+		const previous = values.get(context);
+		values.set(context, node.props.value);
+		root.contextStack.push({
+			context,
+			hadPrevious,
+			previous,
+			provider: node
+		});
+	}
+	function popContextProvider(node) {
+		const root = rootOf(node);
+		const entry = root.contextStack.pop();
+		if (entry === void 0 || entry.provider !== node) {
+			resetContextStack(root);
+			return;
+		}
+		restoreContextEntry(root, entry);
+	}
+	function unwindContextTo(root, node) {
+		while (root.contextStack.length > 0) {
+			const entry = root.contextStack[root.contextStack.length - 1];
+			if (node !== null && isAncestorOf(entry.provider, node)) return;
+			restoreContextEntry(root, root.contextStack.pop());
+		}
+	}
+	function restoreContextEntry(root, entry) {
+		if (entry.hadPrevious) root.contextValues.set(entry.context, entry.previous);
+		else root.contextValues.delete(entry.context);
+	}
+	function resetContextStack(root) {
+		root.contextValues = /* @__PURE__ */ new Map();
+		root.contextStack = [];
+	}
+	function isAncestorOf(ancestor, node) {
+		for (let parent = node; parent !== null; parent = parent.return) if (parent === ancestor) return true;
+		return false;
+	}
+	function addContextDependency(node, context, memoizedValue) {
+		node.contextDependencies ??= [];
+		const dependency = contextDependency(node, context);
+		if (dependency === null) node.contextDependencies.push({
+			context,
+			memoizedValue
+		});
+		else dependency.memoizedValue = memoizedValue;
+	}
+	function contextDependency(node, context) {
+		return node.contextDependencies?.find((dependency) => dependency.context === context) ?? null;
+	}
+	function appendContextDependencies(list, dependencies) {
+		if (dependencies === null) return list;
+		let next = list;
+		for (const dependency of dependencies) next = appendContext(next, dependency.context);
+		return next;
+	}
+	function appendContextList(list, contexts) {
+		if (contexts === null) return list;
+		let next = list;
+		for (const context of contexts) next = appendContext(next, context);
+		return next;
+	}
+	function appendContext(list, context) {
+		if (list === null) return [context];
+		if (!list.includes(context)) list.push(context);
+		return list;
+	}
+	function contextListIncludes(list, context) {
+		return list?.includes(context) === true;
+	}
+	function updateHook(kind) {
+		const hook = currentHook;
+		if (hook === null) {
+			if (didRenderBefore(renderingFiber)) throw hookOrderError("more");
+			return null;
+		}
+		if (hook.kind !== kind) throw new Error(`Hook order changed: expected ${hookKindName(hook.kind)}, received ${hookKindName(kind)}.`);
+		currentHook = hook.next;
+		return hook;
+	}
+	function didRenderBefore(node) {
+		const previous = node?.alternate ?? null;
+		return previous !== null && previous.memoizedProps !== null;
+	}
+	function hookOrderError(direction) {
+		return /* @__PURE__ */ new Error(`Rendered ${direction} hooks than during the previous render.`);
+	}
+	function complete(node) {
+		completeHydration(node);
+		let child = node.child;
+		let childLanes = 0;
+		let subtreeFlags = 0;
+		let contextSubtreeDependencies = null;
+		while (child !== null) {
+			childLanes = mergeLanes(childLanes, child.lanes);
+			childLanes = mergeLanes(childLanes, child.childLanes);
+			subtreeFlags |= childSubtreeFlags(child);
+			contextSubtreeDependencies = appendContextDependencies(contextSubtreeDependencies, child.contextDependencies);
+			contextSubtreeDependencies = appendContextList(contextSubtreeDependencies, child.contextSubtreeDependencies);
+			child = child.sibling;
+		}
+		if (isNewHostInstance(node)) {
+			host.finalizeInitialInstance?.(node.stateNode, node.props);
+			if (!setInitialHostTextContent(node)) {
+				if (node.alternate !== null && node.child !== null) host.setTextContent?.(node.stateNode, "");
+				appendAllHostChildren(node.stateNode, node.child);
+			}
+			if (host.appendInitialChild !== void 0) node.flags |= 64;
+		}
+		if (node.tag === 11) node.flags |= ViewTransitionStaticFlag;
+		node.childLanes = childLanes;
+		node.subtreeFlags = subtreeFlags;
+		node.contextSubtreeDependencies = contextSubtreeDependencies;
+		node.memoizedProps = node.props;
+		if (node.tag === 5 && (node.flags & 16) === 0) popContextProvider(node);
+	}
+	function isNewHostInstance(node) {
+		return node.tag === 1 && node.committedProps === null && (node.flags & 4) === 0;
+	}
+	function setInitialHostTextContent(node) {
+		const text = hostTextContent(node.props.children);
+		if (text === null || host.setTextContent === void 0) return false;
+		host.setTextContent(node.stateNode, text);
+		return true;
+	}
+	function appendAllHostChildren(parent, child) {
+		if (host.appendInitialChild === void 0) return;
+		for (let node = child; node !== null; node = node.sibling) {
+			if (node.tag === 8) continue;
+			if (isHoistedFiber(node)) continue;
+			if (node.tag === 1 || node.tag === 2) host.appendInitialChild(parent, hostNode(node));
+			else appendAllHostChildren(parent, node.child);
+		}
+	}
+	function reconcileCurrentChildren(parent, children, root = rootOf(parent)) {
+		reconcile(parent, children, parent.alternate?.child ?? null, false, root);
+	}
+	function reconcile(parent, children, currentFirstChild, forcePlacement, root = rootOf(parent)) {
+		const nextChildren = collectChildren(children);
+		const seenKeys = null;
+		parent.child = null;
+		parent.deletions = null;
+		let previous = null;
+		let old = currentFirstChild;
+		let index = 0;
+		let lastPlacedIndex = 0;
+		const isHydratingNewTree = parent.tag !== 8 && root.isHydrating && currentFirstChild === null;
+		for (; old !== null && index < nextChildren.length; index += 1) {
+			const child = nextChildren[index];
+			if (!sameChildKey(old, child, index) || !sameType(old, child)) break;
+			validateChildKey(child, seenKeys);
+			const next = createWorkInProgress(old, propsFor(child));
+			next.index = index;
+			next.return = parent;
+			const updateFlags = hostUpdateFlags(old, next.props);
+			if (updateFlags !== 0) recordCommitWork(root.commitIndex, next, updateFlags);
+			if (forcePlacement) next.flags |= 1;
+			else lastPlacedIndex = old.index;
+			previous = appendChild(parent, previous, next);
+			old = old.sibling;
+		}
+		if (index === nextChildren.length) {
+			appendDeletions(parent, old);
+			return;
+		}
+		if (old === null) {
+			for (; index < nextChildren.length; index += 1) {
+				validateChildKey(nextChildren[index], seenKeys);
+				const next = fiberFrom(nextChildren[index]);
+				if (next === null) continue;
+				next.index = index;
+				next.return = parent;
+				if (!isHydratingNewTree) next.flags |= 1;
+				previous = appendChild(parent, previous, next);
+			}
+			return;
+		}
+		let existingByKey = null;
+		let existingByIndex = null;
+		for (; old !== null; old = old.sibling) if (old.key === null) (existingByIndex ??= /* @__PURE__ */ new Map()).set(old.index, old);
+		else (existingByKey ??= /* @__PURE__ */ new Map()).set(String(old.key), old);
+		for (; index < nextChildren.length; index += 1) {
+			const child = nextChildren[index];
+			validateChildKey(child, seenKeys);
+			const key = childExplicitKey(child);
+			const matched = key === null ? existingByIndex?.get(index) : existingByKey?.get(key);
+			const canReuse = matched !== void 0 && sameType(matched, child);
+			const next = canReuse ? createWorkInProgress(matched, propsFor(child)) : fiberFrom(child);
+			if (next === null) continue;
+			next.index = index;
+			next.return = parent;
+			if (canReuse) {
+				if (key === null) existingByIndex?.delete(index);
+				else existingByKey?.delete(key);
+				const updateFlags = hostUpdateFlags(matched, next.props);
+				if (updateFlags !== 0) recordCommitWork(root.commitIndex, next, updateFlags);
+				if (forcePlacement || matched.index < lastPlacedIndex) next.flags |= 1;
+				else lastPlacedIndex = matched.index;
+			} else if (!isHydratingNewTree) next.flags |= 1;
+			previous = appendChild(parent, previous, next);
+		}
+		if (existingByKey !== null) for (const child of existingByKey.values()) appendDeletion(parent, child);
+		if (existingByIndex !== null) for (const child of existingByIndex.values()) appendDeletion(parent, child);
+	}
+	function appendDeletions(parent, firstChild) {
+		for (let child = firstChild; child !== null; child = child.sibling) appendDeletion(parent, child);
+	}
+	function appendDeletion(parent, child) {
+		const root = rootOf(parent);
+		parent.deletions ??= [];
+		parent.deletions.push(child);
+		root.needsCommitDeletions = true;
+		recordCommitWork(root.commitIndex, parent, 128);
+	}
+	function hostUpdateFlags(current, nextProps) {
+		if (current.tag === 2) return current.committedProps?.nodeValue !== nextProps.nodeValue ? 2 : 0;
+		if (current.tag !== 1) return 0;
+		const previousProps = current.committedProps ?? {};
+		let flags = 0;
+		if (hostPropsChanged(previousProps, nextProps)) flags |= 2;
+		if (host.shouldCommitUpdate?.(String(current.type), previousProps, nextProps)) flags |= 2;
+		if (hostTextContentChanged(current, previousProps, nextProps)) flags |= 8;
+		return flags;
+	}
+	function hostTextContentChanged(current, previous, next) {
+		if (host.setTextContent === void 0) return false;
+		if (hasUnsafeHTML(next)) return false;
+		if (adoptedSingleTextChild(current)) return false;
+		const previousText = hostTextContent(previous.children);
+		const nextText = hostTextContent(next.children);
+		return previousText !== nextText || nextText !== null && current.child !== null;
+	}
+	function hostPropsChanged(previous, next) {
+		let previousCount = 0;
+		for (const key in previous) {
+			if (!Object.hasOwn(previous, key)) continue;
+			if (!committedHostProp(key)) continue;
+			previousCount += 1;
+			if (!(key in next) || previous[key] !== next[key]) return true;
+		}
+		let nextCount = 0;
+		for (const key in next) {
+			if (!Object.hasOwn(next, key)) continue;
+			if (committedHostProp(key)) nextCount += 1;
+		}
+		return previousCount !== nextCount;
+	}
+	function committedHostProp(name) {
+		return name !== "children";
+	}
+	function isViewTransitionEligibleCommit(root) {
+		return !root.clearContainerBeforeCommit && root.renderLanes !== 0 && (root.renderLanes & -1409285889) === 0 && viewTransitionHost !== null;
+	}
+	function prepareViewTransitionPlan(root, finishedWork) {
+		if (!isViewTransitionEligibleCommit(root)) return null;
+		if ((finishedWork.subtreeFlags & 4096) === 0 && !root.needsCommitDeletions) return null;
+		const plan = {
+			newSurfaces: [],
+			oldSurfaces: [],
+			rootAffected: false
+		};
+		const exitsByName = /* @__PURE__ */ new Map();
+		if (root.needsCommitDeletions) collectDeletedViewTransitions(root, finishedWork, plan, exitsByName);
+		const changedBoundaries = attributeQueuedHostUpdates(root, plan);
+		collectFinishedViewTransitions(finishedWork.child, false, false, false, changedBoundaries, plan, exitsByName);
+		if (plan.oldSurfaces.length === 0 && plan.newSurfaces.length === 0) return null;
+		return plan;
+	}
+	function collectDeletedViewTransitions(root, node, plan, exitsByName) {
+		for (const cursor of root.commitIndex) {
+			if (cursor.deletions === null) continue;
+			for (const deletion of cursor.deletions) collectDeletedViewTransitionFiber(deletion, plan, exitsByName, true);
+		}
+	}
+	function collectDeletedViewTransitionFiber(cursor, plan, exitsByName, collectExit) {
+		if (cursor.tag === 8 || isHiddenBoundary(cursor)) return;
+		if (cursor.tag === 11) {
+			if (explicitViewTransitionName(cursor) !== null) exitsByName.set(viewTransitionName(cursor), cursor);
+			if (collectExit) collectViewTransitionSurfaces(cursor, "exit", plan.oldSurfaces, "committed");
+			for (let child = cursor.child; child !== null; child = child.sibling) collectDeletedViewTransitionFiber(child, plan, exitsByName, false);
+			return;
+		}
+		if ((cursor.subtreeFlags & 4096) === 0) return;
+		for (let child = cursor.child; child !== null; child = child.sibling) collectDeletedViewTransitionFiber(child, plan, exitsByName, collectExit);
+	}
+	function attributeQueuedHostUpdates(root, plan) {
+		let changed = null;
+		for (const entry of root.commitIndex) {
+			if ((entry.flags & 10) === 0) continue;
+			let sawPortal = false;
+			let boundary = null;
+			for (let parent = entry.return; parent !== null; parent = parent.return) {
+				if (parent.tag === 11) {
+					boundary = parent;
+					break;
+				}
+				if (parent.tag === 8) sawPortal = true;
+			}
+			if (boundary === null) plan.rootAffected = true;
+			else if (!sawPortal) (changed ??= /* @__PURE__ */ new Set()).add(boundary);
+		}
+		return changed;
+	}
+	function collectFinishedViewTransitions(node, placed, insideBoundary, ancestorLayoutChanged, changedBoundaries, plan, exitsByName) {
+		let layoutChanged = ancestorLayoutChanged;
+		for (let cursor = node; !layoutChanged && cursor !== null; cursor = cursor.sibling) if ((cursor.flags & 1) !== 0 && (cursor.alternate !== null || (cursor.flags & 16) !== 0)) layoutChanged = true;
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			const cursorPlaced = placed || (cursor.flags & 1) !== 0;
+			if (!(cursor.tag === 11 || (cursor.subtreeFlags & 4096) !== 0)) {
+				if (!insideBoundary && ((cursor.flags | cursor.subtreeFlags) & 175) !== 0) plan.rootAffected = true;
+				continue;
+			}
+			if (isStablyHiddenBoundary(cursor)) continue;
+			if (cursor.tag === 11) {
+				if (!cursorPlaced && ((cursor.flags | cursor.subtreeFlags) & 4) !== 0) continue;
+				if (cursorPlaced) {
+					const pairedExit = exitsByName.get(viewTransitionName(cursor));
+					if (pairedExit !== void 0) {
+						if (!insideBoundary) plan.rootAffected = true;
+						collectViewTransitionPair(plan, pairedExit, cursor);
+						exitsByName.delete(viewTransitionName(cursor));
+					} else if (cursor.alternate !== null) {
+						collectViewTransitionSurfaces(cursor.alternate, "update", plan.oldSurfaces, "committed", false);
+						collectViewTransitionSurfaces(cursor, "update", plan.newSurfaces, "finished", false);
+					} else {
+						if (!insideBoundary) plan.rootAffected = true;
+						collectViewTransitionSurfaces(cursor, "enter", plan.newSurfaces, "finished");
+					}
+					collectAppearingPairViewTransitions(cursor.child, plan, exitsByName);
+					continue;
+				}
+				const current = cursor.alternate ?? cursor;
+				const contentChanged = viewTransitionChangedOutsideNested(cursor, changedBoundaries);
+				if (contentChanged || layoutChanged) {
+					collectViewTransitionSurfaces(current, "update", plan.oldSurfaces, "committed", contentChanged);
+					collectViewTransitionSurfaces(cursor, "update", plan.newSurfaces, "finished", contentChanged);
+				}
+				collectFinishedViewTransitions(cursor.child, cursorPlaced, true, contentChanged || layoutChanged, changedBoundaries, plan, exitsByName);
+				continue;
+			}
+			if (cursor.tag !== 8) {
+				if (!insideBoundary && (cursor.flags & 175) !== 0) plan.rootAffected = true;
+				collectFinishedViewTransitions(cursor.child, cursorPlaced, insideBoundary, layoutChanged || (cursor.flags & 175) !== 0, changedBoundaries, plan, exitsByName);
+			}
+		}
+	}
+	function collectAppearingPairViewTransitions(node, plan, exitsByName) {
+		if (exitsByName.size === 0) return;
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if (cursor.tag === 8 || isStablyHiddenBoundary(cursor)) continue;
+			if (cursor.tag === 11) {
+				const pairedExit = explicitViewTransitionName(cursor) !== null ? exitsByName.get(viewTransitionName(cursor)) : void 0;
+				if (pairedExit !== void 0) {
+					collectViewTransitionPair(plan, pairedExit, cursor);
+					exitsByName.delete(viewTransitionName(cursor));
+				}
+			}
+			collectAppearingPairViewTransitions(cursor.child, plan, exitsByName);
+		}
+	}
+	function collectViewTransitionPair(plan, oldBoundary, newBoundary) {
+		removeViewTransitionSurfaces(plan.oldSurfaces, oldBoundary);
+		collectViewTransitionSurfaces(oldBoundary, "share", plan.oldSurfaces, "committed");
+		collectViewTransitionSurfaces(newBoundary, "share", plan.newSurfaces, "finished");
+	}
+	function isStablyHiddenBoundary(node) {
+		if (!isHiddenBoundary(node)) return false;
+		const current = node.alternate;
+		return current === null || activityHidden(current.memoizedProps ?? current.props);
+	}
+	function viewTransitionChangedOutsideNested(boundary, changedBoundaries) {
+		if ((boundary.flags & 175) !== 0) return true;
+		if (changedBoundaries !== null && changedBoundaries.has(boundary)) return true;
+		return subtreeChangedOutsideNested(boundary.child);
+	}
+	function subtreeChangedOutsideNested(node) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if (cursor.tag === 8) continue;
+			if (cursor.tag === 11) continue;
+			if ((cursor.flags & 175) !== 0) return true;
+			if ((cursor.subtreeFlags & 175) === 0) continue;
+			if (subtreeChangedOutsideNested(cursor.child)) return true;
+		}
+		return false;
+	}
+	function removeViewTransitionSurfaces(surfaces, boundary) {
+		for (let index = surfaces.length - 1; index >= 0; index -= 1) if (surfaces[index].boundary === boundary) surfaces.splice(index, 1);
+	}
+	function collectViewTransitionSurfaces(boundary, phase, surfaces, propsSource, mustAnimate = true) {
+		const className = viewTransitionClass(boundary.props, phase);
+		if (className === "none") return;
+		const name = viewTransitionName(boundary);
+		let index = 0;
+		const collect = (node) => {
+			for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+				if (cursor.tag === 8) continue;
+				if (cursor.tag === 11) continue;
+				if (cursor.tag === 1) {
+					if (!isHoistedFiber(cursor)) {
+						surfaces.push({
+							boundary,
+							className,
+							instance: cursor.stateNode,
+							measurement: null,
+							mustAnimate,
+							name: index === 0 ? name : `${name}_${index}`,
+							phase,
+							props: viewTransitionSurfaceProps(cursor, propsSource),
+							skipped: false
+						});
+						index += 1;
+					}
+					continue;
+				}
+				collect(cursor.child);
+			}
+		};
+		collect(boundary.child);
+	}
+	function viewTransitionSurfaceProps(node, source) {
+		if (source === "committed") return node.committedProps ?? node.memoizedProps ?? node.props;
+		return node.memoizedProps ?? node.props;
+	}
+	function viewTransitionName(node) {
+		const props = node.props;
+		if (props.name !== void 0 && props.name !== "auto") return props.name;
+		const state = node.stateNode;
+		state.autoName ??= `fig-vt-${viewTransitionAutoNameCounter++}`;
+		return state.autoName;
+	}
+	function explicitViewTransitionName(node) {
+		const name = node.props.name;
+		return name === void 0 || name === "auto" ? null : name;
+	}
+	function viewTransitionClass(props, phase) {
+		const viewTransitionProps = props;
+		const phaseClass = viewTransitionProps[phase];
+		const className = phaseClass === void 0 ? viewTransitionProps.default : phaseClass;
+		if (className === void 0 || className === "auto") return null;
+		if (className === "none") return "none";
+		return className;
+	}
+	function applyOldViewTransitionSurfaces(plan) {
+		if (viewTransitionHost === null) return;
+		const measure = viewTransitionHost.measure;
+		for (const surface of plan.oldSurfaces) {
+			surface.measurement = measure?.(surface.instance) ?? null;
+			if (surface.phase === "exit" && surface.measurement !== null && !surface.measurement.inViewport) {
+				surface.skipped = true;
+				continue;
+			}
+			viewTransitionHost.apply(surface.instance, surface.name, surface.className);
+		}
+	}
+	function resolveViewTransitionPlan(plan) {
+		const result = {
+			canceledNames: [],
+			cancelRootSnapshot: false
+		};
+		if (viewTransitionHost === null || plan === null) return result;
+		const measure = viewTransitionHost.measure;
+		const oldByName = /* @__PURE__ */ new Map();
+		for (const surface of plan.oldSurfaces) if (!surface.skipped) oldByName.set(surface.name, surface);
+		let rootAffected = plan.rootAffected;
+		const newNames = /* @__PURE__ */ new Set();
+		for (const surface of plan.newSurfaces) {
+			newNames.add(surface.name);
+			const measurement = measure?.(surface.instance) ?? null;
+			if (surface.phase === "enter") {
+				if (measurement !== null && !measurement.inViewport) {
+					surface.skipped = true;
+					continue;
+				}
+				applyViewTransitionSurface(viewTransitionHost, surface);
+				continue;
+			}
+			if (surface.phase === "update") {
+				const before = oldByName.get(surface.name)?.measurement ?? null;
+				if (before !== null && measurement !== null) {
+					const moved = before.x !== measurement.x || before.y !== measurement.y || before.width !== measurement.width || before.height !== measurement.height;
+					if (!before.inViewport && !measurement.inViewport || !surface.mustAnimate && !moved) {
+						surface.skipped = true;
+						viewTransitionHost.restore(surface.instance, surface.props);
+						if (oldByName.has(surface.name)) result.canceledNames.push(surface.name);
+						continue;
+					}
+					if ((before.width !== measurement.width || before.height !== measurement.height) && !measurement.absolutelyPositioned) rootAffected = true;
+				}
+			}
+			applyViewTransitionSurface(viewTransitionHost, surface);
+		}
+		for (const [name, surface] of oldByName) if (surface.phase === "update" && !newNames.has(name)) rootAffected = true;
+		result.cancelRootSnapshot = !rootAffected;
+		return result;
+	}
+	function applyViewTransitionSurface(viewTransitionHost, surface) {
+		viewTransitionHost.apply(surface.instance, surface.name, surface.className);
+	}
+	function restoreViewTransitionSurfaces(plan) {
+		if (viewTransitionHost === null) return;
+		const propsByInstance = /* @__PURE__ */ new Map();
+		for (const surface of plan.oldSurfaces) propsByInstance.set(surface.instance, surface.props);
+		for (const surface of plan.newSurfaces) propsByInstance.set(surface.instance, surface.props);
+		for (const [instance, props] of propsByInstance) viewTransitionHost.restore(instance, props);
+	}
+	function commitRoot(root, finishedWork) {
+		if (!root.pendingViewTransitionCommit && isViewTransitionEligibleCommit(root) && viewTransitionHost?.suspend?.(root.container, () => scheduleRoot(root)) === true) {
+			root.parkedViewTransitionCommit = true;
+			root.callback = null;
+			root.callbackPriority = 0;
+			return true;
+		}
+		commitDepth += 1;
+		try {
+			let suspenseRetries = noSuspenseRetries;
+			if (root.pendingSuspenseRetries.length > 0) {
+				suspenseRetries = root.pendingSuspenseRetries;
+				root.pendingSuspenseRetries = [];
+			}
+			commitLiveHookInstances(root);
+			if (hasHiddenBoundaries) armRevealedHiddenBoundaries(finishedWork.child);
+			commitEffects(root, finishedWork.child, 2);
+			const viewTransitionPlan = prepareViewTransitionPlan(root, finishedWork);
+			const commitHostChanges = () => {
+				if (root.clearContainerBeforeCommit) {
+					requireHydrationHostConfig().clearContainer(root.container);
+					root.clearContainerBeforeCommit = false;
+				}
+				if (root.needsCommitDeletions) {
+					commitDeletions(root);
+					root.needsCommitDeletions = false;
+				}
+				commitDataDependencies(root);
+				commitHostUpdates(root);
+				commitMutationEffects(finishedWork.child);
+				if (hasHiddenBoundaries) commitHiddenBoundaryVisibility(finishedWork.child);
+			};
+			const completeCommit = () => {
+				hasHiddenBoundaries = hiddenStates.size > 0;
+				root.current = finishedWork;
+				deactivateHydration(root);
+				root.hydrationInitialElement = NoHydrationInitialElement;
+				root.consumedPendingQueues = [];
+				markRootFinished(root, root.pendingLanes & ~root.renderLanes | finishedWork.lanes | finishedWork.childLanes);
+				if (includesSomeLane(finishedWork.childLanes, 536870912)) {
+					markRootPending(root, OffscreenLane);
+					root.suspendedLanes &= -536870913;
+				}
+				try {
+					commitExternalStores(root);
+					attachCommittedSuspenseRetries(root, suspenseRetries);
+					scheduleDehydratedSuspenseRetries(root);
+					commitEffects(root, finishedWork.child, 1);
+					flushCaughtBoundaryErrors(root);
+				} finally {
+					collectReactiveEffects(root, finishedWork.child);
+					clearTransientFlags(finishedWork);
+					scheduleReactiveEffects(root);
+					clearCommitIndex(root.commitIndex);
+				}
+				flushRecoverableErrors(root);
+				requestPaint();
+			};
+			const commitWithoutViewTransition = () => {
+				commitHostChanges();
+				completeCommit();
+			};
+			const commitWithViewTransition = () => {
+				const isDeferredCommit = root.pendingViewTransitionCommit;
+				if (isDeferredCommit) commitDepth += 1;
+				try {
+					commitHostChanges();
+					const resolution = resolveViewTransitionPlan(viewTransitionPlan);
+					completeCommit();
+					return resolution;
+				} catch (error) {
+					if (!isDeferredCommit) throw error;
+					const info = root.uncaughtErrorInfo ?? errorInfoFor(root.current, error);
+					restartRootWork(root);
+					clearRootAfterUncaughtError(root);
+					reportUncaughtError(root, error, info);
+					if (root.onUncaughtError === null) setTimeout(() => {
+						throw error;
+					});
+					return {
+						canceledNames: [],
+						cancelRootSnapshot: false
+					};
+				} finally {
+					if (isDeferredCommit) {
+						root.pendingViewTransitionCommit = false;
+						commitDepth -= 1;
+						finishRootWork(root);
+						flushPostCommitSyncWork();
+					}
+				}
+			};
+			if (viewTransitionPlan !== null && viewTransitionHost !== null) {
+				const viewTransitionResult = viewTransitionHost.commit(root.container, () => applyOldViewTransitionSurfaces(viewTransitionPlan), commitWithViewTransition, () => restoreViewTransitionSurfaces(viewTransitionPlan));
+				if (viewTransitionResult === "deferred") {
+					root.pendingViewTransitionCommit = true;
+					root.callback = null;
+					root.callbackPriority = 0;
+					return true;
+				}
+				if (viewTransitionResult === "committed") return false;
+			}
+			commitWithoutViewTransition();
+			return false;
+		} finally {
+			commitDepth -= 1;
+		}
+	}
+	function scheduleDehydratedSuspenseRetries(root) {
+		if (!root.isHydrationRoot && root.dehydratedSuspenseCount === 0 && !root.needsRootHydrationCompletion) {
+			root.dehydratedBoundaries = /* @__PURE__ */ new Map();
+			return;
+		}
+		const boundaries = [];
+		root.dehydratedBoundaries = /* @__PURE__ */ new Map();
+		updateDehydratedSuspenseCount(root, collectDehydratedSuspense(root.current.child, boundaries, root.dehydratedBoundaries));
+		if (boundaries.length === 0) return;
+		queueMicrotask(() => {
+			for (const boundary of boundaries) {
+				const state = fiberSuspenseState(boundary);
+				if (state?.kind !== "dehydrated") continue;
+				const lane = dehydratedSuspenseRetryLane(state.boundary);
+				if (lane !== 0) scheduleFiber(boundary, lane);
+			}
+		});
+	}
+	function collectDehydratedSuspense(node, boundaries, byStartMarker) {
+		let count = 0;
+		walkFiberForest(node, (cursor) => {
+			const state = fiberSuspenseState(cursor);
+			if (state?.kind === "dehydrated") {
+				count += 1;
+				byStartMarker.set(state.boundary.start, cursor);
+				if (!abandonedHydrationBoundaries.has(cursor) && dehydratedSuspenseRetryLane(state.boundary) !== 0) boundaries.push(cursor);
+				return false;
+			}
+			return true;
+		});
+		return count;
+	}
+	function updateDehydratedSuspenseCount(root, count) {
+		const previous = root.dehydratedSuspenseCount;
+		root.dehydratedSuspenseCount = count;
+		if ((previous > 0 || root.needsRootHydrationCompletion) && count === 0) {
+			root.needsRootHydrationCompletion = false;
+			host.completeRootHydration?.(root.container);
+		}
+	}
+	function dehydratedSuspenseRetryLane(boundary) {
+		if (boundary.forceClientRender) return 32;
+		if (boundary.status === "completed") return 16;
+		if (boundary.status === "client-rendered") return 32;
+		return 0;
+	}
+	function flushRecoverableErrors(root) {
+		const errors = root.recoverableErrors;
+		if (errors.length === 0) return;
+		root.recoverableErrors = [];
+		for (const { error, info } of errors) try {
+			root.onRecoverableError(error, info);
+		} catch {}
+	}
+	function flushCaughtBoundaryErrors(root) {
+		if (root.committedCaughtErrors.length > 0) {
+			const boundaries = root.committedCaughtErrors;
+			root.committedCaughtErrors = [];
+			for (const boundary of boundaries) flushCaughtBoundaryError(root, boundary);
+		}
+		for (const boundary of root.commitIndex) flushCaughtBoundaryError(root, boundary);
+	}
+	function flushCaughtBoundaryError(root, node) {
+		const state = fiberErrorBoundaryState(node);
+		if (state === null || state.didReport) return;
+		state.didReport = true;
+		if (node.alternate !== null) node.alternate.boundaryState = state;
+		const onError = node.props.onError;
+		if (typeof onError !== "function") return;
+		try {
+			onError(state.error, state.info);
+		} catch (error) {
+			reportUncaughtError(root, error, errorInfoFor(node, error));
+		}
+	}
+	function reportUncaughtError(root, error, info) {
+		try {
+			root.onUncaughtError?.(error, info);
+		} catch {}
+	}
+	function clearRootAfterUncaughtError(root) {
+		root.reactiveCallback?.cancel();
+		root.reactiveCallback = null;
+		root.pendingReactiveEffects = [];
+		root.element = null;
+		if (root.current.child !== null) {
+			deleteFiberDataTree(root.current.child);
+			abortFiberEffects(root.current);
+		}
+		if (host.clearContainer !== void 0) {
+			removePortalDescendants(root.current.child);
+			host.clearContainer(root.container);
+		} else if (root.current.child !== null) {
+			let child = root.current.child;
+			while (child !== null) {
+				const next = child.sibling;
+				remove(child, root.container);
+				child = next;
+			}
+		}
+		const current = fiber(0, null, null, { children: null }, root);
+		current.memoizedProps = current.props;
+		current.committedProps = current.props;
+		root.current = current;
+		resetRootWork(root);
+		root.clearContainerBeforeCommit = false;
+		root.hydrationInitialElement = NoHydrationInitialElement;
+		root.consumedPendingQueues = [];
+		root.commitEffectPhases = 0;
+		root.needsCommitDeletions = false;
+		root.committedCaughtErrors.length = 0;
+		markRootFinished(root, 0);
+		pendingRoots.delete(root);
+	}
+	function commitMutationEffects(node, hidden = false) {
+		let cursor = node;
+		while (cursor !== null) {
+			const subtreeMutation = (cursor.subtreeFlags & 47) !== 0;
+			if ((cursor.flags & 47) === 0 && !subtreeMutation) {
+				cursor = cursor.sibling;
+				continue;
+			}
+			if ((cursor.flags & 1) !== 0) {
+				cursor = commitPlacementRun(cursor, hidden);
+				continue;
+			}
+			if (cursor.tag === 8) commitPortal(cursor);
+			if (cursor.tag === 10 && (cursor.flags & 4) !== 0) commitHydratedActivityBoundary(cursor);
+			if ((cursor.flags & 4) !== 0 && (cursor.flags & 10) !== 0 && isHost(cursor)) {
+				const hostFiber = cursor;
+				commitHostMutation(hostFiber, () => commitUpdate(hostFiber));
+				if (hidden) hideHostFiber(hostFiber);
+			}
+			if ((cursor.flags & 16) === 0 && subtreeMutation) commitMutationEffects(cursor.child, hidden || isHiddenBoundary(cursor));
+			if (cursor.tag === 6 && (cursor.flags & 4) !== 0) commitHydratedSuspenseBoundary(cursor);
+			cursor = cursor.sibling;
+		}
+	}
+	function commitPlacementRun(firstPlaced, hidden) {
+		const lastPlaced = placementRunTail(firstPlaced);
+		const afterPlaced = lastPlaced.sibling;
+		const before = hostSibling(lastPlaced);
+		for (let placed = firstPlaced; placed !== afterPlaced;) {
+			if (placed === null) break;
+			const current = placed;
+			const next = current.sibling;
+			const placedHidden = hidden || isHiddenBoundary(current);
+			if (placedHidden) hidePlacedNode(current);
+			if (hasHiddenBoundaries && isPreassembledHostSubtree(current)) hideNestedBoundaryContent(current.child);
+			commitHostMutation(current, () => commitPlacement(current, before));
+			if (placedHidden) hidePlacedNode(current);
+			if (!isPreassembledHostSubtree(current)) commitMutationEffects(current.child, placedHidden);
+			else commitPortalsInPreassembledSubtree(current.child, placedHidden);
+			placed = next;
+		}
+		return afterPlaced;
+	}
+	function hidePlacedNode(node) {
+		if (isHiddenBoundary(node)) setSubtreeVisibility(node.child, true);
+		else setNodeVisibility(node, true);
+	}
+	function hideNestedBoundaryContent(node) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if (isHiddenBoundary(cursor)) setSubtreeVisibility(cursor.child, true);
+			hideNestedBoundaryContent(cursor.child);
+		}
+	}
+	function commitPortalsInPreassembledSubtree(node, hidden) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			const cursorHidden = hidden || isHiddenBoundary(cursor);
+			if (cursor.tag === 8) {
+				if (cursorHidden) setSubtreeVisibility(cursor.child, true);
+				if (hasHiddenBoundaries) hideNestedBoundaryContent(cursor.child);
+				commitHostMutation(cursor, () => commitPlacement(cursor));
+				if (cursorHidden) setNodeVisibility(cursor, true);
+				commitMutationEffects(cursor.child, cursorHidden);
+			} else commitPortalsInPreassembledSubtree(cursor.child, cursorHidden);
+		}
+	}
+	function commitHostMutation(source, mutation) {
+		try {
+			mutation();
+		} catch (error) {
+			rootOf(source).uncaughtErrorInfo = errorInfoFor(source, error);
+			throw error;
+		}
+	}
+	function isPreassembledHostSubtree(node) {
+		return (node.flags & 64) !== 0;
+	}
+	function placementRunTail(node) {
+		let tail = node;
+		while (tail.sibling !== null && (tail.sibling.flags & 1) !== 0) tail = tail.sibling;
+		return tail;
+	}
+	function commitPlacement(node, before = hostSibling(node)) {
+		if (isHost(node)) {
+			if (node.tag === 1 && isHoistedFiber(node)) {
+				if (node.committedProps === null) acquireHoistedInstance(node);
+				markHostCommitted(node);
+				markHostSubtreeCommitted(node.child);
+				return;
+			}
+			if (shouldCommitPlacementUpdate(node)) commitUpdate(node);
+			host.insertBefore(hostParent(node), hostNode(node), before);
+			markHostCommitted(node);
+			if (isPreassembledHostSubtree(node)) markHostSubtreeCommitted(node.child);
+		} else if (node.tag === 8) {
+			commitPortal(node);
+			if (node.alternate !== null) insertPortalChildren(node);
+		} else if (node.alternate !== null) insertHostSubtree(node, hostParent(node), before);
+	}
+	function commitPortal(node) {
+		host.preparePortalContainer?.(portalTarget(node), rootOf(node).container, hostParent(node));
+	}
+	function shouldCommitPlacementUpdate(node) {
+		if ((node.flags & 10) !== 0) return true;
+		if (node.alternate !== null || node.tag === 2) return false;
+		return host.finalizeInitialInstance === void 0;
+	}
+	function insertHostSubtree(node, parent, before) {
+		visitHostNodes(node, (child) => host.insertBefore(parent, child, before));
+	}
+	function insertPortalChildren(node) {
+		const parent = portalTarget(node);
+		for (let child = node.child; child !== null; child = child.sibling) visitHostNodes(child, (hostChild) => host.insertBefore(parent, hostChild, null));
+	}
+	function commitUpdate(node) {
+		if (node.tag === 2) host.commitTextUpdate(node.stateNode, String(node.props.nodeValue));
+		else if (node.tag === 1 && isHoistedFiber(node)) commitHoistedUpdate(node);
+		else if ((node.flags & 4) !== 0 && host.commitHydratedInstance !== void 0) host.commitHydratedInstance(node.stateNode, node.props);
+		else {
+			const previousProps = previousCommittedProps(node);
+			if ((node.flags & 2) !== 0) host.commitUpdate(node.stateNode, previousProps, node.props);
+			if ((node.flags & 8) !== 0) commitHostTextContent(node, previousProps);
+		}
+		markHostCommitted(node);
+	}
+	function commitHoistedUpdate(node) {
+		const hoistedHost = requireHoistedAssetHostConfig();
+		const previousProps = previousCommittedProps(node);
+		const instance = node.stateNode;
+		const next = hoistedHost.updateHoistedInstance(instance, previousProps, node.props) ?? instance;
+		if (next !== instance) {
+			adoptSwappedHoistedInstance(node, next);
+			return;
+		}
+		if ((node.flags & 8) !== 0) commitHostTextContent(node, previousProps);
+	}
+	function adoptSwappedHoistedInstance(node, next) {
+		node.stateNode = next;
+		if (node.alternate !== null) node.alternate.stateNode = next;
+		const text = hostTextContent(node.props.children);
+		if (text !== null) host.setTextContent?.(next, text);
+	}
+	function commitHydratedSuspenseBoundary(node) {
+		const boundary = dehydratedSuspenseBoundary(node.alternate);
+		if (boundary === null) return;
+		host.commitHydratedSuspenseBoundary?.(boundary);
+	}
+	function commitHydratedActivityBoundary(node) {
+		const state = fiberActivityState(node);
+		if (state?.dehydrated == null) return;
+		requireActivityHydrationHostConfig().commitHydratedActivityBoundary(state.dehydrated);
+		state.dehydrated = null;
+	}
+	function commitHostTextContent(node, previousProps) {
+		if (host.setTextContent === void 0 || node.tag !== 1) return;
+		const nextText = hostTextContent(node.props.children);
+		if (nextText !== null) host.setTextContent(node.stateNode, nextText);
+		else if (hostTextContent(previousProps.children) !== null) host.setTextContent(node.stateNode, "");
+	}
+	function previousCommittedProps(node) {
+		return node.committedProps ?? node.alternate?.committedProps ?? node.alternate?.memoizedProps ?? {};
+	}
+	function markHostCommitted(node) {
+		if (!isHost(node)) return;
+		node.committedProps = node.props;
+		if (node.alternate !== null) node.alternate.committedProps = node.props;
+	}
+	function markHostSubtreeCommitted(node) {
+		walkFiberForest(node, (child) => {
+			if (child.committedProps === null && isHoistedFiber(child)) acquireHoistedInstance(child);
+			markHostCommitted(child);
+		});
+	}
+	function acquireHoistedInstance(node) {
+		const hoistedHost = requireHoistedAssetHostConfig();
+		const instance = node.stateNode;
+		const resolved = hoistedHost.commitHoistedInstance(instance) ?? instance;
+		if (resolved === instance) return;
+		adoptSwappedHoistedInstance(node, resolved);
+	}
+	function commitHostUpdates(root) {
+		for (const cursor of root.commitIndex) {
+			if ((cursor.flags & 10) === 0 || !isHost(cursor)) continue;
+			if ((cursor.flags & 5) !== 0) continue;
+			if (cursor.committedProps === null && cursor.tag !== 2) continue;
+			commitHostMutation(cursor, () => commitUpdate(cursor));
+			if (hasHiddenBoundaries && isInsideHiddenBoundary(cursor)) hideHostFiber(cursor);
+			cursor.flags &= -11;
+		}
+	}
+	function commitDeletions(root) {
+		const store = root.dataStore;
+		for (const cursor of root.commitIndex) {
+			if (cursor.deletions === null) continue;
+			const parent = isHostParent(cursor) ? hostParentFor(cursor) : hostParent(cursor);
+			for (const child of cursor.deletions) {
+				walkFiberSubtree(child, (deleted) => {
+					deleteFiberDataOwner(deleted, store);
+					abortFiberHooks(deleted, false);
+				});
+				child.return = null;
+				if (child.alternate !== null) child.alternate.return = null;
+				remove(child, parent);
+			}
+			cursor.deletions = null;
+		}
+	}
+	function commitDataDependencies(root) {
+		for (const cursor of root.commitIndex) {
+			if (!cursor.dataDependenciesDirty) continue;
+			root.dataStore.commitDataDependencies(cursor, cursor.alternate);
+			cursor.dataDependenciesDirty = false;
+			if (cursor.alternate !== null) cursor.alternate.dataDependenciesDirty = false;
+		}
+	}
+	function deleteFiberDataTree(node) {
+		const store = rootOf(node).dataStore;
+		walkFiberForest(node, (cursor) => {
+			deleteFiberDataOwner(cursor, store);
+		});
+	}
+	function deleteFiberDataOwner(node, store) {
+		store.releaseDataOwner(node);
+		if (node.alternate !== null) store.releaseDataOwner(node.alternate);
+		const state = fiberActivityState(node);
+		if (state !== null) hiddenStates.delete(state);
+	}
+	function dehydratedActivityBoundary(node) {
+		return node.tag === 10 ? fiberActivityState(node)?.dehydrated ?? null : null;
+	}
+	function remove(node, parent) {
+		const dehydratedActivity = dehydratedActivityBoundary(node);
+		if (dehydratedActivity !== null) {
+			host.removeChild(parent, dehydratedActivity);
+			return;
+		}
+		const boundary = dehydratedSuspenseBoundary(node);
+		if (boundary !== null && host.removeDehydratedSuspenseBoundary !== void 0) {
+			host.removeDehydratedSuspenseBoundary(boundary);
+			return;
+		}
+		if (node.tag === 8) {
+			removePortalChildren(node);
+			host.removePortalContainer?.(portalTarget(node));
+			return;
+		}
+		if (node.tag === 1 && isHoistedFiber(node)) {
+			if (node.committedProps !== null) requireHoistedAssetHostConfig().removeHoistedInstance(node.stateNode);
+			return;
+		}
+		if (isHost(node)) {
+			removePortalDescendants(node.child);
+			removeHoistedDescendants(node.child);
+			host.removeChild(parent, hostNode(node));
+			return;
+		}
+		for (let child = node.child; child !== null; child = child.sibling) remove(child, parent);
+	}
+	function removeHoistedDescendants(node) {
+		if (host.isHoistedInstance === void 0) return;
+		for (let child = node; child !== null; child = child.sibling) {
+			if (child.tag === 8) continue;
+			if (child.tag === 1 && isHoistedFiber(child)) {
+				if (child.committedProps !== null && child.stateNode !== null) requireHoistedAssetHostConfig().removeHoistedInstance(child.stateNode);
+				continue;
+			}
+			removeHoistedDescendants(child.child);
+		}
+	}
+	function removePortalChildren(node) {
+		const parent = portalTarget(node);
+		for (let child = node.child; child !== null; child = child.sibling) remove(child, parent);
+	}
+	function removePortalDescendants(node) {
+		for (let child = node; child !== null; child = child.sibling) if (child.tag === 8) {
+			removePortalChildren(child);
+			host.removePortalContainer?.(portalTarget(child));
+		} else removePortalDescendants(child.child);
+	}
+	function visitHostNodes(node, visitor) {
+		if (isHost(node)) {
+			if (node.tag === 1 && isHoistedFiber(node)) return;
+			visitor(hostNode(node));
+			return;
+		}
+		if (node.tag === 8) return;
+		for (let child = node.child; child !== null; child = child.sibling) visitHostNodes(child, visitor);
+	}
+	function hostParent(node) {
+		for (let parent = node.return; parent !== null; parent = parent.return) if (isHostParent(parent)) return hostParentFor(parent);
+		throw new Error("Could not find a host parent for fiber.");
+	}
+	function hostSibling(node) {
+		const dehydratedBoundary = dehydratedSuspenseParent(node);
+		if (dehydratedBoundary !== null) return dehydratedBoundary.start;
+		let cursor = node;
+		search: while (true) {
+			while (cursor.sibling === null) {
+				if (cursor.return === null || isHostParent(cursor.return)) return null;
+				cursor = cursor.return;
+			}
+			cursor = cursor.sibling;
+			while (!isHost(cursor)) {
+				const dehydratedActivity = dehydratedActivityBoundary(cursor);
+				if (dehydratedActivity !== null) return dehydratedActivity;
+				if (cursor.tag === 8 || (cursor.flags & 1) !== 0 || cursor.child === null) continue search;
+				cursor = cursor.child;
+			}
+			if ((cursor.flags & 1) === 0 && !isHoistedFiber(cursor)) return hostNode(cursor);
+		}
+	}
+	function dehydratedSuspenseParent(node) {
+		for (let parent = node.return; parent !== null; parent = parent.return) {
+			if ((parent.flags & 4) !== 0) {
+				const boundary = dehydratedSuspenseBoundary(parent.alternate);
+				if (boundary !== null && (boundary.status !== "completed" || boundary.forceClientRender)) return boundary;
+			}
+			if (isHostParent(parent)) return null;
+		}
+		return null;
+	}
+	function isHostParent(node) {
+		return node.tag === 0 || node.tag === 1 || node.tag === 8;
+	}
+	function hostParentFor(node) {
+		if (node.tag === 0) return node.stateNode.container;
+		if (node.tag === 1) return node.stateNode;
+		return portalTarget(node);
+	}
+	function dehydratedSuspenseBoundary(node) {
+		const state = fiberSuspenseState(node);
+		return state?.kind === "dehydrated" ? state.boundary : null;
+	}
+	function fiberSuspenseState(node) {
+		return node?.tag === 6 ? node.boundaryState : null;
+	}
+	function fiberErrorBoundaryState(node) {
+		return node?.tag === 7 ? node.boundaryState : null;
+	}
+	function fiberActivityState(node) {
+		return node?.tag === 10 ? node.boundaryState : null;
+	}
+	function ensureFiberActivityState(node) {
+		const current = fiberActivityState(node);
+		if (current !== null) return current;
+		const state = {
+			hidden: false,
+			dehydrated: null
+		};
+		node.boundaryState = state;
+		return state;
+	}
+	function scheduleFiber(node, lane) {
+		markLanes(node, lane);
+		const root = scheduleParentPath(node.return, lane);
+		const alternateRoot = scheduleParentPath(node.alternate?.return ?? null, lane);
+		const scheduledRoot = root ?? alternateRoot;
+		if (scheduledRoot === null) return;
+		markRootPending(scheduledRoot, lane);
+		scheduleOrBatchRoot(scheduledRoot);
+	}
+	function scheduleParentPath(parent, lane) {
+		for (; parent !== null; parent = parent.return) {
+			markChildLanes(parent, lane);
+			if (parent.tag === 0) return parent.stateNode;
+		}
+		return null;
+	}
+	function attachPing(root, thenable, lanes) {
+		if (lanes === 0) return;
+		const previousLanes = root.suspendedThenables.get(thenable) ?? 0;
+		root.suspendedThenables.set(thenable, mergeLanes(previousLanes, lanes));
+		if (previousLanes !== 0) return;
+		thenable.then(() => ping(root, thenable), () => ping(root, thenable));
+	}
+	function ping(root, thenable) {
+		const lanes = root.suspendedThenables.get(thenable) ?? 0;
+		if (lanes === 0) return;
+		root.suspendedThenables.delete(thenable);
+		markRootPinged(root, lanes);
+		pendingRoots.add(root);
+		scheduleRoot(root);
+	}
+	function findSuspenseBoundary(node) {
+		for (let parent = node.return; parent !== null; parent = parent.return) if (parent.tag === 6 && fiberSuspenseState(parent) === null) return parent;
+		return null;
+	}
+	function findErrorBoundary(node) {
+		for (let parent = node.return; parent !== null; parent = parent.return) if (parent.tag === 7 && fiberErrorBoundaryState(parent) === null) return parent;
+		return null;
+	}
+	function captureSuspenseBoundary(boundary, thenable) {
+		const root = rootOf(boundary);
+		const lanes = root.renderLanes;
+		attachPing(root, thenable, lanes);
+		root.pendingSuspenseRetries.push({
+			boundary,
+			thenable,
+			lanes
+		});
+		rollbackCommitIndex(root.commitIndex, boundary.commitIndexCheckpoint);
+		if (boundary.deletions !== null) recordCommitWork(root.commitIndex, boundary);
+		const dehydrated = fiberSuspenseState(boundary.alternate);
+		if (root.hydratingSuspenseBoundary === boundary && dehydrated?.kind === "dehydrated") {
+			leaveSuspenseHydration(root, boundary, dehydrated.boundary);
+			boundary.boundaryState = dehydrated;
+			boundary.flags &= -5;
+			boundary.child = null;
+			abandonedHydrationBoundaries.add(boundary);
+			if (boundary.alternate !== null) abandonedHydrationBoundaries.add(boundary.alternate);
+			return completeUnit(boundary);
+		}
+		if (shouldPreserveSuspenseBoundary(root, boundary)) {
+			markRootSuspended(root, lanes);
+			throw PreservedSuspense;
+		}
+		const currentPrimary = suspensePrimaryFiber(boundary.alternate);
+		if (currentPrimary !== null) {
+			boundary.boundaryState = {
+				kind: "fallback",
+				primaryChild: null
+			};
+			boundary.deletions = null;
+			restoreConsumedPendingQueuesForRetry(root, boundary.suspenseQueueStart ?? root.consumedPendingQueues.length);
+			hasHiddenBoundaries = true;
+			const primary = suspensePrimaryWorkInProgress(boundary, currentPrimary, "hidden");
+			primary.child = cloneSuspendedPrimary(currentPrimary.child, primary);
+			primary.flags |= 32;
+			primary.memoizedProps = primary.props;
+			primary.lanes = 0;
+			primary.childLanes = 0;
+			boundary.child = primary;
+			const fallback = suspenseFallbackWorkInProgress(boundary, currentPrimary.sibling, 1);
+			primary.sibling = fallback;
+			return fallback;
+		}
+		boundary.boundaryState = {
+			kind: "fallback",
+			primaryChild: boundary.child?.tag === 10 && boundary.child.type === null ? boundary.child.child : boundary.child
+		};
+		const fallback = suspenseFallbackWorkInProgress(boundary, null, 0);
+		boundary.child = fallback;
+		return fallback;
+	}
+	function captureErrorBoundary(boundary, error, source) {
+		const root = rootOf(boundary);
+		rollbackCommitIndex(root.commitIndex, boundary.commitIndexCheckpoint);
+		recordCommitWork(root.commitIndex, boundary);
+		const state = createErrorBoundaryState(error, source);
+		boundary.boundaryState = state;
+		reconcileCurrentChildren(boundary, errorBoundaryFallback(boundary, state));
+		return boundary.child ?? completeUnit(boundary);
+	}
+	function captureCommittedErrorBoundary(boundary, error, source) {
+		rootOf(boundary).committedCaughtErrors.push(boundary);
+		const state = createErrorBoundaryState(error, source);
+		boundary.boundaryState = state;
+		if (boundary.alternate !== null) boundary.alternate.boundaryState = state;
+	}
+	function createErrorBoundaryState(error, source) {
+		return {
+			error,
+			info: errorInfoFor(source, error),
+			didReport: false
+		};
+	}
+	function shouldPreserveSuspenseBoundary(root, boundary) {
+		return boundary.alternate !== null && fiberSuspenseState(boundary.alternate) === null && isTransitionOrDeferredRender(root);
+	}
+	function attachCommittedSuspenseRetries(root, retries) {
+		for (const { boundary, thenable, lanes } of retries) {
+			let attached = root.attachedSuspenseRetries.get(thenable);
+			if (attached === void 0) {
+				attached = /* @__PURE__ */ new WeakSet();
+				root.attachedSuspenseRetries.set(thenable, attached);
+			}
+			if (attached.has(boundary) || boundary.alternate !== null && attached.has(boundary.alternate)) continue;
+			attached.add(boundary);
+			const retry = () => scheduleFiber(boundary, suspenseRetryLane(lanes));
+			thenable.then(retry, retry);
+		}
+	}
+	function lazilyPropagateParentContextChanges(node, root) {
+		if ((node.flags & 1024) !== 0) return false;
+		const contexts = changedParentContexts(node);
+		node.flags |= ContextPropagationFlag;
+		if (contexts === null) return false;
+		const current = node.alternate;
+		if (current === null) return false;
+		for (const context of contexts) {
+			if (!contextListIncludes(current.contextSubtreeDependencies, context)) continue;
+			for (let child = current.child; child !== null; child = child.sibling) markContextConsumers(child, current, context, root.renderLanes);
+		}
+		return includesSomeLane(node.childLanes, root.renderLanes);
+	}
+	function changedParentContexts(node) {
+		let seen = node.tag === 5 ? [node.type] : null;
+		let changed = null;
+		for (let parent = node.return; parent !== null; parent = parent.return) {
+			if ((parent.flags & 1024) !== 0) break;
+			if (parent.tag !== 5) continue;
+			const context = parent.type;
+			if (contextListIncludes(seen, context)) continue;
+			seen = appendContext(seen, context);
+			if (changedContextProvider(parent)) changed = appendContext(changed, context);
+		}
+		return changed;
+	}
+	function markContextConsumers(node, propagationRoot, context, lanes) {
+		if (node.tag === 5 && node.type === context) return;
+		if (contextDependency(node, context) !== null) {
+			markLanes(node, lanes);
+			markParentPath(node, propagationRoot, lanes);
+		}
+		if (!contextListIncludes(node.contextSubtreeDependencies, context)) return;
+		for (let child = node.child; child !== null; child = child.sibling) markContextConsumers(child, propagationRoot, context, lanes);
+	}
+	function markParentPath(node, stopAt, lanes) {
+		for (let parent = node.return; parent !== null && parent !== stopAt; parent = parent.return) markChildLanes(parent, lanes);
+		markChildLanes(stopAt, lanes);
+	}
+	function markLanes(node, lane) {
+		node.lanes = mergeLanes(node.lanes, lane);
+		if (node.alternate !== null) node.alternate.lanes = mergeLanes(node.alternate.lanes, lane);
+	}
+	function markChildLanes(node, lane) {
+		node.childLanes = mergeLanes(node.childLanes, lane);
+		if (node.alternate !== null) node.alternate.childLanes = mergeLanes(node.alternate.childLanes, lane);
+	}
+	function markSubtreeFlag(node, flag) {
+		for (let parent = node.return; parent !== null; parent = parent.return) parent.subtreeFlags |= flag;
+	}
+	function createWorkInProgress(current, props) {
+		const next = current.alternate ?? fiber(current.tag, current.type, current.key, props, current.stateNode);
+		next.props = props;
+		next.memoizedProps = current.memoizedProps;
+		next.committedProps = current.committedProps;
+		next.memoizedState = current.memoizedState;
+		next.stateNode = current.stateNode;
+		next.return = current.return;
+		next.child = null;
+		next.sibling = null;
+		next.index = current.index;
+		next.flags = 0;
+		next.subtreeFlags = 0;
+		next.deletions = null;
+		next.lanes = current.lanes;
+		next.childLanes = current.childLanes;
+		next.effects = null;
+		next.contextDependencies = current.contextDependencies;
+		next.contextSubtreeDependencies = current.contextSubtreeDependencies;
+		next.dataDependenciesDirty = false;
+		next.boundaryState = current.boundaryState;
+		next.hiddenState = null;
+		next.alternate = current;
+		current.alternate = next;
+		return next;
+	}
+	function cloneChildFibers(parent) {
+		let current = parent.alternate?.child ?? null;
+		let previous = null;
+		parent.child = null;
+		parent.deletions = null;
+		while (current !== null) {
+			const next = createWorkInProgress(current, current.props);
+			next.return = parent;
+			previous = appendChild(parent, previous, next);
+			current = current.sibling;
+		}
+	}
+	function appendChild(parent, previous, child) {
+		if (previous === null) parent.child = child;
+		else previous.sibling = child;
+		return child;
+	}
+	function fiberFrom(child) {
+		if (typeof child === "string") return fiber(2, null, null, { nodeValue: child }, null);
+		if (isPortal(child)) return fiber(8, null, child.key, portalProps(child), null);
+		if (!isValidElement(child)) return null;
+		return fiber(tagFor(child), child.type, child.key, child.props, null);
+	}
+	function portalTarget(node) {
+		return node.props.target;
+	}
+	function fiber(tag, type, key, props, stateNode) {
+		return {
+			tag,
+			type,
+			key,
+			props,
+			memoizedProps: null,
+			committedProps: null,
+			memoizedState: null,
+			stateNode,
+			return: null,
+			child: null,
+			sibling: null,
+			index: 0,
+			alternate: null,
+			flags: 0,
+			subtreeFlags: 0,
+			deletions: null,
+			lanes: 0,
+			childLanes: 0,
+			effects: null,
+			contextDependencies: null,
+			contextSubtreeDependencies: null,
+			dataDependenciesDirty: false,
+			boundaryState: null,
+			hiddenState: null
+		};
+	}
+	function rootOf(node) {
+		const root = rootOfOrNull(node);
+		if (root === null) throw new Error("Could not find a root for fiber.");
+		return root;
+	}
+	function rootOfOrNull(node) {
+		for (let parent = node; parent !== null; parent = parent.return) if (parent.tag === 0) return parent.stateNode;
+		return null;
+	}
+	function errorInfoFor(node, error) {
+		const dataResourceKeys = error === void 0 ? void 0 : dataResourceKeysForError(error);
+		return dataResourceKeys === void 0 ? { componentStack: componentStackFor(node) } : {
+			componentStack: componentStackFor(node),
+			dataResourceKeys
+		};
+	}
+	function queueRecoverableError(root, node, error, details) {
+		root.recoverableErrors.push({
+			error,
+			info: {
+				...details,
+				componentStack: componentStackFor(node)
+			}
+		});
+	}
+	function componentStackFor(node) {
+		const frames = [];
+		for (let fiber = node; fiber !== null; fiber = fiber.return) {
+			const name = componentStackName(fiber);
+			if (name !== null) frames.push(`    at ${name}`);
+		}
+		return frames.length === 0 ? "" : `\n${frames.join("\n")}`;
+	}
+	function componentStackName(node) {
+		switch (node.tag) {
+			case 3: return devtoolsTypeName(node.type, "Anonymous");
+			case 5: return `${devtoolsTypeName(node.type, "Context")}.Provider`;
+			case 6: return "Suspense";
+			case 7: return "ErrorBoundary";
+			case 11: return "ViewTransition";
+			case 8: return "Portal";
+			case 9: return "Assets";
+			default: return null;
+		}
+	}
+	return {
+		batchedUpdates,
+		createRoot,
+		hydrateRoot,
+		hydrateTarget,
+		flushSync,
+		scheduleRefresh
+	};
+	function scheduleRefresh(update) {}
+	function findDehydratedSuspenseBoundaryForTarget(node, target) {
+		if (node === null || host.isTargetWithinSuspenseBoundary === void 0) return null;
+		const state = fiberSuspenseState(node);
+		if (state?.kind === "dehydrated" && host.isTargetWithinSuspenseBoundary(target, state.boundary)) return node;
+		return findDehydratedSuspenseBoundaryForTarget(node.child, target) ?? findDehydratedSuspenseBoundaryForTarget(node.sibling, target);
+	}
+	function isHiddenBoundary(node) {
+		return isHiddenBoundaryTag(node) && activityHidden(node.props);
+	}
+	function isHiddenBoundaryTag(node) {
+		return node.tag === 10;
+	}
+	function requireActivityHostConfig() {
+		if (activityHostConfig !== null) return activityHostConfig;
+		if (host.hideInstance === void 0 || host.unhideInstance === void 0 || host.hideTextInstance === void 0 || host.unhideTextInstance === void 0) throw new Error("Activity is not supported by this renderer.");
+		activityHostConfig = host;
+		return activityHostConfig;
+	}
+	function commitHiddenBoundaryVisibility(node, hidden = false) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if ((cursor.flags & 16) !== 0) continue;
+			const subtreeVisibility = (cursor.subtreeFlags & 32) !== 0;
+			if ((cursor.flags & 32) === 0 && !subtreeVisibility) continue;
+			const boundary = isHiddenBoundaryTag(cursor);
+			const boundaryHidden = boundary && activityHidden(cursor.props);
+			if (boundary && (cursor.flags & 32) !== 0) {
+				const effectiveHidden = hidden || boundaryHidden;
+				const state = fiberActivityState(cursor);
+				if (state !== null) {
+					state.hidden = effectiveHidden;
+					if (effectiveHidden) hiddenStates.add(state);
+					else hiddenStates.delete(state);
+				}
+				setSubtreeVisibility(cursor.child, effectiveHidden);
+				if (effectiveHidden && cursor.child !== null) abortFiberEffects(cursor.child, true);
+				if (!effectiveHidden && includesSomeLane(cursor.childLanes, 536870912)) {
+					const root = rootOf(cursor);
+					markRootPending(root, 32);
+					markRootEntangled(root, 536870944);
+					scheduleOrBatchRoot(root);
+				}
+			}
+			if (subtreeVisibility) commitHiddenBoundaryVisibility(cursor.child, hidden || boundaryHidden);
+		}
+	}
+	function setSubtreeVisibility(node, hidden) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) setNodeVisibility(cursor, hidden);
+	}
+	function setNodeVisibility(cursor, hidden) {
+		if (isHiddenBoundary(cursor)) return;
+		if (cursor.tag === 1) {
+			const activityHost = requireActivityHostConfig();
+			if (hidden) activityHost.hideInstance(cursor.stateNode);
+			else activityHost.unhideInstance(cursor.stateNode, cursor.props);
+		} else if (cursor.tag === 2) {
+			const activityHost = requireActivityHostConfig();
+			if (hidden) activityHost.hideTextInstance(cursor.stateNode);
+			else activityHost.unhideTextInstance(cursor.stateNode, String(cursor.props.nodeValue));
+		}
+		setSubtreeVisibility(cursor.child, hidden);
+	}
+	function hideHostFiber(node) {
+		const activityHost = requireActivityHostConfig();
+		if (node.tag === 1) activityHost.hideInstance(node.stateNode);
+		else activityHost.hideTextInstance(node.stateNode);
+	}
+	function armRevealedHiddenBoundaries(node) {
+		for (let cursor = node; cursor !== null; cursor = cursor.sibling) {
+			if ((cursor.flags & 16) !== 0) continue;
+			const subtreeVisibility = (cursor.subtreeFlags & 32) !== 0;
+			if ((cursor.flags & 32) === 0 && !subtreeVisibility) continue;
+			if (isHiddenBoundaryTag(cursor) && (cursor.flags & 32) !== 0 && !activityHidden(cursor.props) && cursor.child !== null) armDeferredEffects(cursor.child);
+			if (subtreeVisibility) armRevealedHiddenBoundaries(cursor.child);
+		}
+	}
+	function armDeferredEffects(node) {
+		visitFiberHooks(node, (owner, hook) => {
+			if (hook.kind === 10) {
+				const state = hook.memoizedState;
+				const instance = state.instance;
+				instance.handler = state.next;
+				instance.live = true;
+				return;
+			}
+			if (!isEffectHook(hook.kind)) return;
+			const effect = hook.memoizedState;
+			if (effect.controller !== null) return;
+			const effects = owner.effects ??= [];
+			if (!effects.includes(effect)) effects.push(effect);
+			const root = rootOf(owner);
+			recordCommitWork(root.commitIndex, owner, 512);
+			markSubtreeFlag(owner, 512);
+			markCommitEffectPhase(root, effect.phase);
+		});
+	}
+	function commitLiveHookInstances(root) {
+		for (const owner of root.commitIndex) for (let hook = owner.memoizedState; hook !== null; hook = hook.next) commitLiveHookInstance(owner, hook);
+	}
+	function commitLiveHookInstance(owner, hook) {
+		if (isStableEventHook(hook)) {
+			const instance = hook.memoizedState.instance;
+			instance.handler = hook.memoizedState.next;
+			instance.live = !hasHiddenBoundaries || !isInsideHiddenBoundary(owner);
+		}
+		if (hook.kind === 4) {
+			const state = hook.memoizedState;
+			state.instance.action = state.action;
+			state.instance.value = state.value;
+		}
+	}
+	function isInsideHiddenBoundary(node) {
+		for (let parent = node.return; parent !== null; parent = parent.return) if (isHiddenBoundary(parent)) return true;
+		return false;
+	}
+	function isStableEventHook(hook) {
+		return hook.kind === 10;
+	}
+	function commitExternalStores(root) {
+		for (const cursor of root.commitIndex) {
+			if ((cursor.flags & 2048) === 0) continue;
+			if (hasHiddenBoundaries && isInsideHiddenBoundary(cursor)) continue;
+			for (let hook = cursor.memoizedState; hook !== null; hook = hook.next) if (isExternalStoreHook(hook)) commitExternalStore(root, cursor, hook.memoizedState);
+		}
+	}
+	function commitExternalStore(root, owner, state) {
+		const instance = state.instance;
+		if (instance.committedSubscribe !== state.subscribe) {
+			instance.unsubscribe?.();
+			instance.unsubscribe = null;
+			instance.committedSubscribe = state.subscribe;
+		}
+		instance.getSnapshot = state.getSnapshot;
+		instance.owner = owner;
+		instance.value = state.value;
+		root.externalStores.add(instance);
+		instance.unsubscribe ??= state.subscribe(() => {
+			scheduleExternalStoreIfChanged(instance.owner, instance, requestExternalStoreUpdateLane());
+		});
+		scheduleExternalStoreIfChanged(instance.owner, instance, 2);
+	}
+	function scheduleExternalStoreIfChanged(owner, instance, lane) {
+		if (owner === null) return;
+		const latestValue = instance.getSnapshot();
+		if (!Object.is(latestValue, instance.value)) scheduleFiber(owner, lane);
+	}
+	function requestExternalStoreUpdateLane() {
+		const lane = requestUpdateLane();
+		return lane === 32 ? 2 : lane;
+	}
+	function commitEffects(root, node, phase) {
+		const mask = 1 << phase;
+		if ((root.commitEffectPhases & mask) === 0) return;
+		const runEffects = () => {
+			for (const owner of root.commitIndex) {
+				const effects = owner.effects;
+				if (effects === null) continue;
+				if (hasHiddenBoundaries && isInsideHiddenBoundary(owner)) continue;
+				for (const effect of effects) {
+					if (effect.phase !== phase) continue;
+					runCommitEffect(effect, phase);
+				}
+			}
+		};
+		if (phase === 1) runWithPriority(2, runEffects);
+		else runEffects();
+		root.commitEffectPhases &= ~mask;
+	}
+	function runCommitEffect(effect, phase) {
+		const previousPhase = currentCommitEffectPhase;
+		currentCommitEffectPhase = phase;
+		try {
+			runEffect(effect);
+		} finally {
+			currentCommitEffectPhase = previousPhase;
+		}
+	}
+	function collectReactiveEffects(root, node) {
+		walkFiberForest(node, (cursor) => {
+			for (const effect of cursor.effects ?? []) if (effect.phase === 0) root.pendingReactiveEffects.push(effect);
+			cursor.effects = null;
+			const adopted = (cursor.flags & 16) !== 0;
+			const subtreeFlags = cursor.subtreeFlags;
+			clearTransientFlags(cursor);
+			if (adopted) return false;
+			if (isHiddenBoundary(cursor)) {
+				if (subtreeFlags !== 0) clearHiddenSubtreeFlags(cursor.child);
+				return false;
+			}
+			return (subtreeFlags & -4097) !== 0;
+		});
+	}
+	function clearHiddenSubtreeFlags(node) {
+		walkFiberForest(node, (cursor) => {
+			const adopted = (cursor.flags & 16) !== 0;
+			const subtreeFlags = cursor.subtreeFlags;
+			clearTransientFlags(cursor);
+			return !adopted && (subtreeFlags & -4097) !== 0;
+		});
+	}
+	function scheduleReactiveEffects(root) {
+		if (root.pendingReactiveEffects.length === 0 || root.reactiveCallback !== null) return;
+		root.reactiveCallback = scheduleCallback(3, () => {
+			performReactiveEffects(root);
+		});
+	}
+	function performReactiveEffects(root) {
+		try {
+			flushReactiveEffects(root);
+		} catch (error) {
+			const info = root.uncaughtErrorInfo ?? errorInfoFor(root.current, error);
+			clearRootAfterUncaughtError(root);
+			reportUncaughtError(root, error, info);
+			if (root.onUncaughtError === null) setTimeout(() => {
+				throw error;
+			});
+		}
+	}
+	function flushPendingReactiveEffects(root) {
+		root.reactiveCallback?.cancel();
+		flushReactiveEffects(root);
+	}
+	function flushReactiveEffects(root) {
+		root.reactiveCallback = null;
+		const effects = root.pendingReactiveEffects;
+		root.pendingReactiveEffects = [];
+		for (const effect of effects) runEffect(effect);
+	}
+	function visitFiberHooks(node, visitor) {
+		walkFiberForest(node, (cursor) => {
+			for (let hook = cursor.memoizedState; hook !== null; hook = hook.next) visitor(cursor, hook);
+		});
+	}
+	function isExternalStoreHook(hook) {
+		return hook.kind === 7;
+	}
+	function runEffect(effect) {
+		abortEffect(effect);
+		let controller = new AbortController();
+		effect.controller = controller;
+		const dataStore = rootOf(effect.owner).dataStore;
+		try {
+			dataStore.run(() => effect.create(controller.signal));
+		} catch (error) {
+			abortEffect(effect);
+			handleEffectError(effect, error);
+		}
+	}
+	function handleEffectError(effect, error) {
+		const owner = effect.owner;
+		const boundary = findErrorBoundary(owner);
+		if (boundary !== null) {
+			captureCommittedErrorBoundary(boundary, error, owner);
+			scheduleFiber(boundary, 32);
+			return;
+		}
+		rootOf(owner).uncaughtErrorInfo = errorInfoFor(owner, error);
+		throw error;
+	}
+	function abortFiberEffects(node, retirePending = false) {
+		walkFiberForest(node, (cursor) => {
+			abortFiberHooks(cursor, retirePending);
+		});
+	}
+	function abortFiberHooks(owner, retirePending) {
+		for (let hook = owner.memoizedState; hook !== null; hook = hook.next) {
+			if (isEffectHook(hook.kind)) abortEffect(hook.memoizedState);
+			if (isExternalStoreHook(hook)) unsubscribeExternalStore(hook.memoizedState);
+			if (isStableEventHook(hook)) {
+				const instance = hook.memoizedState.instance;
+				instance.controller?.abort();
+				instance.controller = null;
+				instance.live = false;
+			}
+			if (hook.kind === 9) {
+				const state = hook.memoizedState;
+				if (retireRun(state.instance) && retirePending) scheduleHookUpdate(owner, hook.queue, (previous) => ({
+					...previous,
+					pendingCount: Math.max(0, previous.pendingCount - 1)
+				}), 32);
+			}
+			if (hook.kind === 4) {
+				const state = hook.memoizedState;
+				if (retireRun(state.instance) && retirePending) scheduleHookUpdate(owner, hook.queue, (previous) => ({
+					...previous,
+					pending: Math.max(0, previous.pending - 1)
+				}), 32);
+			}
+		}
+	}
+	function abortEffect(effect) {
+		effect.controller?.abort();
+		effect.controller = null;
+	}
+	function unsubscribeExternalStore(state) {
+		if (state.instance.owner !== null) rootOf(state.instance.owner).externalStores.delete(state.instance);
+		state.instance.unsubscribe?.();
+		state.instance.unsubscribe = null;
+		state.instance.committedSubscribe = null;
+		state.instance.owner = null;
+	}
+	function restoreConsumedPendingQueues(root, from = 0) {
+		for (const consumed of root.consumedPendingQueues.splice(from)) restoreConsumedPendingQueue(consumed);
+	}
+	function restoreConsumedPendingQueuesForRetry(root, from) {
+		for (const consumed of root.consumedPendingQueues.splice(from)) {
+			clearQueueLanes(consumed.pending);
+			restoreConsumedPendingQueue(consumed);
+		}
+	}
+	function restoreConsumedPendingQueue({ queue, pending }) {
+		queue.pending = queue.pending === null ? pending : mergeQueues(pending, queue.pending);
+	}
+}
+function activityHidden(props) {
+	return props.mode === "hidden";
+}
+function hookKindName(kind) {
+	return kind;
+}
+function createHook(kind, state) {
+	return {
+		kind,
+		memoizedState: state,
+		baseState: state,
+		baseQueue: null,
+		queue: {
+			pending: null,
+			dispatch: null
+		},
+		next: null
+	};
+}
+function retireRun(instance) {
+	const controller = instance.controller;
+	if (controller === null) return false;
+	instance.controller = null;
+	instance.generation += 1;
+	controller.abort();
+	return true;
+}
+function createActionState(action, value) {
+	return {
+		action,
+		error: NoActionStateError,
+		instance: {
+			action,
+			controller: null,
+			generation: 0,
+			value
+		},
+		pending: 0,
+		value
+	};
+}
+function resolveInitialState(initialState) {
+	return typeof initialState === "function" ? initialState() : initialState;
+}
+function sameType(fiber, child) {
+	if (typeof child === "string") return fiber.tag === 2;
+	if (isPortal(child)) return fiber.tag === 8 && fiber.props.target === child.target;
+	if (!isValidElement(child)) return false;
+	return fiber.type === child.type;
+}
+function propsFor(child) {
+	if (typeof child === "string") return { nodeValue: child };
+	if (isPortal(child)) return portalProps(child);
+	if (isValidElement(child)) return child.props;
+	throw invalidChildError(child);
+}
+function portalProps(child) {
+	return {
+		children: child.children,
+		target: child.target
+	};
+}
+function validateChildKey(child, seenKeys) {
+	if (seenKeys === null) return;
+	const key = childExplicitKey(child);
+	if (key === null) return;
+	if (seenKeys.has(key)) throw duplicateKeyError(key);
+	seenKeys.add(key);
+}
+function sameChildKey(fiber, child, index) {
+	const key = childExplicitKey(child);
+	return key === null ? fiber.key === null && fiber.index === index : fiber.key !== null && String(fiber.key) === key;
+}
+function childExplicitKey(child) {
+	return (isValidElement(child) || isPortal(child)) && child.key !== null ? String(child.key) : null;
+}
+function duplicateKeyError(key) {
+	return /* @__PURE__ */ new Error(`Duplicate key "${String(key)}" found among siblings.`);
+}
+function isHost(fiber) {
+	return fiber.tag === 1 || fiber.tag === 2;
+}
+function hostNode(fiber) {
+	return fiber.stateNode;
+}
+function areHookInputsEqual(nextDeps, previousDeps) {
+	if (nextDeps === null || previousDeps === null) return false;
+	if (nextDeps.length !== previousDeps.length) return false;
+	for (let index = 0; index < nextDeps.length; index += 1) if (!Object.is(nextDeps[index], previousDeps[index])) return false;
+	return true;
+}
+function changedContextProvider(fiber) {
+	return fiber.tag === 5 && fiber.alternate !== null && !Object.is(fiber.props.value, fiber.alternate.memoizedProps?.value);
+}
+function suspenseRetryLane(lanes) {
+	const retryLanes = lanes & RetryLanes;
+	return retryLanes === 0 ? claimNextRetryLane() : getHighestPriorityLane(retryLanes);
+}
+//#endregion
+export { act, createRenderer, runWithEventPriority };
+
+//# sourceMappingURL=index.js.map