@bgub/fig-reconciler 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist-development/index.js

@@ -0,0 +1,3632 @@
+import { A as runWithTransitionLane, B as clearTransientFlags, C as markRootSuspended, D as requestUpdateLane, E as mergeLanes, F as HoistedStaticFlag, I as StaticFlagsMask, L as StoreConsistencyFlag, M as tagFor, N as AssetFlag, O as runWithPriority, P as ContextPropagationFlag, R as ViewTransitionStaticFlag, S as markRootPinged, T as markStarvedLanesAsExpired, _ as includesSomeLane, b as markRootEntangled, c as RetryLanes, d as claimNextTransitionLane, f as createLaneMap, g as includesOnlyTransitions, h as getNextLanes, i as DeferredLane, j as transitionTypeHooks, k as runWithTransition, l as SelectiveHydrationLane, m as getLaneSchedulerPriority, n as walkFiberSubtree, p as getHighestPriorityLane, s as OffscreenLane, t as walkFiberForest, u as claimNextRetryLane, v as isSyncLane, w as markRootUpdated, x as markRootFinished, z as childSubtreeFlags } from "./fiber-traversal-B_egclZy.js";
+import { a as shouldYieldToHost, i as scheduleCallback, n as now, r as requestPaint } from "./scheduler-WVeIVb_n.js";
+import { a as runWithStaleRefreshFamilies, i as resolveLatestType, n as matchesComponentFamily, r as refreshFamilyFor, t as hasRefreshHandler } from "./refresh-internal-C6pcjhGn.js";
+import { Fragment, isValidElement } from "@bgub/fig";
+import { attachDataStore, collectChildren, dataResourceKeysForError, invalidChildError, isPortal, isThenable, readThenable, setCurrentDataStore, setCurrentDispatcher, setTransitionHandler, trackThenable } from "@bgub/fig/internal";
+//#region src/commit-index.ts
+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;
+	for (let offset = checkpoint; 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;
+}
+//#endregion
+//#region src/devtools-internal.ts
+function devtoolsTypeName(type, fallback) {
+	if (typeof type === "string") return type;
+	if (type === Fragment) return "Fragment";
+	if (typeof type !== "function") return fallback;
+	const namedType = type;
+	if (typeof namedType.displayName === "string" && namedType.displayName !== "") return namedType.displayName;
+	if (typeof namedType.name === "string" && namedType.name !== "") return namedType.name;
+	return fallback;
+}
+function getFigDevtoolsGlobalHook() {
+	const hook = globalThis.__FIG_DEVTOOLS_GLOBAL_HOOK__;
+	if (typeof hook !== "object" || hook === null || !("inject" in hook) || !("onCommitRoot" in hook)) return null;
+	const candidate = hook;
+	if (typeof candidate.inject !== "function" || typeof candidate.onCommitRoot !== "function") return null;
+	return candidate;
+}
+const hookKindNames = [
+	"reactive",
+	"before-paint",
+	"before-layout",
+	"state",
+	"action-state",
+	"id",
+	"deferred-value",
+	"external-store",
+	"memo",
+	"transition",
+	"stable-event"
+];
+function isEffectHook(kind) {
+	return kind <= 2;
+}
+//#endregion
+//#region src/devtools-snapshot.ts
+const devtoolsFiberIds = /* @__PURE__ */ new WeakMap();
+const devtoolsRootIds = /* @__PURE__ */ new WeakMap();
+const devtoolsRendererIds = /* @__PURE__ */ new WeakMap();
+let nextDevtoolsFiberId = 1;
+let nextDevtoolsRootId = 1;
+function emitDevtoolsCommit(renderer, root) {
+	const hook = getFigDevtoolsGlobalHook();
+	if (hook === null) return;
+	try {
+		let rendererId = devtoolsRendererIds.get(renderer);
+		if (rendererId === void 0) {
+			rendererId = hook.inject({
+				name: "Fig",
+				packageName: "@bgub/fig-reconciler"
+			});
+			devtoolsRendererIds.set(renderer, rendererId);
+		}
+		const inspection = {
+			hostFibers: /* @__PURE__ */ new WeakMap(),
+			fiberElements: /* @__PURE__ */ new Map()
+		};
+		const snapshot = snapshotDevtoolsRoot(root, rendererId, inspection);
+		hook.onCommitRoot(rendererId, snapshot, createDevtoolsCommitInspection(snapshot.id, inspection));
+	} catch {}
+}
+function snapshotDevtoolsRoot(root, rendererId, inspection) {
+	return {
+		id: devtoolsRootId(root),
+		rendererId,
+		committedAt: now(),
+		dataResources: root.dataStore.inspectDataEntries(),
+		pendingWork: devtoolsWorkLabels(root.pendingLanes),
+		suspendedWork: devtoolsWorkLabels(root.suspendedLanes),
+		pingedWork: devtoolsWorkLabels(root.pingedLanes),
+		expiredWork: devtoolsWorkLabels(root.expiredLanes),
+		tree: snapshotDevtoolsFiber(root.current, null, root.dataStore, inspection)
+	};
+}
+function snapshotDevtoolsFiber(node, parentId, dataStore, inspection) {
+	const id = devtoolsFiberId(node);
+	const { kind, name } = devtoolsFiberInfo(node);
+	const children = [];
+	const errorState = devtoolsErrorBoundaryState(node);
+	recordDevtoolsHostFiber(node, id, inspection);
+	for (let child = node.child; child !== null; child = child.sibling) appendDevtoolsChildSnapshots(child, id, dataStore, inspection, children);
+	return {
+		id,
+		parentId,
+		name,
+		kind,
+		key: node.key,
+		index: node.index,
+		props: devtoolsProps(node),
+		pendingWork: devtoolsWorkLabels(node.lanes),
+		childWork: devtoolsWorkLabels(node.childLanes),
+		hooks: devtoolsHooks(node.memoizedState),
+		contextDependencies: devtoolsContextDependencies(node),
+		dataResourceCanonicalKeys: devtoolsDataResourceKeys(node, dataStore),
+		host: devtoolsHost(node),
+		capturedError: errorState?.error,
+		componentStack: errorState?.info.componentStack,
+		children
+	};
+}
+function devtoolsErrorBoundaryState(node) {
+	return node.tag === 7 ? node.boundaryState : null;
+}
+function devtoolsWorkLabels(lanes) {
+	const labels = [];
+	if (includesSomeLane(lanes, 3)) labels.push("sync");
+	if (includesSomeLane(lanes, 12)) labels.push("input");
+	if (includesSomeLane(lanes, 48)) labels.push("default");
+	if (includesSomeLane(lanes, 64)) labels.push("gesture");
+	if (includesSomeLane(lanes, 4194176)) labels.push("transition");
+	if (includesSomeLane(lanes, 62914560)) labels.push("retry");
+	if (includesSomeLane(lanes, 402653184)) labels.push("idle");
+	if (includesSomeLane(lanes, 536870912)) labels.push("offscreen");
+	if (includesSomeLane(lanes, 1073741824)) labels.push("deferred");
+	if (includesSomeLane(lanes, 67108864)) labels.push("selective-hydration");
+	return labels;
+}
+function devtoolsDataResourceKeys(node, dataStore) {
+	const keys = dataStore.inspectDataDependencyCanonicalKeys(node);
+	if (keys.length > 0 || node.alternate === null) return keys;
+	return dataStore.inspectDataDependencyCanonicalKeys(node.alternate);
+}
+function appendDevtoolsChildSnapshots(node, parentId, dataStore, inspection, children) {
+	if (node.tag === 10 && node.type === null || node.tag === 12) {
+		for (let child = node.child; child !== null; child = child.sibling) appendDevtoolsChildSnapshots(child, parentId, dataStore, inspection, children);
+		return;
+	}
+	children.push(snapshotDevtoolsFiber(node, parentId, dataStore, inspection));
+}
+function devtoolsRootId(root) {
+	const existing = devtoolsRootIds.get(root);
+	if (existing !== void 0) return existing;
+	const id = nextDevtoolsRootId++;
+	devtoolsRootIds.set(root, id);
+	return id;
+}
+function createDevtoolsCommitInspection(rootId, inspection) {
+	return {
+		inspectElement(target) {
+			if (typeof target !== "object" || target === null) return null;
+			const fiberId = inspection.hostFibers.get(target);
+			return fiberId === void 0 ? null : {
+				rootId,
+				fiberId
+			};
+		},
+		elementForFiber(fiberId) {
+			return inspection.fiberElements.get(fiberId) ?? null;
+		}
+	};
+}
+function recordDevtoolsHostFiber(node, id, inspection) {
+	if (node.tag !== 1 && node.tag !== 2) return;
+	if (typeof node.stateNode !== "object" || node.stateNode === null) return;
+	inspection.hostFibers.set(node.stateNode, id);
+	inspection.fiberElements.set(id, node.stateNode);
+}
+function devtoolsFiberId(node) {
+	const existing = devtoolsFiberIds.get(node) ?? (node.alternate === null ? void 0 : devtoolsFiberIds.get(node.alternate));
+	if (existing !== void 0) {
+		devtoolsFiberIds.set(node, existing);
+		if (node.alternate !== null) devtoolsFiberIds.set(node.alternate, existing);
+		return existing;
+	}
+	const id = nextDevtoolsFiberId++;
+	devtoolsFiberIds.set(node, id);
+	if (node.alternate !== null) devtoolsFiberIds.set(node.alternate, id);
+	return id;
+}
+function devtoolsProps(node) {
+	const props = {};
+	const source = node.memoizedProps ?? node.props;
+	for (const [key, value] of Object.entries(source)) if (key !== "children") props[key] = value;
+	return props;
+}
+function devtoolsHooks(firstHook) {
+	const hooks = [];
+	let id = 0;
+	for (let hook = firstHook; hook !== null; hook = hook.next) {
+		id += 1;
+		const kind = hookKindNames[hook.kind];
+		if (isEffectHook(hook.kind)) {
+			const effect = hook.memoizedState;
+			hooks.push({
+				id,
+				kind,
+				deps: effect.deps,
+				phase: devtoolsEffectPhase(effect.phase),
+				active: effect.controller !== null
+			});
+		} else if (hook.kind === 8) {
+			const memo = hook.memoizedState;
+			hooks.push({
+				id,
+				kind,
+				state: memo.value,
+				deps: memo.deps
+			});
+		} else if (hook.kind === 7) {
+			const store = hook.memoizedState;
+			hooks.push({
+				id,
+				kind,
+				state: store.value
+			});
+		} else hooks.push({
+			id,
+			kind,
+			state: hook.memoizedState
+		});
+	}
+	return hooks;
+}
+function devtoolsContextDependencies(node) {
+	return node.contextDependencies?.map((dependency) => devtoolsTypeName(dependency.context, "Context")) ?? [];
+}
+function devtoolsHost(node) {
+	if (node.tag === 2) {
+		const text = node.stateNode;
+		const value = typeof text?.nodeValue === "string" ? text.nodeValue : typeof node.memoizedProps?.nodeValue === "string" ? node.memoizedProps.nodeValue : void 0;
+		return {
+			kind: "text",
+			text: value === void 0 ? void 0 : devtoolsTruncate(value)
+		};
+	}
+	if (node.tag !== 1) return void 0;
+	const instance = node.stateNode;
+	return {
+		kind: "element",
+		tagName: typeof instance?.localName === "string" ? instance.localName : typeof instance?.tagName === "string" ? instance.tagName.toLowerCase() : String(node.type),
+		attributes: {}
+	};
+}
+function devtoolsFiberInfo(node) {
+	switch (node.tag) {
+		case 0: return {
+			kind: "root",
+			name: "Root"
+		};
+		case 1: return {
+			kind: "host",
+			name: String(node.type)
+		};
+		case 2: return {
+			kind: "text",
+			name: "#text"
+		};
+		case 3: return {
+			kind: "function",
+			name: devtoolsTypeName(node.type, "Anonymous")
+		};
+		case 4: return {
+			kind: "fragment",
+			name: "Fragment"
+		};
+		case 5: return {
+			kind: "context-provider",
+			name: `${devtoolsTypeName(node.type, "Context")}.Provider`
+		};
+		case 6: return {
+			kind: "suspense",
+			name: "Suspense"
+		};
+		case 7: return {
+			kind: "error-boundary",
+			name: "ErrorBoundary"
+		};
+		case 10: return {
+			kind: "activity",
+			name: "Activity"
+		};
+		case 11: return {
+			kind: "view-transition",
+			name: "ViewTransition"
+		};
+		case 8: return {
+			kind: "portal",
+			name: "Portal"
+		};
+		case 9: return {
+			kind: "assets",
+			name: "Assets"
+		};
+		case 12: return {
+			kind: "fragment",
+			name: "Promise"
+		};
+	}
+}
+function devtoolsEffectPhase(phase) {
+	if (phase === 1) return "before-paint";
+	if (phase === 2) return "before-layout";
+	return "reactive";
+}
+function devtoolsTruncate(value) {
+	return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+}
+//#endregion
+//#region src/hook-queue.ts
+var HookUpdate = class {
+	action;
+	lane;
+	next = this;
+	constructor(action, lane) {
+		this.action = action;
+		this.lane = lane;
+	}
+};
+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) {
+	return new HookUpdate(update.action, update.lane);
+}
+function cloneQueue(queue) {
+	return queue === null ? null : cloneQueueNodes(queue);
+}
+function cloneQueueNodes(queue) {
+	const first = queue.next;
+	let clone = cloneUpdateNode(first);
+	let update = first.next;
+	while (update !== first) {
+		clone = mergeQueues(clone, cloneUpdateNode(update));
+		update = update.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) || isThenable(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);
+		},
+		ensureData(resource, ...args) {
+			return installStore(resource).ensureData(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() ?? [];
+		},
+		inspectDataDependencyCanonicalKeys(owner) {
+			return inner?.inspectDataDependencyCanonicalKeys(owner) ?? [];
+		},
+		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;
+}
+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 commitCoordinator = null;
+	let didWarnMissingViewTransitionCoordinator = false;
+	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;
+	let renderingFiber = null;
+	let currentHook = null;
+	let workInProgressHook = null;
+	let localIdCounter = 0;
+	function installCommitCoordinator(coordinator) {
+		if (commitCoordinator === coordinator) return;
+		if (commitCoordinator !== null) throw new Error(`Cannot install commit coordinator "${coordinator.name}": commit coordination is already owned by "${commitCoordinator.name}".`);
+		commitCoordinator = coordinator;
+	}
+	function commitPriority(lanes) {
+		const lane = getHighestPriorityLane(lanes);
+		if (includesSomeLane(130023424, lane)) return "suspense";
+		if (includesSomeLane(1077935872, lane)) return "transition";
+		if (includesSomeLane(805306368, lane)) return "idle";
+		return "blocking";
+	}
+	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 (hasRefreshHandler()) mountedRoots.add(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 dataStoreHost = {
+			getLane: requestUpdateLane,
+			partition: options.dataPartition,
+			schedule(owner, lane) {
+				scheduleFiber(owner, hiddenSubtreeLane(owner, lane));
+			}
+		};
+		const dataStore = options.dataStore === void 0 ? createRootDataStore(dataStoreHost) : attachDataStore(options.dataStore, dataStoreHost, options.initialData);
+		const root = {
+			container,
+			current,
+			element: null,
+			identifierPrefix: options.identifierPrefix ?? "",
+			nextClientId: 0,
+			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,
+			pendingCoordinatedCommit: false,
+			parkedCoordinatedCommit: 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: [],
+			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.dataStore === void 0 && 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);
+		transitionTypeHooks.record?.(root, lane);
+		pendingRoots.add(root);
+		if (currentCommitEffectPhase === 1 && isSyncLane(lane)) needsPostCommitSyncFlush = true;
+	}
+	function markRootCompleted(root, remainingLanes) {
+		markRootFinished(root, remainingLanes);
+		transitionTypeHooks.complete?.(root, remainingLanes);
+	}
+	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.pendingCoordinatedCommit) 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;
+		}
+		if (host.shouldRecoverSuspenseMismatchAtRoot?.(root.container, state.boundary) === true) {
+			markHydrationRecovery(root, "root");
+			state.boundary.forceClientRender = true;
+			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.pendingCoordinatedCommit) return;
+		if (root.pendingLanes === 0 && root.wip === null) {
+			pendingRoots.delete(root);
+			return;
+		}
+		flushPendingReactiveEffects(root);
+		if (root.parkedCoordinatedCommit) {
+			root.parkedCoordinatedCommit = 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 = root.commitIndex.length;
+		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 === 12) {
+			reconcileCurrentChildren(node, readThenable(node.props.thenable), root);
+			return;
+		}
+		if (node.tag === 2) {
+			if (node.alternate === null || node.alternate.props.nodeValue !== node.props.nodeValue) host.validateTextNesting?.(String(node.props.nodeValue), hostAncestorTypes(node));
+			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);
+			const hoisted = resolveHoistedFiber(node, root);
+			{
+				let ancestors = null;
+				if (!hoisted && node.alternate === null && host.validateInstanceNesting) {
+					ancestors = hostAncestorTypes(node);
+					host.validateInstanceNesting(type, node.props, ancestors);
+				}
+				if (host.validateTextNesting && shouldUseHostTextContent(node, root)) {
+					const textContent = hostTextContent(children);
+					if (textContent !== null) {
+						ancestors ??= hostAncestorTypes(node);
+						ancestors.unshift(type);
+						host.validateTextNesting(textContent, ancestors);
+					}
+				}
+			}
+			if (!hoisted && tryHydrateInstance(node, root)) {
+				reconcileCurrentChildren(node, children, root);
+				return;
+			}
+			if (!hoisted) 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) {
+		{
+			const name = node.props.name;
+			if (name === "none" || name === "") throw new Error(`<ViewTransition> received the reserved name "${name}". "none" disables the browser feature and "" is not a valid view-transition-name; use "auto" or omit the prop for a generated name.`);
+			if (commitCoordinator?.viewTransitions !== true && !didWarnMissingViewTransitionCoordinator) {
+				didWarnMissingViewTransitionCoordinator = true;
+				const coordinatorDescription = commitCoordinator === null ? "this renderer has no commit coordinator with View Transition support" : `the installed commit coordinator "${commitCoordinator.name}" does not provide View Transition support`;
+				console.error(`A <ViewTransition> rendered, but ${coordinatorDescription}. Install View Transition support for this renderer. Fig DOM applications can call enableViewTransitions() from "@bgub/fig-dom/view-transitions".`);
+			}
+		}
+		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 (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 && !(node.tag === 1 && host.canRetainHydrationTail?.(node.stateNode) === true)) 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 resolveHoistedFiber(node, root) {
+		if (isHoistedFiber(node)) return true;
+		if (node.tag !== 1 || node.stateNode !== null || host.resolveHoistedInstance === void 0) return false;
+		const hydrating = shouldHydrateFiber(root, node);
+		const instance = host.resolveHoistedInstance(String(node.type), node.props, hostParent(node));
+		if (instance === null) return false;
+		requireHoistedAssetHostConfig();
+		node.stateNode = instance;
+		node.flags |= HoistedStaticFlag;
+		if (hydrating) node.flags |= 1;
+		return true;
+	}
+	function isHoistedFiber(node) {
+		return node.tag === 1 && (node.flags & 8192) !== 0;
+	}
+	function requireHoistedAssetHostConfig() {
+		if (hoistedAssetHostConfig !== null) return hoistedAssetHostConfig;
+		if (host.resolveHoistedInstance === 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) {
+		if (hasRefreshHandler()) node.type = resolveLatestType(node.type);
+		prepareHookRender(node, root);
+		const previousDispatcher = setCurrentDispatcher(dispatcher);
+		const previousDataStore = setCurrentDataStore(root.dataStore);
+		try {
+			{
+				const consumedBefore = root.consumedPendingQueues.length;
+				const nextClientIdBefore = root.nextClientId;
+				observeDiscardedPromiseChildren(node.type(node.props));
+				if (currentHook !== null) throw hookOrderError("fewer");
+				restoreConsumedPendingQueues(root, consumedBefore);
+				root.nextClientId = nextClientIdBefore;
+				prepareHookRender(node, root);
+				node.effects = null;
+			}
+			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);
+			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,
+			idPath: hydrationIdPath(root, node),
+			kind: "dehydrated",
+			wasPending: boundary.status === "pending"
+		};
+		host.registerSuspenseBoundaryRetry?.(boundary, () => scheduleFiber(node, 32));
+		root.nextHydratableInstance = nextAfterSuspenseBoundary(boundary);
+		return true;
+	}
+	function hydrateDehydratedSuspenseBoundary(node, state) {
+		const boundary = state.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 = state;
+				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,
+			idPath: hydrationIdPath(root, node)
+		};
+		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" && !isThenable(fallback) ? 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 (instance.runner === 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);
+			};
+			instance.runner = (...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,
+			instance.runner,
+			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;
+		let start = hook.memoizedState.start;
+		if (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;
+			start = (callback, options) => {
+				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;
+						});
+					}
+				}, options);
+			};
+			hook.memoizedState.start = start;
+		}
+		return [hook.memoizedState.pendingCount > 0, start];
+	}
+	function runLatest(instance, fiber, run, updatePending, settled, options) {
+		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), options);
+			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) {
+		if (currentCommitEffectPhase === 2) throw new Error("State updates are not allowed from useBeforeLayout effects.");
+		lane = hiddenSubtreeLane(fiber, lane);
+		const update = new HookUpdate(action, lane);
+		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 (parent.tag === 10 && fiberActivityState(parent)?.hidden === true) return OffscreenLane;
+		return lane;
+	}
+	function createFiberId(root, fiber, localId) {
+		if (!root.isHydrating || insideHydrationExemptHost(fiber)) {
+			const id = root.nextClientId;
+			root.nextClientId += 1;
+			return `${root.identifierPrefix}fig-C-${id.toString(32)}`;
+		}
+		return `${root.identifierPrefix}fig-${hydrationIdPath(root, fiber)}-${localId.toString(32)}`;
+	}
+	function hydrationIdPath(root, fiber) {
+		const suspense = root.hydratingSuspenseBoundary;
+		if (suspense !== null) {
+			const state = fiberSuspenseState(suspense.alternate);
+			if (state?.kind === "dehydrated") return appendIdPath(state.idPath, fiberPath(fiber, suspense));
+		}
+		const activity = root.hydratingActivityBoundary;
+		if (activity !== null) {
+			const base = fiberActivityState(activity)?.dehydrated?.idPath ?? null;
+			if (base !== null) return appendIdPath(base, fiberPath(fiber, activity));
+		}
+		return fiberPath(fiber, null);
+	}
+	function appendIdPath(base, relative) {
+		return relative === "" ? base : `${base}-${relative}`;
+	}
+	function fiberPath(fiber, stopBefore) {
+		const parts = [];
+		for (let node = fiber; node !== null && node !== stopBefore && node.tag !== 0; node = node.return) if (node.tag !== 10 || node.type !== null) 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: previousEffect?.strictRan === true
+		};
+		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;
+		if (node.tag === 9 && host.commitAssetResources !== void 0 && (node.committedProps === null || node.committedProps.assets !== node.props.assets)) recordCommitWork(rootOf(node).commitIndex, node, AssetFlag);
+		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 = /* @__PURE__ */ new Set();
+		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 commitRoot(root, finishedWork) {
+		if (!root.pendingCoordinatedCommit && commitCoordinator?.suspend?.(root, () => scheduleRoot(root)) === true) {
+			parkCoordinatedCommit(root);
+			return true;
+		}
+		commitDepth += 1;
+		try {
+			let suspenseRetries = noSuspenseRetries;
+			if (root.pendingSuspenseRetries.length > 0) {
+				suspenseRetries = root.pendingSuspenseRetries;
+				root.pendingSuspenseRetries = [];
+			}
+			commitLiveHookInstances(root);
+			assertLiveHookInstanceParity(finishedWork.child);
+			if (hasHiddenBoundaries) armRevealedHiddenBoundaries(finishedWork.child);
+			commitEffects(root, finishedWork.child, 2);
+			const commitHostChanges = () => {
+				const recoveringHydration = root.clearContainerBeforeCommit;
+				if (recoveringHydration) requireHydrationHostConfig().clearContainer(root.container);
+				if (root.needsCommitDeletions) {
+					commitDeletions(root);
+					root.needsCommitDeletions = false;
+				}
+				assertDeletionCommitParity(finishedWork);
+				if (!recoveringHydration) {
+					commitAssetResourceUpdates(root);
+					assertAssetResourceCommitParity(finishedWork.child);
+				}
+				commitDataDependencies(root);
+				assertDataDependencyCommitParity(finishedWork.child);
+				commitHostUpdates(root);
+				assertHostUpdateCommitParity(finishedWork.child);
+				commitMutationEffects(finishedWork.child);
+				if (hasHiddenBoundaries) commitHiddenBoundaryVisibility(finishedWork.child);
+				assertPlacedHostCommitParity(finishedWork.child, false);
+				if (recoveringHydration) {
+					commitAssetResourceUpdates(root);
+					assertAssetResourceCommitParity(finishedWork.child);
+				}
+				root.clearContainerBeforeCommit = false;
+			};
+			const completeCommit = () => {
+				hasHiddenBoundaries = hiddenStates.size > 0;
+				root.current = finishedWork;
+				deactivateHydration(root);
+				root.hydrationInitialElement = NoHydrationInitialElement;
+				root.consumedPendingQueues = [];
+				markRootCompleted(root, root.pendingLanes & ~root.renderLanes | finishedWork.lanes | finishedWork.childLanes);
+				if (includesSomeLane(finishedWork.childLanes, 536870912)) {
+					markRootPending(root, OffscreenLane);
+					root.suspendedLanes &= ~OffscreenLane;
+				}
+				try {
+					commitExternalStores(root);
+					assertExternalStoreCommitParity(finishedWork.child);
+					attachCommittedSuspenseRetries(root, suspenseRetries);
+					scheduleDehydratedSuspenseRetries(root);
+					commitEffects(root, finishedWork.child, 1);
+					flushCaughtBoundaryErrors(root);
+					assertCaughtBoundaryErrorParity(finishedWork.child);
+				} finally {
+					collectReactiveEffects(root, finishedWork.child);
+					clearTransientFlags(finishedWork);
+					scheduleReactiveEffects(root);
+					clearCommitIndex(root.commitIndex);
+				}
+				if (root.devtools) emitDevtoolsCommit(host, root);
+				flushRecoverableErrors(root);
+				requestPaint();
+			};
+			const finishDeferredCommit = () => {
+				if (!root.pendingCoordinatedCommit) return;
+				root.pendingCoordinatedCommit = false;
+				finishRootWork(root);
+				flushPostCommitSyncWork();
+			};
+			if (commitCoordinator !== null) {
+				let didRunMutation = false;
+				let didFinishCapture = false;
+				const context = {
+					container: root.container,
+					finishedWork,
+					priority: commitPriority(root.renderLanes),
+					root,
+					captureFinished() {
+						if (!didRunMutation) throw new Error("A commit coordinator cannot finish capture before running the mutation transaction.");
+						didFinishCapture = true;
+						finishDeferredCommit();
+					},
+					runMutation(afterMutation) {
+						if (didRunMutation) throw new Error("A commit coordinator may run its mutation transaction only once.");
+						didRunMutation = true;
+						const isDeferredCommit = root.pendingCoordinatedCommit;
+						if (isDeferredCommit) commitDepth += 1;
+						try {
+							commitHostChanges();
+							completeCommit();
+							return afterMutation();
+						} 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;
+						} finally {
+							if (isDeferredCommit) commitDepth -= 1;
+						}
+					}
+				};
+				switch (commitCoordinator.commit(context)) {
+					case false:
+						if (didRunMutation) throw new Error("A commit coordinator returned false after running the mutation transaction.");
+						break;
+					case "committed":
+						if (!didRunMutation) throw new Error("A commit coordinator returned \"committed\" without running the mutation transaction.");
+						return false;
+					case "deferred":
+						root.pendingCoordinatedCommit = true;
+						root.callback = null;
+						root.callbackPriority = 0;
+						if (didFinishCapture) finishDeferredCommit();
+						return true;
+				}
+			}
+			commitHostChanges();
+			completeCommit();
+			return false;
+		} finally {
+			commitDepth -= 1;
+		}
+	}
+	function parkCoordinatedCommit(root) {
+		root.parkedCoordinatedCommit = true;
+		root.callback = null;
+		root.callbackPriority = 0;
+	}
+	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 assertCaughtBoundaryErrorParity(node) {
+		walkFiberForest(node, (cursor) => {
+			const state = fiberErrorBoundaryState(cursor);
+			if (state !== null && !state.didReport) throw new Error("Fig internal parity error: a caught boundary error was missing from the commit index.");
+		});
+	}
+	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);
+			releaseOutOfBandDescendants(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;
+		markRootCompleted(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));
+		visitHostFibers(node, (child) => {
+			if (child.committedProps !== null) return;
+			if (child.tag === 1 && isHoistedFiber(child)) {
+				acquireHoistedInstance(child);
+				markHostCommitted(child);
+				markHostSubtreeCommitted(child.child);
+				return;
+			}
+			markHostCommitted(child);
+			if (isPreassembledHostSubtree(child)) markHostSubtreeCommitted(child.child);
+		});
+	}
+	function visitHostFibers(node, visitor) {
+		if (isHost(node)) {
+			visitor(node);
+			return;
+		}
+		if (node.tag === 8) return;
+		for (let child = node.child; child !== null; child = child.sibling) visitHostFibers(child, visitor);
+	}
+	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, assetResourceOwner(node)) ?? instance;
+		if (next !== instance) adoptSwappedHoistedInstance(node, next);
+	}
+	function adoptSwappedHoistedInstance(node, next) {
+		node.stateNode = next;
+		if (node.alternate !== null) node.alternate.stateNode = next;
+	}
+	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.boundary);
+		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, node.props, assetResourceOwner(node)) ?? 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 assertHostUpdateCommitParity(node) {
+		walkFiberForest(node, (cursor) => {
+			if ((cursor.flags & 10) !== 0 && (cursor.flags & 5) === 0 && (cursor.committedProps !== null || cursor.tag === 2) && isHost(cursor)) throw new Error("Fig internal parity error: a host fiber with pending updates was missing from the commit index.");
+			return (cursor.flags & 16) === 0;
+		});
+	}
+	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 assertDeletionCommitParity(node) {
+		walkFiberSubtree(node, (cursor) => {
+			if (cursor.deletions !== null) throw new Error("Fig internal parity error: a fiber with pending deletions was missing from the commit index.");
+			return (cursor.flags & 16) === 0 && (cursor.subtreeFlags & 128) !== 0;
+		});
+	}
+	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 commitAssetResourceUpdates(root) {
+		if (host.commitAssetResources === void 0) return;
+		for (const cursor of root.commitIndex) {
+			if ((cursor.flags & 16384) === 0) continue;
+			commitHostMutation(cursor, () => host.commitAssetResources?.(cursor.committedProps?.assets ?? null, cursor.props.assets, assetResourceOwner(cursor)));
+			cursor.committedProps = cursor.props;
+			if (cursor.alternate !== null) cursor.alternate.committedProps = cursor.props;
+			cursor.flags &= ~AssetFlag;
+		}
+	}
+	function assertAssetResourceCommitParity(node) {
+		walkFiberForest(node, (cursor) => {
+			if ((cursor.flags & 16384) !== 0) throw new Error("Fig internal parity error: an Assets fiber with pending resource work was missing from the commit index.");
+			return (cursor.flags & 16) === 0;
+		});
+	}
+	function assertPlacedHostCommitParity(node, placed) {
+		for (let child = node; child !== null; child = child.sibling) {
+			const childPlaced = placed || (child.flags & 1) !== 0;
+			if (childPlaced && isHost(child) && child.committedProps === null) throw new Error("Fig internal parity error: a placed host fiber has no committed props after the mutation phase (a subtree insertion skipped commit marking).");
+			if (childPlaced || (child.subtreeFlags & 1) !== 0) assertPlacedHostCommitParity(child.child, childPlaced);
+		}
+	}
+	function assertDataDependencyCommitParity(node) {
+		walkFiberForest(node, (cursor) => {
+			if (cursor.dataDependenciesDirty) throw new Error("Fig internal parity error: a fiber with dirty data dependencies was missing from the commit index.");
+			return (cursor.flags & 16) === 0;
+		});
+	}
+	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?.boundary ?? 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 === 9) releaseAssetResources(node);
+		if (node.tag === 1 && isHoistedFiber(node)) {
+			if (node.committedProps !== null) requireHoistedAssetHostConfig().removeHoistedInstance(node.stateNode, assetResourceOwner(node));
+			return;
+		}
+		if (isHost(node)) {
+			removePortalDescendants(node.child);
+			releaseOutOfBandDescendants(node.child);
+			host.removeChild(parent, hostNode(node));
+			return;
+		}
+		for (let child = node.child; child !== null; child = child.sibling) remove(child, parent);
+	}
+	function releaseOutOfBandDescendants(node) {
+		if (host.resolveHoistedInstance === void 0 && host.commitAssetResources === void 0) return;
+		for (let child = node; child !== null; child = child.sibling) {
+			if (child.tag === 8) continue;
+			if (child.tag === 9) releaseAssetResources(child);
+			if (child.tag === 1 && isHoistedFiber(child)) {
+				if (child.committedProps !== null && child.stateNode !== null) requireHoistedAssetHostConfig().removeHoistedInstance(child.stateNode, assetResourceOwner(child));
+				continue;
+			}
+			releaseOutOfBandDescendants(child.child);
+		}
+	}
+	function releaseAssetResources(node) {
+		if (node.tag !== 9 || node.committedProps === null || host.commitAssetResources === void 0) return;
+		host.commitAssetResources(node.committedProps.assets, null, assetResourceOwner(node));
+		node.committedProps = null;
+		if (node.alternate !== null) node.alternate.committedProps = null;
+	}
+	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 hostAncestorTypes(node) {
+		const ancestors = [];
+		for (let parent = node.return; parent !== null; parent = parent.return) {
+			if (parent.tag === 1) {
+				ancestors.push(String(parent.type));
+				continue;
+			}
+			if (parent.tag === 8 || parent.tag === 0) {
+				const container = host.containerType?.(hostParentFor(parent));
+				if (container != null) ancestors.push(container);
+				break;
+			}
+		}
+		return ancestors;
+	}
+	function hostSibling(node) {
+		if (rootOf(node).clearContainerBeforeCommit) return null;
+		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.assetResourceOwner = current.assetResourceOwner;
+		next.memoizedState = current.memoizedState;
+		next.stateNode = current.stateNode;
+		next.return = current.return;
+		next.child = null;
+		next.sibling = null;
+		next.index = current.index;
+		next.flags = current.flags & HoistedStaticFlag;
+		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 fiber(tagFor(child), child.type, child.key, child.props, null);
+		if (isThenable(child)) return fiber(12, null, null, { thenable: child }, null);
+		return 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,
+			assetResourceOwner: null,
+			boundaryState: null,
+			hiddenState: null
+		};
+	}
+	function assetResourceOwner(node) {
+		const owner = node.assetResourceOwner ?? node.alternate?.assetResourceOwner ?? {};
+		node.assetResourceOwner = owner;
+		if (node.alternate !== null) node.alternate.assetResourceOwner = owner;
+		return owner;
+	}
+	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,
+		installCommitCoordinator,
+		scheduleRefresh
+	};
+	function scheduleRefresh(update) {
+		if (!hasRefreshHandler() || mountedRoots.size === 0) return;
+		runWithStaleRefreshFamilies(update.staleFamilies, () => {
+			flushSync(() => {
+				for (const root of mountedRoots) scheduleFamilyRefresh(root.current.child, update);
+			});
+		});
+	}
+	function scheduleFamilyRefresh(node, update) {
+		if (node === null) return;
+		if (node.tag === 3 && hasRefreshHandler()) {
+			const family = refreshFamilyFor(node.type);
+			if (family !== void 0) {
+				if (update.staleFamilies.has(family)) remountForRefresh(node);
+				else if (update.updatedFamilies.has(family)) scheduleFiber(node, 2);
+			}
+		}
+		scheduleFamilyRefresh(node.child, update);
+		scheduleFamilyRefresh(node.sibling, update);
+	}
+	function remountForRefresh(node) {
+		{
+			const parent = node.return;
+			if (parent === null || parent.tag === 0) {
+				const root = rootOf(node);
+				updateRoot(root, root.element);
+			} else scheduleFiber(parent, 2);
+		}
+	}
+	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 node.tag === 10 && activityHidden(node.props);
+	}
+	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 = cursor.tag === 10;
+			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, 32 | OffscreenLane);
+					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 (cursor.tag === 10 && (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 assertLiveHookInstanceParity(node) {
+		visitRenderedFiberHooks(node, (owner, hook) => {
+			if (isStableEventHook(hook)) {
+				const instance = hook.memoizedState.instance;
+				if (instance.handler !== hook.memoizedState.next || instance.live !== (!hasHiddenBoundaries || !isInsideHiddenBoundary(owner))) throw new Error("Fig internal parity error: a stable-event hook was not published by the commit index.");
+			}
+			if (hook.kind === 4) {
+				const state = hook.memoizedState;
+				if (state.instance.action !== state.action || state.instance.value !== state.value) throw new Error("Fig internal parity error: an action-state hook was not published by the commit index.");
+			}
+		});
+	}
+	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 assertExternalStoreCommitParity(node) {
+		walkFiberForest(node, (cursor) => {
+			if ((cursor.flags & 16) !== 0) return false;
+			if ((cursor.flags & 2048) !== 0) for (let hook = cursor.memoizedState; hook !== null; hook = hook.next) {
+				if (!isExternalStoreHook(hook)) continue;
+				const state = hook.memoizedState;
+				const instance = state.instance;
+				if (instance.committedSubscribe !== state.subscribe || instance.getSnapshot !== state.getSnapshot || instance.owner !== cursor || !Object.is(instance.value, state.value)) throw new Error("Fig internal parity error: an external-store hook was not committed by the commit index.");
+			}
+			return !isHiddenBoundary(cursor) && (cursor.subtreeFlags & 2048) !== 0;
+		});
+	}
+	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;
+		let executed = 0;
+		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;
+					executed += 1;
+					runCommitEffect(effect, phase);
+				}
+			}
+		};
+		if (phase === 1) runWithPriority(2, runEffects);
+		else runEffects();
+		root.commitEffectPhases &= ~mask;
+		{
+			let expected = 0;
+			visitEffects(node, (effect) => {
+				if (effect.phase === phase) expected += 1;
+			});
+			if (executed !== expected) throw new Error(`Fig internal parity error: the commit index executed ${executed} ${hookKindNames[phase]} effect(s) where the tree walk found ${expected}.`);
+		}
+	}
+	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 & ~StaticFlagsMask) !== 0;
+		});
+	}
+	function clearHiddenSubtreeFlags(node) {
+		walkFiberForest(node, (cursor) => {
+			const adopted = (cursor.flags & 16) !== 0;
+			const subtreeFlags = cursor.subtreeFlags;
+			clearTransientFlags(cursor);
+			return !adopted && (subtreeFlags & -12289) !== 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 visitEffects(node, visitor) {
+		walkFiberForest(node, (cursor) => {
+			for (const effect of cursor.effects ?? []) visitor(effect);
+			return (cursor.flags & 16) === 0 && !isHiddenBoundary(cursor) && (cursor.subtreeFlags & 512) !== 0;
+		});
+	}
+	function visitFiberHooks(node, visitor) {
+		walkFiberForest(node, (cursor) => {
+			for (let hook = cursor.memoizedState; hook !== null; hook = hook.next) visitor(cursor, hook);
+		});
+	}
+	function visitRenderedFiberHooks(node, visitor) {
+		walkFiberForest(node, (cursor) => {
+			for (let hook = cursor.memoizedState; hook !== null; hook = hook.next) visitor(cursor, hook);
+			return (cursor.flags & 16) === 0;
+		});
+	}
+	function isExternalStoreHook(hook) {
+		return hook.kind === 7;
+	}
+	function runEffect(effect) {
+		let runStrict = false;
+		runStrict = !effect.strictRan;
+		effect.strictRan = true;
+		abortEffect(effect);
+		let controller = new AbortController();
+		effect.controller = controller;
+		const dataStore = rootOf(effect.owner).dataStore;
+		try {
+			dataStore.run(() => effect.create(controller.signal));
+			if (runStrict) {
+				abortEffect(effect);
+				controller = new AbortController();
+				effect.controller = controller;
+				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 observeDiscardedPromiseChildren(node) {
+	if (Array.isArray(node)) {
+		for (const child of node) observeDiscardedPromiseChildren(child);
+		return;
+	}
+	if (isValidElement(node)) {
+		observeDiscardedPromiseChildren(node.props.children);
+		return;
+	}
+	if (isPortal(node)) {
+		observeDiscardedPromiseChildren(node.children);
+		return;
+	}
+	if (isThenable(node)) trackThenable(node);
+}
+function activityHidden(props) {
+	return props.mode === "hidden";
+}
+function hookKindName(kind) {
+	return hookKindNames[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,
+			runner: null,
+			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 matchesComponentFamily(fiber.type, child.type);
+	return isThenable(child) && fiber.tag === 12;
+}
+function propsFor(child) {
+	if (typeof child === "string") return { nodeValue: child };
+	if (isPortal(child)) return portalProps(child);
+	if (isValidElement(child)) return child.props;
+	if (isThenable(child)) return { thenable: child };
+	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 { createRenderer, runWithEventPriority };
+
+//# sourceMappingURL=index.js.map