@react-devtools-plus/kit 0.2.0

package/dist/index.cjs

@@ -0,0 +1,3732 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target$1) => (target$1 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target$1, "default", {
+	value: mod,
+	enumerable: true
+}) : target$1, mod));
+
+//#endregion
+let __react_devtools_plus_shared = require("@react-devtools-plus/shared");
+__react_devtools_plus_shared = __toESM(__react_devtools_plus_shared);
+
+//#region src/types/index.ts
+const REACT_TAGS = {
+	FunctionComponent: 0,
+	ClassComponent: 1,
+	IndeterminateComponent: 2,
+	HostRoot: 3,
+	HostComponent: 5,
+	HostText: 6,
+	Fragment: 7,
+	Mode: 8,
+	ContextConsumer: 9,
+	ContextProvider: 10,
+	ForwardRef: 11,
+	SuspenseComponent: 13,
+	MemoComponent: 14,
+	SimpleMemoComponent: 15
+};
+
+//#endregion
+//#region src/core/fiber/utils.ts
+function getDisplayName(fiber) {
+	var _resolvedType$render;
+	const { elementType, type, tag } = fiber;
+	const resolvedType = elementType || type;
+	if (!resolvedType) {
+		if (tag === REACT_TAGS.HostRoot) return "Root";
+		if (tag === REACT_TAGS.HostComponent) return typeof fiber.type === "string" ? fiber.type : "Host";
+		return "Unknown";
+	}
+	if (typeof resolvedType === "string") return resolvedType;
+	if (resolvedType.displayName) return resolvedType.displayName;
+	if (resolvedType.name) return resolvedType.name;
+	if (resolvedType.__name) return resolvedType.__name;
+	if (resolvedType.type) {
+		const innerType = resolvedType.type;
+		if (innerType === null || innerType === void 0 ? void 0 : innerType.displayName) return innerType.displayName;
+		if (innerType === null || innerType === void 0 ? void 0 : innerType.name) return innerType.name;
+		if (innerType === null || innerType === void 0 ? void 0 : innerType.__name) return innerType.__name;
+	}
+	if ((_resolvedType$render = resolvedType.render) === null || _resolvedType$render === void 0 ? void 0 : _resolvedType$render.name) return resolvedType.render.name;
+	if (typeof resolvedType === "function") {
+		const funcName = resolvedType.name;
+		if (funcName && funcName !== "") return funcName;
+	}
+	return "Anonymous";
+}
+function shouldIncludeFiber(fiber, showHostComponents) {
+	if (fiber.tag === REACT_TAGS.HostText) return false;
+	if (fiber.tag === REACT_TAGS.Fragment || fiber.tag === REACT_TAGS.Mode || fiber.tag === REACT_TAGS.HostRoot) return false;
+	if (!showHostComponents && fiber.tag === REACT_TAGS.HostComponent) return false;
+	return [
+		REACT_TAGS.HostComponent,
+		REACT_TAGS.FunctionComponent,
+		REACT_TAGS.ClassComponent,
+		REACT_TAGS.ForwardRef,
+		REACT_TAGS.MemoComponent,
+		REACT_TAGS.SimpleMemoComponent,
+		REACT_TAGS.IndeterminateComponent,
+		REACT_TAGS.ContextProvider,
+		REACT_TAGS.ContextConsumer,
+		REACT_TAGS.SuspenseComponent
+	].includes(fiber.tag);
+}
+let fiberIdCounter = 0;
+const fiberIdMap = /* @__PURE__ */ new WeakMap();
+function getFiberId(fiber) {
+	if (!fiberIdMap.has(fiber)) fiberIdMap.set(fiber, `react-fiber-${++fiberIdCounter}`);
+	return fiberIdMap.get(fiber);
+}
+function getFiberFromElement(element) {
+	const keys = Object.keys(element);
+	for (const key of keys) {
+		if (key.startsWith("__reactFiber")) return element[key];
+		if (key.startsWith("__reactInternalInstance")) return element[key];
+	}
+	return null;
+}
+
+//#endregion
+//#region src/core/context/index.ts
+/**
+* Serialize a value into a displayable PropValue
+*/
+function serializeValue$1(value, depth = 0, maxDepth = 6) {
+	if (value === null) return {
+		type: "null",
+		value: "null"
+	};
+	if (value === void 0) return {
+		type: "undefined",
+		value: "undefined"
+	};
+	const type = typeof value;
+	if (type === "string") return {
+		type: "string",
+		value: `"${value.length > 100 ? `${value.slice(0, 100)}...` : value}"`
+	};
+	if (type === "number") return {
+		type: "number",
+		value: String(value)
+	};
+	if (type === "boolean") return {
+		type: "boolean",
+		value: String(value)
+	};
+	if (type === "function") return {
+		type: "function",
+		value: `ƒ ${value.name || "anonymous"}()`
+	};
+	if (type === "symbol") return {
+		type: "symbol",
+		value: value.toString()
+	};
+	if (depth > maxDepth) {
+		if (Array.isArray(value)) return {
+			type: "array",
+			value: `Array(${value.length})`
+		};
+		return {
+			type: "object",
+			value: "Object"
+		};
+	}
+	if (Array.isArray(value)) {
+		const children = {};
+		value.forEach((item, index) => {
+			children[String(index)] = serializeValue$1(item, depth + 1, maxDepth);
+		});
+		return {
+			type: "array",
+			value: `Array(${value.length})`,
+			children: Object.keys(children).length > 0 ? children : void 0
+		};
+	}
+	if (type === "object") {
+		if (value.$$typeof) {
+			var _value$type, _value$type2;
+			return {
+				type: "element",
+				value: `<${((_value$type = value.type) === null || _value$type === void 0 ? void 0 : _value$type.displayName) || ((_value$type2 = value.type) === null || _value$type2 === void 0 ? void 0 : _value$type2.name) || value.type || "Unknown"} />`
+			};
+		}
+		const keys = Object.keys(value);
+		const children = {};
+		for (const key of keys) try {
+			children[key] = serializeValue$1(value[key], depth + 1, maxDepth);
+		} catch (_unused) {
+			children[key] = {
+				type: "unknown",
+				value: "[Error]"
+			};
+		}
+		return {
+			type: "object",
+			value: `Object`,
+			preview: keys.length > 0 ? `{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", ..." : ""}}` : "{}",
+			children: Object.keys(children).length > 0 ? children : void 0
+		};
+	}
+	return {
+		type: "unknown",
+		value: String(value)
+	};
+}
+/**
+* Get the display name of a Context
+*/
+function getContextDisplayName(fiber) {
+	var _fiber$type, _contextType$Provider, _contextType$Consumer;
+	const contextType = ((_fiber$type = fiber.type) === null || _fiber$type === void 0 ? void 0 : _fiber$type._context) || fiber.type;
+	if (!contextType) return "Unknown Context";
+	if (contextType.displayName) return contextType.displayName;
+	if ((_contextType$Provider = contextType.Provider) === null || _contextType$Provider === void 0 ? void 0 : _contextType$Provider.displayName) return contextType.Provider.displayName.replace(".Provider", "");
+	if ((_contextType$Consumer = contextType.Consumer) === null || _contextType$Consumer === void 0 ? void 0 : _contextType$Consumer.displayName) return contextType.Consumer.displayName.replace(".Consumer", "");
+	const componentName = getDisplayName(fiber);
+	if (componentName && componentName !== "Anonymous") return componentName.replace(".Provider", "").replace(".Consumer", "");
+	return "Context";
+}
+/**
+* Get the context value from a Provider fiber
+*/
+function getContextValue(fiber) {
+	if (fiber.memoizedProps && "value" in fiber.memoizedProps) return fiber.memoizedProps.value;
+}
+/**
+* Check if a fiber is a Context Provider
+*/
+function isContextProvider(fiber) {
+	return fiber.tag === REACT_TAGS.ContextProvider;
+}
+/**
+* Find all consumers of a specific context type
+*/
+function findConsumers(fiber, contextType, consumers, visited) {
+	if (!fiber || visited.has(fiber)) return;
+	visited.add(fiber);
+	if (fiber.tag === REACT_TAGS.ContextConsumer) {
+		var _fiber$type2;
+		if ((((_fiber$type2 = fiber.type) === null || _fiber$type2 === void 0 ? void 0 : _fiber$type2._context) || fiber.type) === contextType) consumers.push({
+			id: getFiberId(fiber),
+			name: getDisplayName(fiber),
+			fiberId: getFiberId(fiber)
+		});
+	}
+	if (fiber.tag === REACT_TAGS.FunctionComponent || fiber.tag === REACT_TAGS.ForwardRef || fiber.tag === REACT_TAGS.MemoComponent || fiber.tag === REACT_TAGS.SimpleMemoComponent) {
+		let hookState = fiber.memoizedState;
+		while (hookState) {
+			if (hookState.memoizedState !== void 0) {
+				const dependencies = fiber.dependencies;
+				if (dependencies === null || dependencies === void 0 ? void 0 : dependencies.firstContext) {
+					let contextItem = dependencies.firstContext;
+					while (contextItem) {
+						if (contextItem.context === contextType) {
+							consumers.push({
+								id: getFiberId(fiber),
+								name: getDisplayName(fiber),
+								fiberId: getFiberId(fiber)
+							});
+							break;
+						}
+						contextItem = contextItem.next;
+					}
+				}
+			}
+			hookState = hookState.next;
+		}
+	}
+	if (fiber.child) findConsumers(fiber.child, contextType, consumers, visited);
+	if (fiber.sibling) findConsumers(fiber.sibling, contextType, consumers, visited);
+}
+/**
+* Build context provider info from a fiber
+*/
+function buildProviderInfo(fiber, visited) {
+	var _fiber$type3;
+	if (!isContextProvider(fiber)) return null;
+	const contextType = (_fiber$type3 = fiber.type) === null || _fiber$type3 === void 0 ? void 0 : _fiber$type3._context;
+	const consumers = [];
+	if (fiber.child) findConsumers(fiber.child, contextType, consumers, /* @__PURE__ */ new WeakSet());
+	const uniqueConsumers = consumers.filter((consumer, index, self) => index === self.findIndex((c) => c.id === consumer.id));
+	const info = {
+		id: getFiberId(fiber),
+		name: getContextDisplayName(fiber),
+		value: serializeValue$1(getContextValue(fiber)),
+		fiberId: getFiberId(fiber),
+		consumerCount: uniqueConsumers.length,
+		consumers: uniqueConsumers,
+		children: [],
+		source: fiber._debugSource ? {
+			fileName: fiber._debugSource.fileName,
+			lineNumber: fiber._debugSource.lineNumber,
+			columnNumber: fiber._debugSource.columnNumber
+		} : void 0
+	};
+	const findNestedProviders = (child) => {
+		var _child$type;
+		if (!child || visited.has(child)) return;
+		visited.add(child);
+		if (isContextProvider(child) && ((_child$type = child.type) === null || _child$type === void 0 ? void 0 : _child$type._context) === contextType) {
+			const nestedInfo = buildProviderInfo(child, visited);
+			if (nestedInfo) info.children.push(nestedInfo);
+		} else {
+			if (child.child) findNestedProviders(child.child);
+			if (child.sibling) findNestedProviders(child.sibling);
+		}
+	};
+	if (fiber.child) findNestedProviders(fiber.child);
+	return info;
+}
+/**
+* Collect all context providers from the fiber tree
+*/
+function collectProviders(fiber, providers, visited, processedContextTypes) {
+	if (!fiber || visited.has(fiber)) return;
+	visited.add(fiber);
+	if (isContextProvider(fiber)) {
+		var _fiber$type4;
+		const contextType = (_fiber$type4 = fiber.type) === null || _fiber$type4 === void 0 ? void 0 : _fiber$type4._context;
+		if (contextType && !processedContextTypes.has(contextType)) {
+			const info = buildProviderInfo(fiber, new WeakSet([fiber]));
+			if (info) {
+				providers.push(info);
+				processedContextTypes.add(contextType);
+			}
+		}
+	}
+	if (fiber.child) collectProviders(fiber.child, providers, visited, processedContextTypes);
+	if (fiber.sibling) collectProviders(fiber.sibling, providers, visited, processedContextTypes);
+}
+/**
+* Get the context tree from a fiber root
+*/
+function getContextTree(root) {
+	var _root$current;
+	const providers = [];
+	const visited = /* @__PURE__ */ new WeakSet();
+	const processedContextTypes = /* @__PURE__ */ new Set();
+	if (root === null || root === void 0 || (_root$current = root.current) === null || _root$current === void 0 ? void 0 : _root$current.child) collectProviders(root.current.child, providers, visited, processedContextTypes);
+	let totalConsumers = 0;
+	const countConsumers = (providerList) => {
+		for (const provider of providerList) {
+			totalConsumers += provider.consumerCount;
+			if (provider.children.length > 0) countConsumers(provider.children);
+		}
+	};
+	countConsumers(providers);
+	return {
+		providers,
+		totalProviders: providers.length,
+		totalConsumers
+	};
+}
+/**
+* Get context info for a specific provider by fiber ID
+*/
+function getContextProviderInfo(root, fiberId) {
+	const tree = getContextTree(root);
+	const findProvider = (providers) => {
+		for (const provider of providers) {
+			if (provider.fiberId === fiberId) return provider;
+			const found = findProvider(provider.children);
+			if (found) return found;
+		}
+		return null;
+	};
+	return findProvider(tree.providers);
+}
+/**
+* Get all contexts available in the application
+*/
+function getAllContexts(root) {
+	return getContextTree(root);
+}
+
+//#endregion
+//#region src/core/fiber/details.ts
+/**
+* Serialize a value into a displayable PropValue
+*/
+function serializeValue(value, depth = 0, maxDepth = 8) {
+	if (value === null) return {
+		type: "null",
+		value: "null"
+	};
+	if (value === void 0) return {
+		type: "undefined",
+		value: "undefined"
+	};
+	const type = typeof value;
+	if (type === "string") return {
+		type: "string",
+		value: `"${value.length > 100 ? `${value.slice(0, 100)}...` : value}"`
+	};
+	if (type === "number") return {
+		type: "number",
+		value: String(value)
+	};
+	if (type === "boolean") return {
+		type: "boolean",
+		value: String(value)
+	};
+	if (type === "function") return {
+		type: "function",
+		value: `ƒ ${value.name || "anonymous"}()`
+	};
+	if (type === "symbol") return {
+		type: "symbol",
+		value: value.toString()
+	};
+	if (depth > maxDepth) {
+		if (Array.isArray(value)) return {
+			type: "array",
+			value: `Array(${value.length})`
+		};
+		return {
+			type: "object",
+			value: "Object"
+		};
+	}
+	if (Array.isArray(value)) {
+		const children = {};
+		value.forEach((item, index) => {
+			children[String(index)] = serializeValue(item, depth + 1, maxDepth);
+		});
+		return {
+			type: "array",
+			value: `Array(${value.length})`,
+			children: Object.keys(children).length > 0 ? children : void 0
+		};
+	}
+	if (type === "object") {
+		if (value.$$typeof) {
+			var _value$type, _value$type2;
+			return {
+				type: "element",
+				value: `<${((_value$type = value.type) === null || _value$type === void 0 ? void 0 : _value$type.displayName) || ((_value$type2 = value.type) === null || _value$type2 === void 0 ? void 0 : _value$type2.name) || value.type || "Unknown"} />`
+			};
+		}
+		const keys = Object.keys(value);
+		const children = {};
+		for (const key of keys) try {
+			children[key] = serializeValue(value[key], depth + 1, maxDepth);
+		} catch (_unused) {
+			children[key] = {
+				type: "unknown",
+				value: "[Error]"
+			};
+		}
+		return {
+			type: "object",
+			value: `Object`,
+			preview: keys.length > 0 ? `{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", ..." : ""}}` : "{}",
+			children: Object.keys(children).length > 0 ? children : void 0
+		};
+	}
+	return {
+		type: "unknown",
+		value: String(value)
+	};
+}
+/**
+* Extract props from fiber
+*/
+function extractProps(fiber) {
+	const props = {};
+	const memoizedProps = fiber.memoizedProps;
+	if (!memoizedProps || typeof memoizedProps !== "object") return props;
+	for (const [key, value] of Object.entries(memoizedProps)) {
+		if (key === "children") {
+			if (value) if (Array.isArray(value)) props[key] = {
+				type: "array",
+				value: `[${value.length} children]`
+			};
+			else if (typeof value === "object" && value.$$typeof) {
+				var _type, _type2;
+				props[key] = {
+					type: "element",
+					value: `<${((_type = value.type) === null || _type === void 0 ? void 0 : _type.displayName) || ((_type2 = value.type) === null || _type2 === void 0 ? void 0 : _type2.name) || value.type || "Element"} />`
+				};
+			} else if (typeof value === "string") props[key] = {
+				type: "string",
+				value: `"${value.slice(0, 50)}${value.length > 50 ? "..." : ""}"`
+			};
+			else props[key] = serializeValue(value);
+			continue;
+		}
+		props[key] = serializeValue(value);
+	}
+	return props;
+}
+/**
+* Hook type names from React internals
+*/
+const HOOK_NAMES = {
+	0: "useState",
+	1: "useReducer",
+	2: "useContext",
+	3: "useRef",
+	4: "useEffect",
+	5: "useInsertionEffect",
+	6: "useLayoutEffect",
+	7: "useCallback",
+	8: "useMemo",
+	9: "useImperativeHandle",
+	10: "useDebugValue",
+	11: "useDeferredValue",
+	12: "useTransition",
+	13: "useMutableSource",
+	14: "useSyncExternalStore",
+	15: "useId",
+	16: "useCacheRefresh"
+};
+/**
+* Extract hooks from fiber's memoizedState
+*/
+function extractHooks(fiber) {
+	const hooks = [];
+	if (fiber.tag !== REACT_TAGS.FunctionComponent && fiber.tag !== REACT_TAGS.ForwardRef && fiber.tag !== REACT_TAGS.SimpleMemoComponent && fiber.tag !== REACT_TAGS.MemoComponent) return hooks;
+	const debugHookTypes = fiber._debugHookTypes;
+	let hookState = fiber.memoizedState;
+	let hookIndex = 0;
+	while (hookState) {
+		let hookName = "Hook";
+		if (debugHookTypes && debugHookTypes[hookIndex]) hookName = debugHookTypes[hookIndex];
+		else if (hookState.tag !== void 0 && HOOK_NAMES[hookState.tag]) hookName = HOOK_NAMES[hookState.tag];
+		else if (hookState.queue !== void 0 && hookState.baseState !== void 0) hookName = "useState";
+		else if (hookState.memoizedState !== void 0 && hookState.deps !== void 0) hookName = "useMemo/useCallback";
+		else if (hookState.current !== void 0) hookName = "useRef";
+		let value;
+		if (hookName === "useState" || hookName === "useReducer") value = serializeValue(hookState.memoizedState);
+		else if (hookName === "useRef") {
+			var _hookState$memoizedSt;
+			value = serializeValue((_hookState$memoizedSt = hookState.memoizedState) === null || _hookState$memoizedSt === void 0 ? void 0 : _hookState$memoizedSt.current);
+		} else if (hookName === "useContext") value = serializeValue(hookState.memoizedState);
+		else if (hookName === "useMemo" || hookName === "useCallback" || hookName === "useMemo/useCallback") {
+			const memoValue = hookState.memoizedState;
+			if (Array.isArray(memoValue) && memoValue.length >= 1) value = serializeValue(memoValue[0]);
+			else value = serializeValue(memoValue);
+		} else value = {
+			type: "unknown",
+			value: "..."
+		};
+		hooks.push({
+			name: hookName,
+			value
+		});
+		hookState = hookState.next;
+		hookIndex++;
+	}
+	return hooks;
+}
+/**
+* Extract parent component chain (rendered by)
+*/
+function extractRenderedBy(fiber) {
+	const renderedBy = [];
+	let parent = fiber.return;
+	let depth = 0;
+	const maxDepth = 10;
+	while (parent && depth < maxDepth) {
+		if (parent.tag === REACT_TAGS.FunctionComponent || parent.tag === REACT_TAGS.ClassComponent || parent.tag === REACT_TAGS.ForwardRef || parent.tag === REACT_TAGS.MemoComponent || parent.tag === REACT_TAGS.SimpleMemoComponent || parent.tag === REACT_TAGS.ContextProvider) {
+			const name = getDisplayName(parent);
+			if (name && name !== "Anonymous") renderedBy.push({
+				id: getFiberId(parent),
+				name,
+				tag: parent.tag
+			});
+		}
+		parent = parent.return;
+		depth++;
+	}
+	return renderedBy;
+}
+/**
+* Extract source location from fiber
+*/
+function extractSource(fiber) {
+	if (fiber._debugSource) return {
+		fileName: fiber._debugSource.fileName,
+		lineNumber: fiber._debugSource.lineNumber,
+		columnNumber: fiber._debugSource.columnNumber
+	};
+}
+/**
+* Get detailed information about a component from its fiber
+*/
+function getComponentDetails(fiber) {
+	return {
+		id: getFiberId(fiber),
+		name: getDisplayName(fiber),
+		tag: fiber.tag,
+		props: extractProps(fiber),
+		hooks: extractHooks(fiber),
+		renderedBy: extractRenderedBy(fiber),
+		source: extractSource(fiber),
+		key: fiber.key
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/core/fiber/highlight.ts
+const CONTAINER_ELEMENT_ID = "__react-devtools-component-inspector__";
+const CARD_ELEMENT_ID = "__react-devtools-component-inspector__card__";
+const COMPONENT_NAME_ELEMENT_ID = "__react-devtools-component-inspector__name__";
+const INDICATOR_ELEMENT_ID = "__react-devtools-component-inspector__indicator__";
+const SOURCE_FILE_ELEMENT_ID = "__react-devtools-component-inspector__source-file__";
+const SOURCE_HINT_ELEMENT_ID = "__react-devtools-component-inspector__source-hint__";
+let highlightHideTimer;
+const containerStyles = {
+	display: "block",
+	zIndex: "2147483640",
+	position: "fixed",
+	backgroundColor: "color-mix(in srgb, var(--color-primary-500, #61dafb), transparent 85%)",
+	border: "1px solid color-mix(in srgb, var(--color-primary-500, #61dafb), transparent 50%)",
+	borderRadius: "5px",
+	transition: "all 0.1s ease-in",
+	pointerEvents: "none"
+};
+const baseCardStyles = {
+	fontFamily: "Arial, Helvetica, sans-serif",
+	padding: "5px 8px",
+	borderRadius: "4px",
+	textAlign: "left",
+	position: "absolute",
+	left: "0",
+	color: "#fff",
+	fontSize: "14px",
+	fontWeight: "600",
+	lineHeight: "24px",
+	backgroundColor: "var(--color-primary-500, #61dafb)",
+	boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)",
+	whiteSpace: "nowrap"
+};
+const cardStyles = _objectSpread2({}, baseCardStyles);
+const sourceCardStyles = _objectSpread2(_objectSpread2({}, baseCardStyles), {}, {
+	fontFamily: "Menlo, Monaco, Consolas, \"Courier New\", monospace",
+	padding: "6px 10px",
+	boxShadow: "0 4px 12px rgba(0, 0, 0, 0.15)",
+	display: "flex",
+	flexDirection: "column",
+	gap: "2px"
+});
+const indicatorStyles = {
+	display: "inline-block",
+	fontWeight: "400",
+	fontStyle: "normal",
+	fontSize: "12px",
+	opacity: "0.7",
+	marginLeft: "6px"
+};
+const sourceFileStyles = {
+	fontSize: "12px",
+	fontWeight: "500"
+};
+const sourceHintStyles = {
+	fontSize: "10px",
+	opacity: "0.8",
+	fontWeight: "normal"
+};
+function getContainerElement() {
+	return document.getElementById(CONTAINER_ELEMENT_ID);
+}
+function createHighlightElement(rect, name, source) {
+	const containerEl = document.createElement("div");
+	containerEl.id = CONTAINER_ELEMENT_ID;
+	Object.assign(containerEl.style, containerStyles);
+	const cardEl = document.createElement("div");
+	cardEl.id = CARD_ELEMENT_ID;
+	if (source) {
+		Object.assign(cardEl.style, sourceCardStyles);
+		const sourceFileEl = document.createElement("div");
+		sourceFileEl.id = SOURCE_FILE_ELEMENT_ID;
+		Object.assign(sourceFileEl.style, sourceFileStyles);
+		cardEl.appendChild(sourceFileEl);
+		const sourceHintEl = document.createElement("div");
+		sourceHintEl.id = SOURCE_HINT_ELEMENT_ID;
+		Object.assign(sourceHintEl.style, sourceHintStyles);
+		sourceHintEl.textContent = "Click to go to the file";
+		cardEl.appendChild(sourceHintEl);
+	} else {
+		Object.assign(cardEl.style, cardStyles);
+		const nameEl = document.createElement("span");
+		nameEl.id = COMPONENT_NAME_ELEMENT_ID;
+		cardEl.appendChild(nameEl);
+		const indicatorEl = document.createElement("i");
+		indicatorEl.id = INDICATOR_ELEMENT_ID;
+		Object.assign(indicatorEl.style, indicatorStyles);
+		cardEl.appendChild(indicatorEl);
+	}
+	containerEl.appendChild(cardEl);
+	document.body.appendChild(containerEl);
+	updateHighlightElement(rect, name, source);
+	return containerEl;
+}
+function updateHighlightElement(rect, name, source) {
+	let containerEl = getContainerElement();
+	const cardEl = document.getElementById(CARD_ELEMENT_ID);
+	const hasSourceElement = document.getElementById(SOURCE_FILE_ELEMENT_ID);
+	if (containerEl && (!!source && !hasSourceElement || !source && hasSourceElement)) {
+		containerEl.remove();
+		containerEl = null;
+	}
+	if (!containerEl) {
+		createHighlightElement(rect, name, source);
+		return;
+	}
+	Object.assign(containerEl.style, {
+		left: `${Math.round(rect.left * 100) / 100}px`,
+		top: `${Math.round(rect.top * 100) / 100}px`,
+		width: `${Math.round(rect.width * 100) / 100}px`,
+		height: `${Math.round(rect.height * 100) / 100}px`,
+		display: "block",
+		opacity: "1",
+		backgroundColor: "color-mix(in srgb, var(--color-primary-500, #61dafb), transparent 85%)",
+		border: "1px solid color-mix(in srgb, var(--color-primary-500, #61dafb), transparent 50%)"
+	});
+	if (cardEl) Object.assign(cardEl.style, {
+		top: rect.top < 45 ? "100%" : "auto",
+		bottom: rect.top < 45 ? "auto" : "100%",
+		marginTop: rect.top < 45 ? "4px" : "0",
+		marginBottom: rect.top < 45 ? "0" : "4px"
+	});
+	if (source) {
+		const sourceFileEl = document.getElementById(SOURCE_FILE_ELEMENT_ID);
+		if (sourceFileEl) {
+			let cleanFileName = source.fileName;
+			const segments = cleanFileName.split("/");
+			const srcIndex = segments.findIndex((seg) => seg === "src");
+			if (srcIndex > 0) cleanFileName = segments.slice(srcIndex).join("/");
+			else if (segments.length > 1 && !cleanFileName.startsWith("/")) cleanFileName = segments.slice(1).join("/");
+			sourceFileEl.textContent = `${cleanFileName}:${source.lineNumber}:${source.columnNumber}`;
+		}
+	} else {
+		const nameEl = document.getElementById(COMPONENT_NAME_ELEMENT_ID);
+		if (nameEl) nameEl.textContent = name === "Element" ? "Element" : `<${name}>`;
+		const indicatorEl = document.getElementById(INDICATOR_ELEMENT_ID);
+		if (indicatorEl) indicatorEl.textContent = `${Math.round(rect.width * 100) / 100} x ${Math.round(rect.height * 100) / 100}`;
+	}
+}
+function hideHighlight() {
+	const highlight = getContainerElement();
+	if (!highlight) return;
+	window.clearTimeout(highlightHideTimer);
+	highlight.style.opacity = "0";
+	highlightHideTimer = window.setTimeout(() => {
+		highlight.style.display = "none";
+	}, 150);
+}
+function showHighlight(rect, name, source) {
+	const highlight = getContainerElement();
+	window.clearTimeout(highlightHideTimer);
+	if (highlight) updateHighlightElement(rect, name, source);
+	else createHighlightElement(rect, name, source);
+}
+function mergeClientRects(rects) {
+	if (!rects.length) return null;
+	let top = Number.POSITIVE_INFINITY;
+	let left = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	let bottom = Number.NEGATIVE_INFINITY;
+	rects.forEach((rect) => {
+		top = Math.min(top, rect.top);
+		left = Math.min(left, rect.left);
+		right = Math.max(right, rect.right);
+		bottom = Math.max(bottom, rect.bottom);
+	});
+	return new DOMRect(left, top, Math.max(0, right - left), Math.max(0, bottom - top));
+}
+function isInOverlay(node) {
+	var _overlayContainer$con;
+	if (!node) return false;
+	const overlayContainer = document.getElementById("react-devtools-overlay");
+	return (_overlayContainer$con = overlayContainer === null || overlayContainer === void 0 ? void 0 : overlayContainer.contains(node)) !== null && _overlayContainer$con !== void 0 ? _overlayContainer$con : false;
+}
+function collectHostElements(fiber, elements, visited = /* @__PURE__ */ new WeakSet()) {
+	if (!fiber || visited.has(fiber)) return;
+	visited.add(fiber);
+	if (fiber.stateNode && isInOverlay(fiber.stateNode)) return;
+	if (fiber.tag === REACT_TAGS.HostComponent && fiber.stateNode instanceof Element) {
+		if (!isInOverlay(fiber.stateNode)) elements.add(fiber.stateNode);
+		return;
+	}
+	if (fiber.tag === REACT_TAGS.HostText) {
+		var _fiber$stateNode;
+		const parent = (_fiber$stateNode = fiber.stateNode) === null || _fiber$stateNode === void 0 ? void 0 : _fiber$stateNode.parentElement;
+		if (parent && !isInOverlay(parent)) elements.add(parent);
+		return;
+	}
+	let child = fiber.child;
+	while (child) {
+		collectHostElements(child, elements, visited);
+		child = child.sibling;
+	}
+}
+function highlightNode(fiber, source) {
+	if (!fiber) {
+		hideHighlight();
+		return;
+	}
+	if (fiber.tag === REACT_TAGS.HostComponent && fiber.stateNode instanceof Element) {
+		const element = fiber.stateNode;
+		const rect = element.getBoundingClientRect();
+		if (rect.width > 0 || rect.height > 0) {
+			showHighlight(rect, fiber.type || element.tagName.toLowerCase(), source);
+			return;
+		}
+	}
+	const elements = /* @__PURE__ */ new Set();
+	collectHostElements(fiber, elements);
+	if (elements.size === 0) {
+		hideHighlight();
+		return;
+	}
+	const merged = mergeClientRects(Array.from(elements).map((element) => element.getBoundingClientRect()).filter((rect) => rect.width > 0 || rect.height > 0));
+	if (!merged || merged.width === 0 && merged.height === 0) {
+		hideHighlight();
+		return;
+	}
+	showHighlight(merged, getDisplayName(fiber), source);
+}
+function cleanupHighlight() {
+	const el = getContainerElement();
+	el === null || el === void 0 || el.remove();
+	window.clearTimeout(highlightHideTimer);
+}
+/**
+* Scroll the page to make the component visible
+*/
+function scrollToNode(fiber) {
+	if (!fiber) return;
+	if (fiber.tag === REACT_TAGS.HostComponent && fiber.stateNode instanceof Element) {
+		fiber.stateNode.scrollIntoView({
+			behavior: "smooth",
+			block: "center",
+			inline: "center"
+		});
+		return;
+	}
+	const elements = /* @__PURE__ */ new Set();
+	collectHostElements(fiber, elements);
+	if (elements.size === 0) return;
+	const firstElement = Array.from(elements)[0];
+	if (firstElement) firstElement.scrollIntoView({
+		behavior: "smooth",
+		block: "center",
+		inline: "center"
+	});
+}
+
+//#endregion
+//#region src/core/fiber/tree.ts
+const fiberRegistry = /* @__PURE__ */ new Map();
+function getFiberById(id) {
+	return fiberRegistry.get(id);
+}
+function collectVisibleChildren(fiber, showHostComponents, nodes, visited) {
+	let current = fiber;
+	while (current) {
+		if (visited.has(current)) {
+			current = current.sibling;
+			continue;
+		}
+		if (shouldIncludeFiber(current, showHostComponents)) {
+			visited.add(current);
+			const treeChild = fiberToTree(current, showHostComponents, visited);
+			if (treeChild) nodes.push(treeChild);
+		} else if (current.child) collectVisibleChildren(current.child, showHostComponents, nodes, visited);
+		current = current.sibling;
+	}
+}
+function fiberToTree(fiber, showHostComponents, visited) {
+	if (!fiber) return null;
+	if (fiber.tag === REACT_TAGS.Mode || fiber.tag === REACT_TAGS.Fragment || fiber.tag === REACT_TAGS.HostRoot) return null;
+	const displayName = getDisplayName(fiber);
+	const node = {
+		id: getFiberId(fiber),
+		name: displayName,
+		children: [],
+		meta: { tag: fiber.tag }
+	};
+	fiberRegistry.set(node.id, fiber);
+	const childVisited = /* @__PURE__ */ new WeakSet();
+	collectVisibleChildren(fiber.child, showHostComponents, node.children, childVisited);
+	return node;
+}
+function buildTree(root, showHostComponents) {
+	if (!(root === null || root === void 0 ? void 0 : root.current)) return null;
+	const current = root.current;
+	const visited = /* @__PURE__ */ new WeakSet();
+	let fiber = current.child;
+	let depth = 0;
+	while (fiber && depth < 20) {
+		depth++;
+		if (fiber.tag === REACT_TAGS.Mode || fiber.tag === REACT_TAGS.Fragment || fiber.tag === REACT_TAGS.HostRoot) {
+			fiber = fiber.child || fiber.sibling;
+			continue;
+		}
+		if (shouldIncludeFiber(fiber, showHostComponents)) return fiberToTree(fiber, showHostComponents, visited);
+		if (fiber.child) {
+			fiber = fiber.child;
+			continue;
+		}
+		fiber = fiber.sibling;
+	}
+	return null;
+}
+function clearFiberRegistry() {
+	fiberRegistry.clear();
+}
+
+//#endregion
+//#region src/core/fiber/props.ts
+/** Stores overridden props for UI display */
+const overriddenProps = /* @__PURE__ */ new Map();
+/** Stores overridden context values for UI display */
+const overriddenContexts = /* @__PURE__ */ new Map();
+/**
+* Get the React renderer that has overrideProps API
+*
+* React DevTools hook may have multiple renderers. We need to find the one
+* that provides the official overrideProps API (React's native renderer).
+*/
+function getRenderer() {
+	const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	if (!(hook === null || hook === void 0 ? void 0 : hook.renderers)) return null;
+	for (const renderer of hook.renderers.values()) if (renderer === null || renderer === void 0 ? void 0 : renderer.overrideProps) return renderer;
+	for (const renderer of hook.renderers.values()) if (renderer) return renderer;
+	return null;
+}
+/**
+* Parse a string value to the appropriate JavaScript type
+*
+* @param value - The string representation of the value
+* @param expectedType - The expected type of the value
+* @returns The parsed value in the correct type
+*/
+function parseValue(value, expectedType) {
+	if (expectedType === "null" || expectedType === "undefined") {
+		if (value === "null") return null;
+		if (value === "undefined") return void 0;
+		return inferValueType(value);
+	}
+	switch (expectedType) {
+		case "number": return Number(value);
+		case "boolean": return value === "true";
+		case "object":
+		case "array": try {
+			return JSON.parse(value);
+		} catch (_unused) {
+			return value;
+		}
+		case "string":
+		default:
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+			return value;
+	}
+}
+/**
+* Infer the type of a value from its string representation
+*
+* Used when the original type is null/undefined and user enters a new value.
+*/
+function inferValueType(value) {
+	const trimmed = value.trim();
+	if (trimmed === "true") return true;
+	if (trimmed === "false") return false;
+	if (trimmed === "null") return null;
+	if (trimmed === "undefined") return void 0;
+	const num = Number(trimmed);
+	if (!Number.isNaN(num) && trimmed !== "") return num;
+	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
+		return JSON.parse(trimmed);
+	} catch (_unused2) {}
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+/**
+* Set a nested property on an object immutably
+*
+* @param obj - The source object
+* @param path - Array of keys representing the path to the property
+* @param value - The value to set
+* @returns A new object with the updated value
+*/
+function setNestedValue(obj, path, value) {
+	if (path.length === 0) return value;
+	const result = Array.isArray(obj) ? [...obj] : _objectSpread2({}, obj);
+	let current = result;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		const nextKey = path[i + 1];
+		const isNextArray = !Number.isNaN(Number(nextKey));
+		current[key] = current[key] ? Array.isArray(current[key]) ? [...current[key]] : _objectSpread2({}, current[key]) : isNextArray ? [] : {};
+		current = current[key];
+	}
+	current[path[path.length - 1]] = value;
+	return result;
+}
+/**
+* Force update a specific component and its ancestors
+*
+* Strategy:
+* 1. Try class component forceUpdate (safest)
+* 2. Try function component hooks with object/array state
+* 3. Try primitive state with toggle-and-restore
+*/
+function forceComponentUpdate(fiber) {
+	if (fiber.stateNode && typeof fiber.stateNode.forceUpdate === "function") try {
+		fiber.stateNode.forceUpdate();
+		return true;
+	} catch (_unused3) {}
+	let current = fiber;
+	let depth = 0;
+	while (current && depth < 50) {
+		if (current.stateNode && typeof current.stateNode.forceUpdate === "function") try {
+			current.stateNode.forceUpdate();
+			return true;
+		} catch (_unused4) {}
+		if (current.memoizedState !== null && typeof current.memoizedState === "object") {
+			if (tryDispatchStateUpdate(current.memoizedState)) return true;
+		}
+		current = current.return;
+		depth++;
+	}
+	return false;
+}
+/**
+* Try to dispatch a state update through hook state
+*/
+function tryDispatchStateUpdate(hookState) {
+	while (hookState) {
+		const queue = hookState.queue;
+		const currentState = hookState.memoizedState;
+		if (queue === null || queue === void 0 ? void 0 : queue.dispatch) try {
+			const dispatch = queue.dispatch;
+			if (currentState !== null && typeof currentState === "object") {
+				dispatch(Array.isArray(currentState) ? [...currentState] : _objectSpread2({}, currentState));
+				return true;
+			} else if (typeof currentState === "boolean") {
+				dispatch(!currentState);
+				setTimeout(() => dispatch(currentState), 0);
+				return true;
+			} else if (typeof currentState === "number") {
+				dispatch(currentState + 1e-7);
+				setTimeout(() => dispatch(currentState), 0);
+				return true;
+			}
+		} catch (_unused5) {}
+		hookState = hookState.next;
+	}
+	return false;
+}
+/**
+* Force update by finding any component in the tree with updatable state
+*/
+function forceGlobalUpdate() {
+	try {
+		const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+		if (!(hook === null || hook === void 0 ? void 0 : hook.renderers)) return false;
+		for (const [rendererID] of hook.renderers.entries()) {
+			var _hook$getFiberRoots;
+			const roots = (_hook$getFiberRoots = hook.getFiberRoots) === null || _hook$getFiberRoots === void 0 ? void 0 : _hook$getFiberRoots.call(hook, rendererID);
+			if (roots) {
+				for (const root of roots) if (root.current) {
+					if (findAndForceUpdate(root.current)) return true;
+				}
+			}
+		}
+	} catch (_unused6) {}
+	return false;
+}
+/**
+* Walk fiber tree to find a component that can be force-updated
+*/
+function findAndForceUpdate(fiber, depth = 0) {
+	if (!fiber || depth > 100) return false;
+	if (fiber.stateNode && typeof fiber.stateNode.forceUpdate === "function") try {
+		fiber.stateNode.forceUpdate();
+		return true;
+	} catch (_unused7) {}
+	if (fiber.memoizedState !== null && typeof fiber.memoizedState === "object") {
+		if (tryDispatchStateUpdate(fiber.memoizedState)) return true;
+	}
+	if (fiber.child && findAndForceUpdate(fiber.child, depth + 1)) return true;
+	if (fiber.sibling && findAndForceUpdate(fiber.sibling, depth + 1)) return true;
+	return false;
+}
+/**
+* Set a prop value on a component
+*
+* Uses React's official overrideProps API when available,
+* falls back to direct fiber manipulation otherwise.
+*
+* @param fiberId - The fiber ID of the component
+* @param propPath - Dot-separated path to the prop (e.g., "user.name")
+* @param value - The string representation of the new value
+* @param valueType - The expected type of the value
+* @returns Whether the operation succeeded
+*/
+function setComponentProp(fiberId, propPath, value, valueType) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) {
+		console.warn(`[React DevTools] Fiber not found: ${fiberId}`);
+		return false;
+	}
+	const parsedValue = parseValue(value, valueType);
+	const pathParts = propPath.split(".");
+	try {
+		if (!overriddenProps.has(fiberId)) overriddenProps.set(fiberId, /* @__PURE__ */ new Map());
+		overriddenProps.get(fiberId).set(propPath, parsedValue);
+		const renderer = getRenderer();
+		if (renderer === null || renderer === void 0 ? void 0 : renderer.overrideProps) try {
+			renderer.overrideProps(fiber, pathParts, parsedValue);
+			return true;
+		} catch (_unused8) {
+			const numericId = Number.parseInt(fiberId.replace("react-fiber-", ""), 10);
+			if (!Number.isNaN(numericId)) try {
+				renderer.overrideProps(numericId, pathParts, parsedValue);
+				return true;
+			} catch (_unused9) {}
+		}
+		const newProps = setNestedValue(fiber.memoizedProps || {}, pathParts, parsedValue);
+		fiber.memoizedProps = newProps;
+		fiber.pendingProps = newProps;
+		if (fiber.alternate) {
+			fiber.alternate.memoizedProps = newProps;
+			fiber.alternate.pendingProps = newProps;
+		}
+		forceComponentUpdate(fiber) || forceGlobalUpdate();
+		return true;
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set prop:", error);
+		return false;
+	}
+}
+/**
+* Get an overridden prop value for UI display
+*/
+function getOverriddenProp(fiberId, propPath) {
+	var _overriddenProps$get;
+	return (_overriddenProps$get = overriddenProps.get(fiberId)) === null || _overriddenProps$get === void 0 ? void 0 : _overriddenProps$get.get(propPath);
+}
+/**
+* Check if a prop is editable
+*
+* Some props cannot be edited (children, key, ref, etc.)
+* Some types cannot be edited (functions, symbols, elements)
+*/
+function isEditableProp(propName, valueType) {
+	if ([
+		"children",
+		"key",
+		"ref",
+		"$$typeof"
+	].includes(propName)) return false;
+	if ([
+		"element",
+		"function",
+		"symbol"
+	].includes(valueType)) return false;
+	return true;
+}
+/**
+* Set a Context Provider's value
+*
+* @param fiberId - The fiber ID of the Context Provider
+* @param value - The string representation of the new value
+* @param valueType - The expected type of the value
+* @returns Whether the operation succeeded
+*/
+function setContextValue(fiberId, value, valueType) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) {
+		console.warn(`[React DevTools] Fiber not found: ${fiberId}`);
+		return false;
+	}
+	if (fiber.tag !== REACT_TAGS.ContextProvider) {
+		console.warn(`[React DevTools] Fiber is not a Context Provider`);
+		return false;
+	}
+	try {
+		return applyContextValue(fiber, parseValue(value, valueType), fiberId);
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set context value:", error);
+		return false;
+	}
+}
+/**
+* Set a Context Provider's value from a JSON string
+*
+* Used for complex objects where JSON editing is more convenient.
+*/
+function setContextValueFromJson(fiberId, jsonValue) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) {
+		console.warn(`[React DevTools] Fiber not found: ${fiberId}`);
+		return false;
+	}
+	if (fiber.tag !== REACT_TAGS.ContextProvider) {
+		console.warn(`[React DevTools] Fiber is not a Context Provider`);
+		return false;
+	}
+	try {
+		return applyContextValue(fiber, JSON.parse(jsonValue), fiberId);
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set context value from JSON:", error);
+		return false;
+	}
+}
+/**
+* Set a nested property within a Context Provider's value
+*
+* @param fiberId - The fiber ID of the Context Provider
+* @param path - Dot-separated path to the property (e.g., "theme.mode")
+* @param value - The string representation of the new value
+* @param valueType - The expected type of the value
+* @returns Whether the operation succeeded
+*/
+function setContextValueAtPath(fiberId, path, value, valueType) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) {
+		console.warn(`[React DevTools] Fiber not found: ${fiberId}`);
+		return false;
+	}
+	if (fiber.tag !== REACT_TAGS.ContextProvider) {
+		console.warn(`[React DevTools] Fiber is not a Context Provider`);
+		return false;
+	}
+	try {
+		var _fiber$memoizedProps;
+		const parsedValue = parseValue(value, valueType);
+		const pathParts = path.split(".");
+		return applyContextValue(fiber, setNestedValue((_fiber$memoizedProps = fiber.memoizedProps) === null || _fiber$memoizedProps === void 0 ? void 0 : _fiber$memoizedProps.value, pathParts, parsedValue), fiberId);
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set context value at path:", error);
+		return false;
+	}
+}
+/**
+* Apply a value to a Context Provider
+*
+* Context Provider is essentially a component with a `value` prop.
+* We use overrideProps to modify this prop.
+*/
+function applyContextValue(fiber, newValue, fiberId) {
+	var _fiber$type;
+	overriddenContexts.set(fiberId, newValue);
+	const renderer = getRenderer();
+	if (renderer === null || renderer === void 0 ? void 0 : renderer.overrideProps) try {
+		renderer.overrideProps(fiber, ["value"], newValue);
+		return true;
+	} catch (_unused10) {
+		const numericId = Number.parseInt(fiberId.replace("react-fiber-", ""), 10);
+		if (!Number.isNaN(numericId)) try {
+			renderer.overrideProps(numericId, ["value"], newValue);
+			return true;
+		} catch (_unused11) {}
+	}
+	const newProps = _objectSpread2(_objectSpread2({}, fiber.memoizedProps || {}), {}, { value: newValue });
+	fiber.memoizedProps = newProps;
+	fiber.pendingProps = newProps;
+	if (fiber.alternate) {
+		fiber.alternate.memoizedProps = newProps;
+		fiber.alternate.pendingProps = newProps;
+	}
+	const contextType = (_fiber$type = fiber.type) === null || _fiber$type === void 0 ? void 0 : _fiber$type._context;
+	if (contextType) {
+		contextType._currentValue = newValue;
+		if ("_currentValue2" in contextType) contextType._currentValue2 = newValue;
+	}
+	forceComponentUpdate(fiber) || forceGlobalUpdate();
+	return true;
+}
+/**
+* Get an overridden context value for UI display
+*/
+function getOverriddenContext(fiberId) {
+	return overriddenContexts.get(fiberId);
+}
+/**
+* Clear all overrides
+*
+* Should be called when the page refreshes or DevTools disconnects.
+*/
+function clearOverrides() {
+	overriddenProps.clear();
+	overriddenContexts.clear();
+}
+
+//#endregion
+//#region src/core/fiber/state.ts
+/**
+* Get all useState/useReducer hooks from a component
+*/
+function getComponentHookStates(fiberId) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) return [];
+	if (fiber.tag !== REACT_TAGS.FunctionComponent && fiber.tag !== REACT_TAGS.ForwardRef && fiber.tag !== REACT_TAGS.SimpleMemoComponent && fiber.tag !== REACT_TAGS.MemoComponent) return [];
+	const states = [];
+	const debugHookTypes = fiber._debugHookTypes;
+	let hookState = fiber.memoizedState;
+	let index = 0;
+	while (hookState) {
+		var _hookState$queue;
+		if ((_hookState$queue = hookState.queue) === null || _hookState$queue === void 0 ? void 0 : _hookState$queue.dispatch) {
+			const hookName = (debugHookTypes === null || debugHookTypes === void 0 ? void 0 : debugHookTypes[index]) || "State";
+			const value = hookState.memoizedState;
+			const valueType = getValueType(value);
+			states.push({
+				index,
+				name: hookName,
+				value: serializeForDisplay(value),
+				type: valueType,
+				canEdit: isEditableType(valueType)
+			});
+		}
+		hookState = hookState.next;
+		index++;
+	}
+	return states;
+}
+/**
+* Set a hook state value
+* This directly calls the useState setter, which is the most reliable way to update React state
+*/
+function setHookState(fiberId, hookIndex, value, valueType) {
+	const fiber = getFiberById(fiberId);
+	if (!fiber) {
+		console.warn(`[React DevTools] Fiber not found: ${fiberId}`);
+		return false;
+	}
+	let hookState = fiber.memoizedState;
+	let currentIndex = 0;
+	let targetHook = null;
+	while (hookState) {
+		var _hookState$queue2;
+		if ((_hookState$queue2 = hookState.queue) === null || _hookState$queue2 === void 0 ? void 0 : _hookState$queue2.dispatch) {
+			if (currentIndex === hookIndex) {
+				targetHook = hookState;
+				break;
+			}
+			currentIndex++;
+		}
+		hookState = hookState.next;
+	}
+	if (!targetHook) {
+		console.warn(`[React DevTools] Hook at index ${hookIndex} not found`);
+		return false;
+	}
+	const dispatch = targetHook.queue.dispatch;
+	if (!dispatch) {
+		console.warn(`[React DevTools] Hook has no dispatch function`);
+		return false;
+	}
+	try {
+		dispatch(parseValue$1(value, valueType));
+		return true;
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set hook state:", error);
+		return false;
+	}
+}
+/**
+* Set a hook state value using JSON (for objects/arrays)
+*/
+function setHookStateFromJson(fiberId, hookIndex, jsonValue) {
+	try {
+		const parsedValue = JSON.parse(jsonValue);
+		const fiber = getFiberById(fiberId);
+		if (!fiber) return false;
+		let hookState = fiber.memoizedState;
+		let currentIndex = 0;
+		while (hookState) {
+			var _hookState$queue3;
+			if ((_hookState$queue3 = hookState.queue) === null || _hookState$queue3 === void 0 ? void 0 : _hookState$queue3.dispatch) {
+				if (currentIndex === hookIndex) {
+					hookState.queue.dispatch(parsedValue);
+					return true;
+				}
+				currentIndex++;
+			}
+			hookState = hookState.next;
+		}
+		return false;
+	} catch (error) {
+		console.warn("[React DevTools] Failed to set hook state from JSON:", error);
+		return false;
+	}
+}
+function getValueType(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function isEditableType(type) {
+	return [
+		"string",
+		"number",
+		"boolean",
+		"null",
+		"undefined",
+		"object",
+		"array"
+	].includes(type);
+}
+function parseValue$1(value, valueType) {
+	switch (valueType) {
+		case "number": return Number(value);
+		case "boolean": return value === "true";
+		case "null": return null;
+		case "undefined": return;
+		case "object":
+		case "array": try {
+			return JSON.parse(value);
+		} catch (_unused) {
+			return value;
+		}
+		case "string":
+		default:
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+			return value;
+	}
+}
+function serializeForDisplay(value) {
+	if (value === null) return null;
+	if (value === void 0) return void 0;
+	if (typeof value === "function") return `ƒ ${value.name || "anonymous"}()`;
+	if (typeof value === "symbol") return value.toString();
+	return value;
+}
+
+//#endregion
+//#region src/core/router/index.ts
+/**
+* Global variable to store the React fiber root reference
+*/
+let fiberRoot = null;
+/**
+* Navigation history storage
+*/
+const navigationHistory = [];
+let lastNavigationStart = null;
+let lastNavigationDuration;
+/**
+* Max history entries to keep
+*/
+const MAX_HISTORY_ENTRIES = 50;
+/**
+* Set the fiber root reference (called from hook)
+*/
+function setFiberRoot(root) {
+	fiberRoot = root;
+}
+/**
+* Get the current fiber root
+*/
+function getFiberRoot() {
+	return fiberRoot;
+}
+/**
+* Extract dynamic params from a path pattern
+*/
+function extractParamsFromPath(path) {
+	const params = [];
+	const regex = /:([^/]+)/g;
+	let match = regex.exec(path);
+	while (match !== null) {
+		params.push(match[1]);
+		match = regex.exec(path);
+	}
+	return params;
+}
+/**
+* Check if element is lazy loaded
+*/
+function isLazyElement(element) {
+	var _element$$$typeof, _element$type;
+	if (!element) return false;
+	if (((_element$$$typeof = element.$$typeof) === null || _element$$$typeof === void 0 ? void 0 : _element$$$typeof.toString()) === "Symbol(react.lazy)") return true;
+	if (((_element$type = element.type) === null || _element$type === void 0 || (_element$type = _element$type.$$typeof) === null || _element$type === void 0 ? void 0 : _element$type.toString()) === "Symbol(react.lazy)") return true;
+	return false;
+}
+/**
+* Get element name from React element
+*/
+function getElementName(element) {
+	var _element$type2, _element$type3, _element$type4;
+	if (!element) return void 0;
+	if (typeof element.type === "string") return element.type;
+	if ((_element$type2 = element.type) === null || _element$type2 === void 0 ? void 0 : _element$type2.name) return element.type.name;
+	if ((_element$type3 = element.type) === null || _element$type3 === void 0 ? void 0 : _element$type3.displayName) return element.type.displayName;
+	if ((_element$type4 = element.type) === null || _element$type4 === void 0 || (_element$type4 = _element$type4._payload) === null || _element$type4 === void 0 || (_element$type4 = _element$type4._result) === null || _element$type4 === void 0 ? void 0 : _element$type4.name) return element.type._payload._result.name;
+}
+/**
+* Extract route info from a React Router Route element (JSX props)
+*/
+function extractRouteFromElement(element, parentPath = "") {
+	if (!element || !element.props) return null;
+	const props = element.props;
+	const isIndex = props.index === true;
+	let fullPath = "";
+	if (isIndex) fullPath = parentPath || "/";
+	else if (props.path) {
+		props.path;
+		fullPath = props.path.startsWith("/") ? props.path : `${parentPath}/${props.path}`.replace(/\/+/g, "/");
+	} else fullPath = parentPath || "/";
+	const childRoutes = [];
+	if (props.children) {
+		const children = Array.isArray(props.children) ? props.children : [props.children];
+		for (const child of children) {
+			var _child$type;
+			if (child && child.type && (child.type.name === "Route" || ((_child$type = child.type) === null || _child$type === void 0 ? void 0 : _child$type.displayName) === "Route")) {
+				const childRoute = extractRouteFromElement(child, fullPath);
+				if (childRoute) childRoutes.push(childRoute);
+			}
+		}
+	}
+	const hasChildren = childRoutes.length > 0;
+	const params = extractParamsFromPath(props.path || "");
+	const routeInfo = {
+		path: fullPath || "/",
+		name: props.id || void 0,
+		element: getElementName(props.element),
+		isIndex,
+		isLayout: hasChildren,
+		hasLoader: !!props.loader,
+		hasAction: !!props.action,
+		isLazy: isLazyElement(props.element) || !!props.lazy,
+		hasErrorBoundary: !!props.errorElement || !!props.ErrorBoundary,
+		params: params.length > 0 ? params : void 0
+	};
+	if (hasChildren) routeInfo.children = childRoutes;
+	return routeInfo;
+}
+/**
+* Extract routes from Routes component's children prop
+*/
+function extractRoutesFromProps(props) {
+	const routes = [];
+	if (!(props === null || props === void 0 ? void 0 : props.children)) return routes;
+	const children = Array.isArray(props.children) ? props.children : [props.children];
+	for (const child of children) {
+		var _child$type2;
+		if (child && child.type && (child.type.name === "Route" || ((_child$type2 = child.type) === null || _child$type2 === void 0 ? void 0 : _child$type2.displayName) === "Route")) {
+			const route = extractRouteFromElement(child);
+			if (route) routes.push(route);
+		}
+	}
+	return routes;
+}
+/**
+* Extract route configuration from fiber tree
+*/
+function extractRoutesFromFiber(fiber) {
+	const routes = [];
+	const visited = /* @__PURE__ */ new WeakSet();
+	function traverse$1(node, parentPath = "") {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		const name = getDisplayName(node);
+		const props = node.memoizedProps || node.pendingProps;
+		if ((name === "Route" || name === "RenderedRoute" || name === "RouteContext.Provider") && props) {
+			var _props$value, _props$value2;
+			const match = props.match || ((_props$value = props.value) === null || _props$value === void 0 ? void 0 : _props$value.match);
+			const route = props.route || ((_props$value2 = props.value) === null || _props$value2 === void 0 ? void 0 : _props$value2.route);
+			if (match || route) {
+				var _route$element, _route$element2;
+				const routeInfo = {
+					path: (match === null || match === void 0 ? void 0 : match.pathname) || (route === null || route === void 0 ? void 0 : route.path) || parentPath || "/",
+					name: (route === null || route === void 0 ? void 0 : route.id) || void 0,
+					element: (route === null || route === void 0 || (_route$element = route.element) === null || _route$element === void 0 || (_route$element = _route$element.type) === null || _route$element === void 0 ? void 0 : _route$element.name) || (route === null || route === void 0 || (_route$element2 = route.element) === null || _route$element2 === void 0 || (_route$element2 = _route$element2.type) === null || _route$element2 === void 0 ? void 0 : _route$element2.displayName) || getElementName(props.element),
+					hasLoader: !!(route === null || route === void 0 ? void 0 : route.loader),
+					hasAction: !!(route === null || route === void 0 ? void 0 : route.action),
+					hasErrorBoundary: !!(route === null || route === void 0 ? void 0 : route.errorElement)
+				};
+				if (!routes.some((r) => r.path === routeInfo.path)) routes.push(routeInfo);
+			}
+		}
+		if (node.child) traverse$1(node.child, parentPath);
+		if (node.sibling) traverse$1(node.sibling, parentPath);
+	}
+	traverse$1(fiber);
+	return routes;
+}
+/**
+* Find Routes component and extract route configuration
+*/
+function findAndExtractRoutes(fiber) {
+	if (!fiber) return [];
+	const visited = /* @__PURE__ */ new WeakSet();
+	let routes = [];
+	function traverse$1(node) {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		const name = getDisplayName(node);
+		const props = node.memoizedProps || node.pendingProps;
+		if (name === "Routes") {
+			const propsRoutes = extractRoutesFromProps(props);
+			if (propsRoutes.length > 0) {
+				routes = propsRoutes;
+				return;
+			}
+		}
+		if (name === "DataRoutes" || name === "RoutesRenderer") {
+			const fiberRoutes = extractRoutesFromFiber(node);
+			if (fiberRoutes.length > 0) routes.push(...fiberRoutes);
+		}
+		if (node.child) traverse$1(node.child);
+		if (node.sibling) traverse$1(node.sibling);
+	}
+	traverse$1(fiber);
+	return routes;
+}
+/**
+* Match a path against a route pattern and extract params
+*/
+function matchPath(pattern, pathname) {
+	const params = {};
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = pathname.split("/").filter(Boolean);
+	if (patternParts.length === 0 && pathParts.length === 0) return {
+		matched: true,
+		params
+	};
+	let patternIndex = 0;
+	let pathIndex = 0;
+	while (patternIndex < patternParts.length && pathIndex < pathParts.length) {
+		const patternPart = patternParts[patternIndex];
+		const pathPart = pathParts[pathIndex];
+		if (patternPart.startsWith(":")) {
+			const paramName = patternPart.slice(1).replace("?", "");
+			params[paramName] = pathPart;
+		} else if (patternPart === "*") {
+			params["*"] = pathParts.slice(pathIndex).join("/");
+			return {
+				matched: true,
+				params
+			};
+		} else if (patternPart !== pathPart) return {
+			matched: false,
+			params: {}
+		};
+		patternIndex++;
+		pathIndex++;
+	}
+	while (patternIndex < patternParts.length) {
+		const part = patternParts[patternIndex];
+		if (!part.endsWith("?") && !part.startsWith(":")) return {
+			matched: false,
+			params: {}
+		};
+		patternIndex++;
+	}
+	return {
+		matched: true,
+		params
+	};
+}
+/**
+* Find matched routes for a given path
+*/
+function findMatchedRoutes(routes, pathname) {
+	const matched = [];
+	function findInRoutes(routeList, currentPath) {
+		for (const route of routeList) {
+			const { matched: isMatch, params } = matchPath(route.path, pathname);
+			if (isMatch) {
+				matched.push({
+					path: route.path,
+					params,
+					element: route.element
+				});
+				if (route.children && route.children.length > 0) findInRoutes(route.children, route.path);
+				if (route.path === pathname || route.isIndex) return true;
+			}
+		}
+		return matched.length > 0;
+	}
+	findInRoutes(routes, pathname);
+	return matched;
+}
+/**
+* Get current URL information
+*/
+function getCurrentUrlInfo() {
+	if (window.location.hash && window.location.hash.startsWith("#/")) {
+		const [pathAndSearch, hash] = window.location.hash.slice(1).split("#");
+		const [path, search] = (pathAndSearch || "/").split("?");
+		return {
+			path: path || "/",
+			search: search ? `?${search}` : "",
+			hash: hash ? `#${hash}` : ""
+		};
+	}
+	return {
+		path: window.location.pathname || "/",
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+}
+/**
+* Extract all params from matched routes
+*/
+function extractAllParams(matchedRoutes) {
+	const params = {};
+	for (const route of matchedRoutes) Object.assign(params, route.params);
+	return params;
+}
+/**
+* Detect router type from fiber tree
+*/
+function detectRouterType(fiber) {
+	if (!fiber) return null;
+	const visited = /* @__PURE__ */ new WeakSet();
+	function traverse$1(node) {
+		if (!node || visited.has(node)) return null;
+		visited.add(node);
+		const name = getDisplayName(node);
+		if (name === "Router" || name === "BrowserRouter" || name === "HashRouter" || name === "MemoryRouter" || name === "Routes" || name === "Route") return "react-router";
+		if (node.child) {
+			const result = traverse$1(node.child);
+			if (result) return result;
+		}
+		if (node.sibling) {
+			const result = traverse$1(node.sibling);
+			if (result) return result;
+		}
+		return null;
+	}
+	return traverse$1(fiber);
+}
+/**
+* Record navigation to history
+*/
+function recordNavigation(path, search, hash) {
+	const now = Date.now();
+	if (lastNavigationStart !== null) lastNavigationDuration = now - lastNavigationStart;
+	navigationHistory.unshift({
+		path,
+		search,
+		hash,
+		timestamp: now,
+		duration: lastNavigationDuration
+	});
+	if (navigationHistory.length > MAX_HISTORY_ENTRIES) navigationHistory.pop();
+	lastNavigationStart = null;
+}
+/**
+* Get router information from the current React app
+*/
+function getRouterInfo() {
+	const root = fiberRoot;
+	const urlInfo = getCurrentUrlInfo();
+	if (!(root === null || root === void 0 ? void 0 : root.current)) return {
+		currentPath: urlInfo.path,
+		search: urlInfo.search,
+		hash: urlInfo.hash,
+		routes: [],
+		routerType: null,
+		matchedRoutes: [],
+		params: {},
+		history: [...navigationHistory],
+		lastNavigationDuration
+	};
+	const fiber = root.current;
+	const routerType = detectRouterType(fiber);
+	const routes = findAndExtractRoutes(fiber.child);
+	const matchedRoutes = findMatchedRoutes(routes, urlInfo.path);
+	const params = extractAllParams(matchedRoutes);
+	return {
+		currentPath: urlInfo.path,
+		search: urlInfo.search,
+		hash: urlInfo.hash,
+		routes,
+		routerType,
+		matchedRoutes,
+		params,
+		history: [...navigationHistory],
+		lastNavigationDuration
+	};
+}
+/**
+* Navigate to a path using various methods
+*/
+function navigateTo(path) {
+	try {
+		lastNavigationStart = Date.now();
+		if (window.history && window.history.pushState) {
+			if (window.location.hash && window.location.hash.startsWith("#/")) window.location.hash = path;
+			else {
+				window.history.pushState({}, "", path);
+				window.dispatchEvent(new PopStateEvent("popstate"));
+			}
+			return true;
+		}
+		window.location.href = path;
+		return true;
+	} catch (e) {
+		console.error("[React DevTools] Failed to navigate:", e);
+		lastNavigationStart = null;
+		return false;
+	}
+}
+/**
+* Clear navigation history
+*/
+function clearNavigationHistory() {
+	navigationHistory.length = 0;
+	lastNavigationDuration = void 0;
+}
+/**
+* Initialize navigation tracking by listening to navigation events
+*/
+if (typeof window !== "undefined") {
+	let currentFullPath = "";
+	const updateCurrentPath = () => {
+		const urlInfo$1 = getCurrentUrlInfo();
+		currentFullPath = `${urlInfo$1.path}${urlInfo$1.search}${urlInfo$1.hash}`;
+	};
+	const handleNavigation = () => {
+		const urlInfo$1 = getCurrentUrlInfo();
+		const newFullPath = `${urlInfo$1.path}${urlInfo$1.search}${urlInfo$1.hash}`;
+		if (newFullPath !== currentFullPath) {
+			recordNavigation(urlInfo$1.path, urlInfo$1.search, urlInfo$1.hash);
+			currentFullPath = newFullPath;
+		}
+	};
+	window.addEventListener("popstate", handleNavigation);
+	window.addEventListener("hashchange", handleNavigation);
+	const originalPushState = window.history.pushState;
+	const originalReplaceState = window.history.replaceState;
+	window.history.pushState = function(...args) {
+		const result = originalPushState.apply(this, args);
+		handleNavigation();
+		return result;
+	};
+	window.history.replaceState = function(...args) {
+		const result = originalReplaceState.apply(this, args);
+		updateCurrentPath();
+		return result;
+	};
+	const urlInfo = getCurrentUrlInfo();
+	recordNavigation(urlInfo.path, urlInfo.search, urlInfo.hash);
+	currentFullPath = `${urlInfo.path}${urlInfo.search}${urlInfo.hash}`;
+}
+
+//#endregion
+//#region src/core/hook/index.ts
+const fiberRoots = /* @__PURE__ */ new Map();
+let updateTimer = null;
+let lastRootCurrent = null;
+const treeUpdateCallbacks = /* @__PURE__ */ new Set();
+function onTreeUpdated(callback) {
+	treeUpdateCallbacks.add(callback);
+	return () => {
+		treeUpdateCallbacks.delete(callback);
+	};
+}
+function emitTree(tree) {
+	treeUpdateCallbacks.forEach((callback) => {
+		try {
+			callback(tree);
+		} catch (e) {}
+	});
+}
+function getRoots(rendererID) {
+	if (!fiberRoots.has(rendererID)) fiberRoots.set(rendererID, /* @__PURE__ */ new Set());
+	return fiberRoots.get(rendererID);
+}
+/**
+* Get root selector from runtime config
+*/
+function getRootSelector() {
+	if (typeof window !== "undefined") {
+		var _REACT_DEVTOOLS_CONFI;
+		return (_REACT_DEVTOOLS_CONFI = window.__REACT_DEVTOOLS_CONFIG__) === null || _REACT_DEVTOOLS_CONFI === void 0 ? void 0 : _REACT_DEVTOOLS_CONFI.rootSelector;
+	}
+}
+function isOverlayRoot(root) {
+	const overlayContainer = document.getElementById("react-devtools-overlay");
+	if (!overlayContainer) return false;
+	const containerInfo = root.containerInfo;
+	return containerInfo && containerInfo instanceof Node && overlayContainer.contains(containerInfo);
+}
+/**
+* Check if a root belongs to the specified rootSelector container
+*/
+function isRootInSelector(root, selector) {
+	const containerInfo = root.containerInfo;
+	if (!containerInfo || !(containerInfo instanceof Node)) return false;
+	const targetContainer = document.querySelector(selector);
+	if (!targetContainer) return false;
+	return containerInfo === targetContainer || targetContainer.contains(containerInfo);
+}
+/**
+* Check if a root should be tracked based on rootSelector config
+*/
+function shouldTrackRoot(root) {
+	if (isOverlayRoot(root)) return false;
+	const rootSelector = getRootSelector();
+	if (!rootSelector) return true;
+	return isRootInSelector(root, rootSelector);
+}
+function findAppRoot() {
+	for (const roots of fiberRoots.values()) for (const root of roots) if (root && shouldTrackRoot(root)) return root;
+	if (!getRootSelector()) {
+		for (const roots of fiberRoots.values()) for (const root of roots) if (root && !isOverlayRoot(root)) return root;
+	}
+	return null;
+}
+/**
+* Get the current app fiber root (exported for context debugging)
+*/
+function getAppFiberRoot() {
+	return findAppRoot();
+}
+function handleTreeUpdate(root, showHostComponents) {
+	if (lastRootCurrent === (root === null || root === void 0 ? void 0 : root.current)) return;
+	lastRootCurrent = root === null || root === void 0 ? void 0 : root.current;
+	setFiberRoot(root);
+	if (updateTimer) clearTimeout(updateTimer);
+	updateTimer = setTimeout(() => {
+		const tree = buildTree(root, showHostComponents());
+		if (tree) emitTree(tree);
+		updateTimer = null;
+	}, 200);
+}
+function rebuildTree(showHostComponents) {
+	const appRoot = findAppRoot();
+	if (!appRoot) return;
+	setTimeout(() => {
+		const tree = buildTree(appRoot, showHostComponents);
+		if (tree) emitTree(tree);
+	}, 100);
+}
+function createHook(showHostComponents) {
+	let rendererIDCounter = 0;
+	const renderers = /* @__PURE__ */ new Map();
+	return {
+		supportsFiber: true,
+		renderers,
+		inject(renderer) {
+			const id = ++rendererIDCounter;
+			renderers.set(id, renderer);
+			return id;
+		},
+		getFiberRoots(rendererID) {
+			return new Set(getRoots(rendererID));
+		},
+		onCommitFiberRoot(rendererID, root) {
+			getRoots(rendererID).add(root);
+			handleTreeUpdate(root, showHostComponents);
+		},
+		onCommitFiberUnmount() {}
+	};
+}
+function patchHook(existingHook, showHostComponents) {
+	if (existingHook.__REACT_DEVTOOLS_PATCHED__) return existingHook;
+	if ((existingHook._instrumentationSource || "").includes("bippy") || window.__REACT_SCAN_INTERNALS__) {
+		if (existingHook.renderers) for (const rendererID of existingHook.renderers.keys()) detectExistingRoots(rendererID);
+		try {
+			const scanInternals = window.__REACT_SCAN_INTERNALS__;
+			if (scanInternals && scanInternals.options) setInterval(() => {
+				if (existingHook.renderers) for (const rendererID of existingHook.renderers.keys()) getRoots(rendererID).forEach((root) => handleTreeUpdate(root, showHostComponents));
+			}, 1e3);
+		} catch (e) {
+			console.warn("[React DevTools] Failed to attach to React Scan", e);
+		}
+		return existingHook;
+	}
+	const originalCommit = existingHook.onCommitFiberRoot;
+	if (originalCommit) {
+		const patchedCallback = function(rendererID, root) {
+			let originalResult;
+			try {
+				originalResult = originalCommit.call(this, rendererID, root);
+			} catch (e) {
+				console.error("[React DevTools] Error in other devtools hook:", e);
+			}
+			try {
+				getRoots(rendererID).add(root);
+				handleTreeUpdate(root, showHostComponents);
+			} catch (error) {}
+			return originalResult;
+		};
+		Object.setPrototypeOf(patchedCallback, Object.getPrototypeOf(originalCommit));
+		existingHook.onCommitFiberRoot = patchedCallback;
+	} else existingHook.onCommitFiberRoot = (rendererID, root) => {
+		getRoots(rendererID).add(root);
+		handleTreeUpdate(root, showHostComponents);
+	};
+	if (!existingHook.getFiberRoots) existingHook.getFiberRoots = (rendererID) => new Set(getRoots(rendererID));
+	existingHook.__REACT_DEVTOOLS_PATCHED__ = true;
+	return existingHook;
+}
+function detectExistingRoots(rendererID) {
+	const rootSelector = getRootSelector();
+	function findRootFromContainer(container) {
+		if (!container || typeof container !== "object") return null;
+		if (container.containerInfo) return container;
+		if (container.current) {
+			const fiber = container.current;
+			if (fiber.tag === 3 || fiber.tag === 24) return fiber.stateNode || container;
+			const root = findRootFromFiber(fiber);
+			if (root) return root;
+		}
+		if (container._reactRootContainer) {
+			const root = findRootFromContainer(container._reactRootContainer);
+			if (root) return root;
+		}
+		if (container._internalRoot) {
+			const root = findRootFromContainer(container._internalRoot);
+			if (root) return root;
+		}
+		return null;
+	}
+	function findRootFromFiber(fiber) {
+		let current = fiber;
+		let depth = 0;
+		const maxDepth = 100;
+		while (current && depth < maxDepth) {
+			if (current.tag === 3 || current.tag === 24) return current.stateNode;
+			current = current.return || current._debugOwner;
+			depth++;
+		}
+		return null;
+	}
+	/**
+	* Try to find React root from a single element
+	*/
+	function findRootFromElement(element) {
+		const keys = [...Object.keys(element), ...Object.getOwnPropertyNames(element)];
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			if (seenKeys.has(key)) continue;
+			seenKeys.add(key);
+			try {
+				const value = element[key];
+				if (!value || typeof value !== "object") continue;
+				if (key.startsWith("__reactContainer")) {
+					if (value && (value.tag === 3 || value.tag === 24)) {
+						const fiberRoot$1 = value.stateNode;
+						if (fiberRoot$1) return fiberRoot$1;
+					}
+					const root = findRootFromFiber(value);
+					if (root) return root;
+				} else if (key.startsWith("__reactFiber")) {
+					const root = findRootFromFiber(value);
+					if (root) return root;
+				} else if (key.startsWith("__reactInternalInstance")) {
+					const root = findRootFromFiber(value);
+					if (root) return root;
+				}
+			} catch (e) {
+				continue;
+			}
+		}
+		return null;
+	}
+	/**
+	* Check if a root's containerInfo is inside the target selector
+	*/
+	function isRootContainerInSelector(root, selector) {
+		const containerInfo = root.containerInfo;
+		if (!containerInfo || !(containerInfo instanceof Element)) return false;
+		const targetContainer = document.querySelector(selector);
+		if (!targetContainer) return false;
+		return containerInfo === targetContainer || targetContainer.contains(containerInfo);
+	}
+	function walkDOM(element) {
+		if (rootSelector) {
+			const targetElement = document.querySelector(rootSelector);
+			if (targetElement) {
+				const directRoot = findRootFromElement(targetElement);
+				if (directRoot && isRootContainerInSelector(directRoot, rootSelector)) return directRoot;
+				const walker$2 = document.createTreeWalker(targetElement, NodeFilter.SHOW_ELEMENT);
+				let node$1 = walker$2.currentNode;
+				while (node$1) {
+					const root = findRootFromElement(node$1);
+					if (root) {
+						if (isRootContainerInSelector(root, rootSelector)) return root;
+					}
+					node$1 = walker$2.nextNode();
+				}
+			}
+			return null;
+		}
+		for (const id of [
+			"root",
+			"app",
+			"main",
+			"app-root"
+		]) {
+			const rootElement = document.getElementById(id);
+			if (!rootElement) continue;
+			const root = findRootFromElement(rootElement);
+			if (root) return root;
+		}
+		const walker$1 = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT);
+		let node = walker$1.currentNode;
+		while (node) {
+			const root = findRootFromElement(node);
+			if (root) return root;
+			node = walker$1.nextNode();
+		}
+		return null;
+	}
+	const existingRoot = walkDOM(document.body || document);
+	if (existingRoot) {
+		getRoots(rendererID).add(existingRoot);
+		setTimeout(() => {
+			handleTreeUpdate(existingRoot, () => false);
+		}, 50);
+		return true;
+	}
+	return false;
+}
+/**
+* Get the React version from the renderer
+*/
+function getReactVersion() {
+	const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	if (!hook || !hook.renderers) return null;
+	for (const renderer of hook.renderers.values()) {
+		if (renderer && renderer.version) return renderer.version;
+		if (renderer && renderer.reconcilerVersion) return renderer.reconcilerVersion;
+	}
+	if (typeof window !== "undefined") {
+		const React = window.React;
+		if (React && React.version) return React.version;
+	}
+	return null;
+}
+function installReactHook(showHostComponents) {
+	const globalObj = globalThis;
+	if (globalObj.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+		const hook$1 = patchHook(globalObj.__REACT_DEVTOOLS_GLOBAL_HOOK__, showHostComponents);
+		if (hook$1.renderers && hook$1.renderers.size > 0) for (const rendererID of hook$1.renderers.keys()) detectExistingRoots(rendererID);
+		else detectExistingRoots(hook$1.inject({}));
+		return;
+	}
+	const hook = createHook(showHostComponents);
+	globalObj.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+	let attempts = 0;
+	const maxAttempts = 10;
+	function tryDetect() {
+		attempts++;
+		if (detectExistingRoots(hook.inject({}))) return;
+		if (hook.renderers && hook.renderers.size > 0) {
+			for (const rendererID of hook.renderers.keys()) if (detectExistingRoots(rendererID)) return;
+		}
+		if (attempts < maxAttempts) setTimeout(tryDetect, 200 * attempts);
+	}
+	tryDetect();
+	setTimeout(() => {
+		tryDetect();
+	}, 50);
+}
+
+//#endregion
+//#region src/core/inspector/index.ts
+let isInspectorEnabled = false;
+let inspectorMode = "select-component";
+const selectCallbacks = /* @__PURE__ */ new Set();
+const openInEditorCallbacks = /* @__PURE__ */ new Set();
+function onInspectorSelect(callback) {
+	selectCallbacks.add(callback);
+	return () => selectCallbacks.delete(callback);
+}
+function onOpenInEditor(callback) {
+	openInEditorCallbacks.add(callback);
+	return () => openInEditorCallbacks.delete(callback);
+}
+function emitSelect(fiberId) {
+	selectCallbacks.forEach((cb) => cb(fiberId));
+}
+function emitOpenInEditor(fileName, line, column) {
+	openInEditorCallbacks.forEach((cb) => cb(fileName, line, column));
+}
+function findNearestComponentFiber(fiber) {
+	let current = fiber;
+	while (current) {
+		if (shouldIncludeFiber(current, false)) return current;
+		current = current.return;
+	}
+	return null;
+}
+function findSourceFiber(fiber) {
+	let current = fiber;
+	while (current) {
+		if (current._debugSource) return current;
+		current = current.return;
+	}
+	return null;
+}
+function parseSourcePath(sourcePath) {
+	const lastColon = sourcePath.lastIndexOf(":");
+	if (lastColon === -1) return null;
+	const secondLastColon = sourcePath.lastIndexOf(":", lastColon - 1);
+	if (secondLastColon === -1) return null;
+	const fileName = sourcePath.substring(0, secondLastColon);
+	const lineNumber = Number.parseInt(sourcePath.substring(secondLastColon + 1, lastColon), 10);
+	const columnNumber = Number.parseInt(sourcePath.substring(lastColon + 1), 10);
+	if (Number.isNaN(lineNumber) || Number.isNaN(columnNumber)) return null;
+	return {
+		fileName,
+		lineNumber,
+		columnNumber
+	};
+}
+function getSourceFromElement(element) {
+	if (!element) return null;
+	let current = element;
+	while (current && current !== document.body) {
+		const sourcePath = current.getAttribute("data-source-path");
+		if (sourcePath) return parseSourcePath(sourcePath);
+		current = current.parentElement;
+	}
+	return null;
+}
+function handleMouseOver(e) {
+	if (!isInspectorEnabled) return;
+	const target$1 = e.target;
+	const fiber = getFiberFromElement(target$1);
+	if (inspectorMode === "select-component") {
+		const componentFiber = findNearestComponentFiber(fiber);
+		if (componentFiber) highlightNode(componentFiber);
+		else hideHighlight();
+	} else if (inspectorMode === "open-in-editor") {
+		const source = getSourceFromElement(target$1);
+		if (source && fiber) highlightNode(fiber, source);
+		else {
+			const sourceFiber = findSourceFiber(fiber);
+			if (sourceFiber) {
+				const fallbackSource = sourceFiber._debugSource ? {
+					fileName: sourceFiber._debugSource.fileName,
+					lineNumber: sourceFiber._debugSource.lineNumber,
+					columnNumber: sourceFiber._debugSource.columnNumber
+				} : void 0;
+				if (fiber) highlightNode(fiber, fallbackSource);
+				else highlightNode(sourceFiber, fallbackSource);
+			} else hideHighlight();
+		}
+	}
+}
+function handleClick(e) {
+	if (!isInspectorEnabled) return;
+	e.preventDefault();
+	e.stopPropagation();
+	const target$1 = e.target;
+	const fiber = getFiberFromElement(target$1);
+	if (inspectorMode === "select-component") {
+		const componentFiber = findNearestComponentFiber(fiber);
+		if (componentFiber) {
+			emitSelect(getFiberId(componentFiber));
+			toggleInspector(false);
+			hideHighlight();
+		}
+	} else if (inspectorMode === "open-in-editor") {
+		const source = getSourceFromElement(target$1);
+		if (source) {
+			const { fileName, lineNumber, columnNumber } = source;
+			emitOpenInEditor(fileName, lineNumber, columnNumber);
+			toggleInspector(false);
+			hideHighlight();
+		} else {
+			const sourceFiber = findSourceFiber(fiber);
+			if (sourceFiber && sourceFiber._debugSource) {
+				const { fileName, lineNumber, columnNumber } = sourceFiber._debugSource;
+				emitOpenInEditor(fileName, lineNumber, columnNumber);
+				toggleInspector(false);
+				hideHighlight();
+			}
+		}
+	}
+}
+function toggleInspector(enabled, options = {}) {
+	isInspectorEnabled = enabled;
+	if (options.mode) inspectorMode = options.mode;
+	if (enabled) {
+		window.addEventListener("mouseover", handleMouseOver, true);
+		window.addEventListener("click", handleClick, true);
+		document.body.style.cursor = "default";
+	} else {
+		window.removeEventListener("mouseover", handleMouseOver, true);
+		window.removeEventListener("click", handleClick, true);
+		document.body.style.cursor = "";
+		hideHighlight();
+	}
+}
+
+//#endregion
+//#region src/core/open-in-editor/index.ts
+/**
+* Try to open a file in the editor using URL protocol (fallback)
+*/
+function tryOpenWithProtocol(fileName, line, column) {
+	try {
+		const protocolUrl = `${localStorage.getItem("react_devtools_editor") || "vscode"}://file/${fileName}:${line}:${column}`;
+		const link = document.createElement("a");
+		link.href = protocolUrl;
+		link.click();
+		link.remove();
+		return true;
+	} catch (e) {
+		console.warn("[React DevTools] Failed to open with URL protocol:", e);
+		return false;
+	}
+}
+function openInEditor(fileName, line, column) {
+	try {
+		const url = `/__open-in-editor?file=${encodeURIComponent(`${fileName}:${line}:${column}`)}`;
+		fetch(url).then((response) => {
+			if (!response.ok) {
+				console.warn("[React DevTools] Server endpoint failed, trying URL protocol fallback");
+				tryOpenWithProtocol(fileName, line, column);
+			}
+		}).catch(() => {
+			console.warn("[React DevTools] Fetch failed, trying URL protocol fallback");
+			tryOpenWithProtocol(fileName, line, column);
+		});
+	} catch (e) {
+		console.error("[React DevTools] Failed to open in editor:", e);
+		tryOpenWithProtocol(fileName, line, column);
+	}
+}
+
+//#endregion
+//#region src/core/timeline/index.ts
+const TIMELINE_LAYERS = [
+	{
+		id: "mouse",
+		label: "Mouse",
+		color: "#A451AF",
+		enabled: true
+	},
+	{
+		id: "keyboard",
+		label: "Keyboard",
+		color: "#8151AF",
+		enabled: true
+	},
+	{
+		id: "component-event",
+		label: "Component events",
+		color: "#4FC08D",
+		enabled: true
+	},
+	{
+		id: "performance",
+		label: "Performance",
+		color: "#41B86A",
+		enabled: true
+	}
+];
+let timelineState = {
+	recordingState: false,
+	mouseEventEnabled: true,
+	keyboardEventEnabled: true,
+	componentEventEnabled: true,
+	performanceEventEnabled: true,
+	selected: "mouse"
+};
+let eventIdCounter = 0;
+let groupIdCounter = 0;
+const perfGroupIds = /* @__PURE__ */ new Map();
+const timelineEventCallbacks = /* @__PURE__ */ new Set();
+function onTimelineEvent(callback) {
+	timelineEventCallbacks.add(callback);
+	return () => {
+		timelineEventCallbacks.delete(callback);
+	};
+}
+function emitTimelineEvent(layerId, event) {
+	timelineEventCallbacks.forEach((callback) => {
+		try {
+			callback(layerId, event);
+		} catch (e) {}
+	});
+}
+function getTimelineState() {
+	return _objectSpread2({}, timelineState);
+}
+function updateTimelineState(state) {
+	timelineState = _objectSpread2(_objectSpread2({}, timelineState), state);
+}
+function clearTimeline() {
+	eventIdCounter = 0;
+	groupIdCounter = 0;
+	perfGroupIds.clear();
+}
+function addMouseEvent(eventType, x, y) {
+	if (!timelineState.recordingState || !timelineState.mouseEventEnabled) return;
+	emitTimelineEvent("mouse", {
+		id: ++eventIdCounter,
+		time: Date.now(),
+		data: {
+			type: eventType,
+			x,
+			y
+		},
+		title: eventType
+	});
+}
+function addKeyboardEvent(eventType, key, modifiers) {
+	if (!timelineState.recordingState || !timelineState.keyboardEventEnabled) return;
+	emitTimelineEvent("keyboard", {
+		id: ++eventIdCounter,
+		time: Date.now(),
+		data: _objectSpread2({
+			type: eventType,
+			key
+		}, modifiers),
+		title: key,
+		subtitle: eventType
+	});
+}
+function addComponentEvent(componentName, eventName, params) {
+	if (!timelineState.recordingState || !timelineState.componentEventEnabled) return;
+	emitTimelineEvent("component-event", {
+		id: ++eventIdCounter,
+		time: Date.now(),
+		data: {
+			component: componentName,
+			event: eventName,
+			params
+		},
+		title: eventName,
+		subtitle: `by ${componentName}`
+	});
+}
+function getComponentName(fiber) {
+	if (!fiber) return "Unknown";
+	const type = fiber.elementType || fiber.type;
+	if (!type) return "Unknown";
+	if (typeof type === "string") return type;
+	return type.displayName || type.name || "Anonymous";
+}
+function addPerformanceEvent(type, componentName, measure, duration, groupKey) {
+	if (!timelineState.recordingState || !timelineState.performanceEventEnabled) return;
+	let groupId;
+	if (groupKey) if (measure === "start") {
+		groupId = ++groupIdCounter;
+		perfGroupIds.set(groupKey, {
+			groupId,
+			time: Date.now()
+		});
+	} else {
+		const groupInfo = perfGroupIds.get(groupKey);
+		if (groupInfo) {
+			groupId = groupInfo.groupId;
+			if (!duration) duration = Date.now() - groupInfo.time;
+			perfGroupIds.delete(groupKey);
+		}
+	}
+	emitTimelineEvent("performance", {
+		id: ++eventIdCounter,
+		time: Date.now(),
+		data: _objectSpread2({
+			component: componentName,
+			type,
+			measure
+		}, duration !== void 0 && { duration: {
+			value: duration,
+			display: `${duration.toFixed(2)} ms`
+		} }),
+		title: componentName,
+		subtitle: type,
+		groupId
+	});
+}
+const fiberPerfMap = /* @__PURE__ */ new Map();
+function trackFiberPerformanceStart(fiber, type) {
+	const componentName = getComponentName(fiber);
+	const key = `${fiber.key || "null"}-${componentName}-${type}`;
+	fiberPerfMap.set(key, {
+		time: performance.now(),
+		fiber
+	});
+	addPerformanceEvent(type, componentName, "start", void 0, key);
+}
+function trackFiberPerformanceEnd(fiber, type) {
+	const componentName = getComponentName(fiber);
+	const key = `${fiber.key || "null"}-${componentName}-${type}`;
+	const perfData = fiberPerfMap.get(key);
+	if (perfData) {
+		const duration = performance.now() - perfData.time;
+		fiberPerfMap.delete(key);
+		addPerformanceEvent(type, componentName, "end", duration, key);
+	}
+}
+let eventListenersInstalled = false;
+function installTimelineEventListeners() {
+	if (typeof window === "undefined" || eventListenersInstalled) return;
+	eventListenersInstalled = true;
+	[
+		"mousedown",
+		"mouseup",
+		"click",
+		"dblclick"
+	].forEach((eventType) => {
+		window.addEventListener(eventType, (event) => {
+			addMouseEvent(eventType, event.clientX, event.clientY);
+		}, {
+			capture: true,
+			passive: true
+		});
+	});
+	[
+		"keyup",
+		"keydown",
+		"keypress"
+	].forEach((eventType) => {
+		window.addEventListener(eventType, (event) => {
+			addKeyboardEvent(eventType, event.key, {
+				ctrlKey: event.ctrlKey,
+				shiftKey: event.shiftKey,
+				altKey: event.altKey,
+				metaKey: event.metaKey
+			});
+		}, {
+			capture: true,
+			passive: true
+		});
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/birpc@2.8.0/node_modules/birpc/dist/index.mjs
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+	return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: clearTimeout$1, setTimeout: setTimeout$1 } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize: serialize$1 = defaultSerialize, deserialize: deserialize$1 = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize$1(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				var _timeoutId$unref;
+				timeoutId = setTimeout$1(() => {
+					try {
+						var _options$onTimeoutErr;
+						if (((_options$onTimeoutErr = options.onTimeoutError) === null || _options$onTimeoutErr === void 0 ? void 0 : _options$onTimeoutErr.call(options, method, args)) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = (_timeoutId$unref = timeoutId.unref) === null || _timeoutId$unref === void 0 ? void 0 : _timeoutId$unref.call(timeoutId);
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest(req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			var _options$onGeneralErr;
+			if (((_options$onGeneralErr = options.onGeneralError) === null || _options$onGeneralErr === void 0 ? void 0 : _options$onGeneralErr.call(options, e)) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout$1(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const $call = (method, ...args) => _call(method, args, false);
+	const $callOptional = (method, ...args) => _call(method, args, false, true);
+	const $callEvent = (method, ...args) => _call(method, args, true);
+	const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
+	const builtinMethods = {
+		$call,
+		$callOptional,
+		$callEvent,
+		$callRaw,
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		$close,
+		$functions
+	};
+	const rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				var _customError$cause;
+				(_customError$cause = customError.cause) !== null && _customError$cause !== void 0 || (customError.cause = error);
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize$1(data);
+		} catch (e) {
+			var _options$onGeneralErr2;
+			if (((_options$onGeneralErr2 = options.onGeneralError) === null || _options$onGeneralErr2 === void 0 ? void 0 : _options$onGeneralErr2.call(options, e)) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver(method, $functions[method]) : $functions[method]);
+			if (optional) fn || (fn = () => void 0);
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onError) options.onError(error, method, args);
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError(error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize$1({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					var _options$onGeneralErr3;
+					error = e;
+					if (((_options$onGeneralErr3 = options.onGeneralError) === null || _options$onGeneralErr3 === void 0 ? void 0 : _options$onGeneralErr3.call(options, e, method, args)) !== true) throw e;
+				}
+				try {
+					await post(serialize$1({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					var _options$onGeneralErr4;
+					if (((_options$onGeneralErr4 = options.onGeneralError) === null || _options$onGeneralErr4 === void 0 ? void 0 : _options$onGeneralErr4.call(options, e, method, args)) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout$1(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+const cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+	return items.map((i) => {
+		let r = cacheMap.get(i);
+		if (!r) {
+			r = fn(i);
+			cacheMap.set(i, r);
+		}
+		return r;
+	});
+}
+function createBirpcGroup(functions, channels, options = {}) {
+	const getChannels = () => typeof channels === "function" ? channels() : channels;
+	const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, _objectSpread2(_objectSpread2({}, options), s)));
+	function _boardcast(method, args, event, optional) {
+		const clients = getClients();
+		return Promise.all(clients.map((c) => c.$callRaw({
+			method,
+			args,
+			event,
+			optional
+		})));
+	}
+	function $call(method, ...args) {
+		return _boardcast(method, args, false);
+	}
+	function $callOptional(method, ...args) {
+		return _boardcast(method, args, false, true);
+	}
+	function $callEvent(method, ...args) {
+		return _boardcast(method, args, true);
+	}
+	const broadcastBuiltin = {
+		$call,
+		$callOptional,
+		$callEvent
+	};
+	const broadcastProxy = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(broadcastBuiltin, method)) return broadcastBuiltin[method];
+		const callbacks = getClients().map((c) => c[method]);
+		const sendCall = (...args) => {
+			return Promise.all(callbacks.map((i) => i(...args)));
+		};
+		sendCall.asEvent = async (...args) => {
+			await Promise.all(callbacks.map((i) => i.asEvent(...args)));
+		};
+		return sendCall;
+	} });
+	function updateChannels(fn) {
+		const channels2 = getChannels();
+		fn === null || fn === void 0 || fn(channels2);
+		return getClients(channels2);
+	}
+	getClients();
+	return {
+		get clients() {
+			return getClients();
+		},
+		functions,
+		updateChannels,
+		broadcast: broadcastProxy,
+		boardcast: broadcastProxy
+	};
+}
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+	constructor() {
+		this.keyToValue = /* @__PURE__ */ new Map();
+		this.valueToKey = /* @__PURE__ */ new Map();
+	}
+	set(key, value) {
+		this.keyToValue.set(key, value);
+		this.valueToKey.set(value, key);
+	}
+	getByKey(key) {
+		return this.keyToValue.get(key);
+	}
+	getByValue(value) {
+		return this.valueToKey.get(value);
+	}
+	clear() {
+		this.keyToValue.clear();
+		this.valueToKey.clear();
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/registry.js
+var Registry = class {
+	constructor(generateIdentifier) {
+		this.generateIdentifier = generateIdentifier;
+		this.kv = new DoubleIndexedKV();
+	}
+	register(value, identifier) {
+		if (this.kv.getByValue(value)) return;
+		if (!identifier) identifier = this.generateIdentifier(value);
+		this.kv.set(identifier, value);
+	}
+	clear() {
+		this.kv.clear();
+	}
+	getIdentifier(value) {
+		return this.kv.getByValue(value);
+	}
+	getValue(identifier) {
+		return this.kv.getByKey(identifier);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+	constructor() {
+		super((c) => c.name);
+		this.classToAllowedProps = /* @__PURE__ */ new Map();
+	}
+	register(value, options) {
+		if (typeof options === "object") {
+			if (options.allowProps) this.classToAllowedProps.set(value, options.allowProps);
+			super.register(value, options.identifier);
+		} else super.register(value, options);
+	}
+	getAllowedProps(value) {
+		return this.classToAllowedProps.get(value);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+	if ("values" in Object) return Object.values(record);
+	const values = [];
+	for (const key in record) if (record.hasOwnProperty(key)) values.push(record[key]);
+	return values;
+}
+function find(record, predicate) {
+	const values = valuesOfObj(record);
+	if ("find" in values) return values.find(predicate);
+	const valuesNotNever = values;
+	for (let i = 0; i < valuesNotNever.length; i++) {
+		const value = valuesNotNever[i];
+		if (predicate(value)) return value;
+	}
+}
+function forEach(record, run) {
+	Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+	return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+	for (let i = 0; i < record.length; i++) {
+		const value = record[i];
+		if (predicate(value)) return value;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+	constructor() {
+		this.transfomers = {};
+	}
+	register(transformer) {
+		this.transfomers[transformer.name] = transformer;
+	}
+	findApplicable(v) {
+		return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+	}
+	findByName(name) {
+		return this.transfomers[name];
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/is.js
+const getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+const isUndefined = (payload) => typeof payload === "undefined";
+const isNull = (payload) => payload === null;
+const isPlainObject$1 = (payload) => {
+	if (typeof payload !== "object" || payload === null) return false;
+	if (payload === Object.prototype) return false;
+	if (Object.getPrototypeOf(payload) === null) return true;
+	return Object.getPrototypeOf(payload) === Object.prototype;
+};
+const isEmptyObject = (payload) => isPlainObject$1(payload) && Object.keys(payload).length === 0;
+const isArray$1 = (payload) => Array.isArray(payload);
+const isString = (payload) => typeof payload === "string";
+const isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+const isBoolean = (payload) => typeof payload === "boolean";
+const isRegExp = (payload) => payload instanceof RegExp;
+const isMap = (payload) => payload instanceof Map;
+const isSet = (payload) => payload instanceof Set;
+const isSymbol = (payload) => getType$1(payload) === "Symbol";
+const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = (payload) => payload instanceof Error;
+const isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+const isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+const isBigint = (payload) => typeof payload === "bigint";
+const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+const isURL = (payload) => payload instanceof URL;
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/pathstringifier.js
+const escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+const stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+const parsePath = (string, legacyPaths) => {
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < string.length; i++) {
+		let char = string.charAt(i);
+		if (!legacyPaths && char === "\\") {
+			const escaped = string.charAt(i + 1);
+			if (escaped === "\\") {
+				segment += "\\";
+				i++;
+				continue;
+			} else if (escaped !== ".") throw Error("invalid path");
+		}
+		if (char === "\\" && string.charAt(i + 1) === ".") {
+			segment += ".";
+			i++;
+			continue;
+		}
+		if (char === ".") {
+			result.push(segment);
+			segment = "";
+			continue;
+		}
+		segment += char;
+	}
+	const lastSegment = segment;
+	result.push(lastSegment);
+	return result;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const simpleRules = [
+	simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+	simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+		if (typeof BigInt !== "undefined") return BigInt(v);
+		console.error("Please add a BigInt polyfill.");
+		return v;
+	}),
+	simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+	simpleTransformation(isError, "Error", (v, superJson) => {
+		const baseError = {
+			name: v.name,
+			message: v.message
+		};
+		if ("cause" in v) baseError.cause = v.cause;
+		superJson.allowedErrorProps.forEach((prop) => {
+			baseError[prop] = v[prop];
+		});
+		return baseError;
+	}, (v, superJson) => {
+		const e = new Error(v.message, { cause: v.cause });
+		e.name = v.name;
+		e.stack = v.stack;
+		superJson.allowedErrorProps.forEach((prop) => {
+			e[prop] = v[prop];
+		});
+		return e;
+	}),
+	simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+		const body = regex.slice(1, regex.lastIndexOf("/"));
+		const flags = regex.slice(regex.lastIndexOf("/") + 1);
+		return new RegExp(body, flags);
+	}),
+	simpleTransformation(isSet, "set", (v) => [...v.values()], (v) => new Set(v)),
+	simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+	simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+		if (isNaNValue(v)) return "NaN";
+		if (v > 0) return "Infinity";
+		else return "-Infinity";
+	}, Number),
+	simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+		return "-0";
+	}, Number),
+	simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+	if (isSymbol(s)) return !!superJson.symbolRegistry.getIdentifier(s);
+	return false;
+}, (s, superJson) => {
+	return ["symbol", superJson.symbolRegistry.getIdentifier(s)];
+}, (v) => v.description, (_, a, superJson) => {
+	const value = superJson.symbolRegistry.getValue(a[1]);
+	if (!value) throw new Error("Trying to deserialize unknown symbol");
+	return value;
+});
+const constructorToName = [
+	Int8Array,
+	Uint8Array,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	Uint8ClampedArray
+].reduce((obj, ctor) => {
+	obj[ctor.name] = ctor;
+	return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+	const ctor = constructorToName[a[1]];
+	if (!ctor) throw new Error("Trying to deserialize unknown typed array");
+	return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+	if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) return !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+	return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+	return ["class", superJson.classRegistry.getIdentifier(clazz.constructor)];
+}, (clazz, superJson) => {
+	const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+	if (!allowedProps) return _objectSpread2({}, clazz);
+	const result = {};
+	allowedProps.forEach((prop) => {
+		result[prop] = clazz[prop];
+	});
+	return result;
+}, (v, a, superJson) => {
+	const clazz = superJson.classRegistry.getValue(a[1]);
+	if (!clazz) throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+	return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+	return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+	return ["custom", superJson.customTransformerRegistry.findApplicable(value).name];
+}, (value, superJson) => {
+	return superJson.customTransformerRegistry.findApplicable(value).serialize(value);
+}, (v, a, superJson) => {
+	const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+	if (!transformer) throw new Error("Trying to deserialize unknown custom value");
+	return transformer.deserialize(v);
+});
+const compositeRules = [
+	classRule,
+	symbolRule,
+	customRule,
+	typedArrayRule
+];
+const transformValue = (value, superJson) => {
+	const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableCompositeRule) return {
+		value: applicableCompositeRule.transform(value, superJson),
+		type: applicableCompositeRule.annotation(value, superJson)
+	};
+	const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableSimpleRule) return {
+		value: applicableSimpleRule.transform(value, superJson),
+		type: applicableSimpleRule.annotation
+	};
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+	simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+	if (isArray$1(type)) switch (type[0]) {
+		case "symbol": return symbolRule.untransform(json, type, superJson);
+		case "class": return classRule.untransform(json, type, superJson);
+		case "custom": return customRule.untransform(json, type, superJson);
+		case "typed-array": return typedArrayRule.untransform(json, type, superJson);
+		default: throw new Error("Unknown transformation: " + type);
+	}
+	else {
+		const transformation = simpleRulesByAnnotation[type];
+		if (!transformation) throw new Error("Unknown transformation: " + type);
+		return transformation.untransform(json, superJson);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/accessDeep.js
+const getNthKey = (value, n) => {
+	if (n > value.size) throw new Error("index out of bounds");
+	const keys = value.keys();
+	while (n > 0) {
+		keys.next();
+		n--;
+	}
+	return keys.next().value;
+};
+function validatePath(path) {
+	if (includes(path, "__proto__")) throw new Error("__proto__ is not allowed as a property");
+	if (includes(path, "prototype")) throw new Error("prototype is not allowed as a property");
+	if (includes(path, "constructor")) throw new Error("constructor is not allowed as a property");
+}
+const getDeep = (object, path) => {
+	validatePath(path);
+	for (let i = 0; i < path.length; i++) {
+		const key = path[i];
+		if (isSet(object)) object = getNthKey(object, +key);
+		else if (isMap(object)) {
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(object, row);
+			switch (type) {
+				case "key":
+					object = keyOfRow;
+					break;
+				case "value":
+					object = object.get(keyOfRow);
+					break;
+			}
+		} else object = object[key];
+	}
+	return object;
+};
+const setDeep = (object, path, mapper) => {
+	validatePath(path);
+	if (path.length === 0) return mapper(object);
+	let parent = object;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		if (isArray$1(parent)) {
+			const index = +key;
+			parent = parent[index];
+		} else if (isPlainObject$1(parent)) parent = parent[key];
+		else if (isSet(parent)) {
+			const row = +key;
+			parent = getNthKey(parent, row);
+		} else if (isMap(parent)) {
+			if (i === path.length - 2) break;
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(parent, row);
+			switch (type) {
+				case "key":
+					parent = keyOfRow;
+					break;
+				case "value":
+					parent = parent.get(keyOfRow);
+					break;
+			}
+		}
+	}
+	const lastKey = path[path.length - 1];
+	if (isArray$1(parent)) parent[+lastKey] = mapper(parent[+lastKey]);
+	else if (isPlainObject$1(parent)) parent[lastKey] = mapper(parent[lastKey]);
+	if (isSet(parent)) {
+		const oldValue = getNthKey(parent, +lastKey);
+		const newValue = mapper(oldValue);
+		if (oldValue !== newValue) {
+			parent.delete(oldValue);
+			parent.add(newValue);
+		}
+	}
+	if (isMap(parent)) {
+		const row = +path[path.length - 2];
+		const keyToRow = getNthKey(parent, row);
+		switch (+lastKey === 0 ? "key" : "value") {
+			case "key": {
+				const newKey = mapper(keyToRow);
+				parent.set(newKey, parent.get(keyToRow));
+				if (newKey !== keyToRow) parent.delete(keyToRow);
+				break;
+			}
+			case "value":
+				parent.set(keyToRow, mapper(parent.get(keyToRow)));
+				break;
+		}
+	}
+	return object;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/plainer.js
+const enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker$1, version, origin = []) {
+	if (!tree) return;
+	const legacyPaths = enableLegacyPaths(version);
+	if (!isArray$1(tree)) {
+		forEach(tree, (subtree, key) => traverse(subtree, walker$1, version, [...origin, ...parsePath(key, legacyPaths)]));
+		return;
+	}
+	const [nodeValue, children] = tree;
+	if (children) forEach(children, (child, key) => {
+		traverse(child, walker$1, version, [...origin, ...parsePath(key, legacyPaths)]);
+	});
+	walker$1(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+	traverse(annotations, (type, path) => {
+		plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+	}, version);
+	return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+	const legacyPaths = enableLegacyPaths(version);
+	function apply(identicalPaths, path) {
+		const object = getDeep(plain, parsePath(path, legacyPaths));
+		identicalPaths.map((path$1) => parsePath(path$1, legacyPaths)).forEach((identicalObjectPath) => {
+			plain = setDeep(plain, identicalObjectPath, () => object);
+		});
+	}
+	if (isArray$1(annotations)) {
+		const [root, other] = annotations;
+		root.forEach((identicalPath) => {
+			plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+		});
+		if (other) forEach(other, apply);
+	} else forEach(annotations, apply);
+	return plain;
+}
+const isDeep = (object, superJson) => isPlainObject$1(object) || isArray$1(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+	const existingSet = identities.get(object);
+	if (existingSet) existingSet.push(path);
+	else identities.set(object, [path]);
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+	const result = {};
+	let rootEqualityPaths = void 0;
+	identitites.forEach((paths) => {
+		if (paths.length <= 1) return;
+		if (!dedupe) paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+		const [representativePath, ...identicalPaths] = paths;
+		if (representativePath.length === 0) rootEqualityPaths = identicalPaths.map(stringifyPath);
+		else result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+	});
+	if (rootEqualityPaths) if (isEmptyObject(result)) return [rootEqualityPaths];
+	else return [rootEqualityPaths, result];
+	else return isEmptyObject(result) ? void 0 : result;
+}
+const walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+	var _transformationResult;
+	const primitive = isPrimitive(object);
+	if (!primitive) {
+		addIdentity(object, path, identities);
+		const seen = seenObjects.get(object);
+		if (seen) return dedupe ? { transformedValue: null } : seen;
+	}
+	if (!isDeep(object, superJson)) {
+		const transformed$1 = transformValue(object, superJson);
+		const result$1 = transformed$1 ? {
+			transformedValue: transformed$1.value,
+			annotations: [transformed$1.type]
+		} : { transformedValue: object };
+		if (!primitive) seenObjects.set(object, result$1);
+		return result$1;
+	}
+	if (includes(objectsInThisPath, object)) return { transformedValue: null };
+	const transformationResult = transformValue(object, superJson);
+	const transformed = (_transformationResult = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _transformationResult !== void 0 ? _transformationResult : object;
+	const transformedValue = isArray$1(transformed) ? [] : {};
+	const innerAnnotations = {};
+	forEach(transformed, (value, index) => {
+		if (index === "__proto__" || index === "constructor" || index === "prototype") throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+		const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+		transformedValue[index] = recursiveResult.transformedValue;
+		if (isArray$1(recursiveResult.annotations)) innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+		else if (isPlainObject$1(recursiveResult.annotations)) forEach(recursiveResult.annotations, (tree, key) => {
+			innerAnnotations[escapeKey(index) + "." + key] = tree;
+		});
+	});
+	const result = isEmptyObject(innerAnnotations) ? {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type] : void 0
+	} : {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+	};
+	if (!primitive) seenObjects.set(object, result);
+	return result;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+/** Returns the object type of the given payload */
+function getType(payload) {
+	return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+/** Returns whether the payload is an array */
+function isArray(payload) {
+	return getType(payload) === "Array";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+/**
+* Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+* with other prototypes)
+*/
+function isPlainObject(payload) {
+	if (getType(payload) !== "Object") return false;
+	const prototype = Object.getPrototypeOf(payload);
+	return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/copy-anything@4.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+	const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+	if (propType === "enumerable") carry[key] = newVal;
+	if (includeNonenumerable && propType === "nonenumerable") Object.defineProperty(carry, key, {
+		value: newVal,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+}
+/**
+* Copy (clone) an object and all its props recursively to get rid of any prop referenced of the
+* original object. Arrays are also cloned, however objects inside arrays are still linked.
+*
+* @param target Target can be anything
+* @param [options={}] See type {@link Options} for more details.
+*
+*   - `{ props: ['key1'] }` will only copy the `key1` property. When using this you will need to cast
+*       the return type manually (in order to keep the TS implementation in here simple I didn't
+*       built a complex auto resolved type for those few cases people want to use this option)
+*   - `{ nonenumerable: true }` will copy all non-enumerable properties. Default is `{}`
+*
+* @returns The target with replaced values
+*/
+function copy(target$1, options = {}) {
+	if (isArray(target$1)) return target$1.map((item) => copy(item, options));
+	if (!isPlainObject(target$1)) return target$1;
+	const props = Object.getOwnPropertyNames(target$1);
+	const symbols = Object.getOwnPropertySymbols(target$1);
+	return [...props, ...symbols].reduce((carry, key) => {
+		if (key === "__proto__") return carry;
+		if (isArray(options.props) && !options.props.includes(key)) return carry;
+		const val = target$1[key];
+		assignProp(carry, key, copy(val, options), target$1, options.nonenumerable);
+		return carry;
+	}, {});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.5/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+	/**
+	* @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+	*/
+	constructor({ dedupe = false } = {}) {
+		this.classRegistry = new ClassRegistry();
+		this.symbolRegistry = new Registry((s) => {
+			var _s$description;
+			return (_s$description = s.description) !== null && _s$description !== void 0 ? _s$description : "";
+		});
+		this.customTransformerRegistry = new CustomTransformerRegistry();
+		this.allowedErrorProps = [];
+		this.dedupe = dedupe;
+	}
+	serialize(object) {
+		const identities = /* @__PURE__ */ new Map();
+		const output = walker(object, identities, this, this.dedupe);
+		const res = { json: output.transformedValue };
+		if (output.annotations) res.meta = _objectSpread2(_objectSpread2({}, res.meta), {}, { values: output.annotations });
+		const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+		if (equalityAnnotations) res.meta = _objectSpread2(_objectSpread2({}, res.meta), {}, { referentialEqualities: equalityAnnotations });
+		if (res.meta) res.meta.v = 1;
+		return res;
+	}
+	deserialize(payload, options) {
+		const { json, meta } = payload;
+		let result = (options === null || options === void 0 ? void 0 : options.inPlace) ? json : copy(json);
+		if (meta === null || meta === void 0 ? void 0 : meta.values) {
+			var _meta$v;
+			result = applyValueAnnotations(result, meta.values, (_meta$v = meta.v) !== null && _meta$v !== void 0 ? _meta$v : 0, this);
+		}
+		if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {
+			var _meta$v2;
+			result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, (_meta$v2 = meta.v) !== null && _meta$v2 !== void 0 ? _meta$v2 : 0);
+		}
+		return result;
+	}
+	stringify(object) {
+		return JSON.stringify(this.serialize(object));
+	}
+	parse(string) {
+		return this.deserialize(JSON.parse(string), { inPlace: true });
+	}
+	registerClass(v, options) {
+		this.classRegistry.register(v, options);
+	}
+	registerSymbol(v, identifier) {
+		this.symbolRegistry.register(v, identifier);
+	}
+	registerCustom(transformer, name) {
+		this.customTransformerRegistry.register(_objectSpread2({ name }, transformer));
+	}
+	allowErrorProps(...props) {
+		this.allowedErrorProps.push(...props);
+	}
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+const serialize = SuperJSON.serialize;
+const deserialize = SuperJSON.deserialize;
+const stringify = SuperJSON.stringify;
+const parse = SuperJSON.parse;
+const registerClass = SuperJSON.registerClass;
+const registerCustom = SuperJSON.registerCustom;
+const registerSymbol = SuperJSON.registerSymbol;
+const allowErrorProps = SuperJSON.allowErrorProps;
+
+//#endregion
+//#region src/messaging/presets/broadcast/client.ts
+const __REACT_DEVTOOLS_KIT_BROADCAST_MESSAGING_EVENT_KEY$1 = "__REACT_DEVTOOLS_KIT_BROADCAST_MESSAGE__";
+function createBroadcastClientChannel() {
+	if (!__react_devtools_plus_shared.isBrowser) return {
+		post: () => {},
+		on: () => {}
+	};
+	const channel = new BroadcastChannel(__REACT_DEVTOOLS_KIT_BROADCAST_MESSAGING_EVENT_KEY$1);
+	return {
+		post: (data) => channel.postMessage(SuperJSON.stringify(data)),
+		on: (handler) => channel.addEventListener("message", (event) => {
+			try {
+				handler(SuperJSON.parse(event.data));
+			} catch (e) {}
+		})
+	};
+}
+
+//#endregion
+//#region src/messaging/presets/broadcast/server.ts
+const __REACT_DEVTOOLS_KIT_BROADCAST_MESSAGING_EVENT_KEY = "__REACT_DEVTOOLS_KIT_BROADCAST_MESSAGE__";
+function createBroadcastServerChannel() {
+	if (!__react_devtools_plus_shared.isBrowser) return {
+		post: () => {},
+		on: () => {}
+	};
+	const channel = new BroadcastChannel(__REACT_DEVTOOLS_KIT_BROADCAST_MESSAGING_EVENT_KEY);
+	return {
+		post: (data) => channel.postMessage(SuperJSON.stringify(data)),
+		on: (handler) => channel.addEventListener("message", (event) => {
+			try {
+				handler(SuperJSON.parse(event.data));
+			} catch (e) {}
+		})
+	};
+}
+
+//#endregion
+//#region src/messaging/presets/iframe/context.ts
+let iframeServerContext = null;
+function setIframeServerContext(iframe) {
+	iframeServerContext = iframe;
+}
+function getIframeServerContext() {
+	return iframeServerContext;
+}
+const __REACT_DEVTOOLS_KIT_IFRAME_MESSAGING_EVENT_KEY = "__REACT_DEVTOOLS_KIT_IFRAME_MESSAGE__";
+
+//#endregion
+//#region src/messaging/presets/iframe/client.ts
+function createIframeClientChannel() {
+	if (!__react_devtools_plus_shared.isBrowser) return {
+		post: () => {},
+		on: () => {}
+	};
+	return {
+		post: (data) => window.parent.postMessage(SuperJSON.stringify({
+			event: __REACT_DEVTOOLS_KIT_IFRAME_MESSAGING_EVENT_KEY,
+			data
+		}), "*"),
+		on: (handler) => window.addEventListener("message", (event) => {
+			try {
+				const parsed = SuperJSON.parse(event.data);
+				if (event.source === window.parent && parsed.event === __REACT_DEVTOOLS_KIT_IFRAME_MESSAGING_EVENT_KEY) handler(parsed.data);
+			} catch (e) {}
+		})
+	};
+}
+
+//#endregion
+//#region src/messaging/presets/iframe/server.ts
+function createIframeServerChannel() {
+	if (!__react_devtools_plus_shared.isBrowser) return {
+		post: () => {},
+		on: () => {}
+	};
+	return {
+		post: (data) => {
+			var _iframe$contentWindow;
+			const iframe = getIframeServerContext();
+			iframe === null || iframe === void 0 || (_iframe$contentWindow = iframe.contentWindow) === null || _iframe$contentWindow === void 0 || _iframe$contentWindow.postMessage(SuperJSON.stringify({
+				event: __REACT_DEVTOOLS_KIT_IFRAME_MESSAGING_EVENT_KEY,
+				data
+			}), "*");
+		},
+		on: (handler) => {
+			window.addEventListener("message", (event) => {
+				const iframe = getIframeServerContext();
+				try {
+					const parsed = SuperJSON.parse(event.data);
+					if (event.source === (iframe === null || iframe === void 0 ? void 0 : iframe.contentWindow) && parsed.event === __REACT_DEVTOOLS_KIT_IFRAME_MESSAGING_EVENT_KEY) handler(parsed.data);
+				} catch (e) {}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/messaging/presets/index.ts
+function getChannel(preset, host = "client") {
+	return {
+		iframe: {
+			client: createIframeClientChannel,
+			server: createIframeServerChannel
+		},
+		broadcast: {
+			client: createBroadcastClientChannel,
+			server: createBroadcastServerChannel
+		}
+	}[preset][host]();
+}
+
+//#endregion
+//#region src/messaging/index.ts
+var _target$__REACT_DEVTO, _target$__REACT_DEVTO2;
+(_target$__REACT_DEVTO = __react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_CLIENT__) !== null && _target$__REACT_DEVTO !== void 0 || (__react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_CLIENT__ = null);
+(_target$__REACT_DEVTO2 = __react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_SERVER__) !== null && _target$__REACT_DEVTO2 !== void 0 || (__react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_SERVER__ = null);
+function setRpcClientToGlobal(rpc) {
+	__react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_CLIENT__ = rpc;
+}
+function setRpcServerToGlobal(rpc) {
+	__react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_SERVER__ = rpc;
+}
+function getRpcClient() {
+	var _target$__REACT_DEVTO3;
+	return (_target$__REACT_DEVTO3 = __react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_CLIENT__) !== null && _target$__REACT_DEVTO3 !== void 0 ? _target$__REACT_DEVTO3 : null;
+}
+function getRpcServer() {
+	var _target$__REACT_DEVTO4;
+	return (_target$__REACT_DEVTO4 = __react_devtools_plus_shared.target.__REACT_DEVTOOLS_KIT_RPC_SERVER__) !== null && _target$__REACT_DEVTO4 !== void 0 ? _target$__REACT_DEVTO4 : null;
+}
+function createRpcClient(functions, options = {}) {
+	const { channel: _channel, options: _options, preset } = options;
+	const channel = preset ? getChannel(preset, "client") : _channel;
+	const rpc = createBirpc(functions, _objectSpread2(_objectSpread2(_objectSpread2({}, _options), channel), {}, { timeout: -1 }));
+	setRpcClientToGlobal(rpc);
+	return rpc;
+}
+function createRpcServer(functions, options = {}) {
+	const { channel: _channel, preset } = options;
+	const channel = preset ? getChannel(preset, "server") : _channel;
+	const rpcServer = getRpcServer();
+	if (!rpcServer) setRpcServerToGlobal(createBirpcGroup(functions, [channel], { timeout: -1 }));
+	else rpcServer.updateChannels((channels) => {
+		channels.push(channel);
+	});
+}
+
+//#endregion
+exports.REACT_TAGS = REACT_TAGS;
+exports.TIMELINE_LAYERS = TIMELINE_LAYERS;
+exports.addComponentEvent = addComponentEvent;
+exports.addPerformanceEvent = addPerformanceEvent;
+exports.buildTree = buildTree;
+exports.cleanupHighlight = cleanupHighlight;
+exports.clearFiberRegistry = clearFiberRegistry;
+exports.clearNavigationHistory = clearNavigationHistory;
+exports.clearOverrides = clearOverrides;
+exports.clearTimeline = clearTimeline;
+exports.createRpcClient = createRpcClient;
+exports.createRpcServer = createRpcServer;
+exports.getAllContexts = getAllContexts;
+exports.getAppFiberRoot = getAppFiberRoot;
+exports.getComponentDetails = getComponentDetails;
+exports.getComponentHookStates = getComponentHookStates;
+exports.getContextProviderInfo = getContextProviderInfo;
+exports.getContextTree = getContextTree;
+exports.getDisplayName = getDisplayName;
+exports.getFiberById = getFiberById;
+exports.getFiberFromElement = getFiberFromElement;
+exports.getFiberId = getFiberId;
+exports.getFiberRoot = getFiberRoot;
+exports.getOverriddenContext = getOverriddenContext;
+exports.getOverriddenProp = getOverriddenProp;
+exports.getReactVersion = getReactVersion;
+exports.getRouterInfo = getRouterInfo;
+exports.getRpcClient = getRpcClient;
+exports.getRpcServer = getRpcServer;
+exports.getTimelineState = getTimelineState;
+exports.hideHighlight = hideHighlight;
+exports.highlightNode = highlightNode;
+exports.installReactHook = installReactHook;
+exports.installTimelineEventListeners = installTimelineEventListeners;
+exports.isEditableProp = isEditableProp;
+exports.mergeClientRects = mergeClientRects;
+exports.navigateTo = navigateTo;
+exports.onInspectorSelect = onInspectorSelect;
+exports.onOpenInEditor = onOpenInEditor;
+exports.onTimelineEvent = onTimelineEvent;
+exports.onTreeUpdated = onTreeUpdated;
+exports.openInEditor = openInEditor;
+exports.parseValue = parseValue;
+exports.rebuildTree = rebuildTree;
+exports.scrollToNode = scrollToNode;
+exports.setComponentProp = setComponentProp;
+exports.setContextValue = setContextValue;
+exports.setContextValueAtPath = setContextValueAtPath;
+exports.setContextValueFromJson = setContextValueFromJson;
+exports.setFiberRoot = setFiberRoot;
+exports.setHookState = setHookState;
+exports.setHookStateFromJson = setHookStateFromJson;
+exports.setIframeServerContext = setIframeServerContext;
+exports.setRpcServerToGlobal = setRpcServerToGlobal;
+exports.shouldIncludeFiber = shouldIncludeFiber;
+exports.showHighlight = showHighlight;
+exports.toggleInspector = toggleInspector;
+exports.trackFiberPerformanceEnd = trackFiberPerformanceEnd;
+exports.trackFiberPerformanceStart = trackFiberPerformanceStart;
+exports.updateTimelineState = updateTimelineState;