react-grab 0.1.28 → 0.1.30

package/dist/freeze-updates-BXMr6a9g.cjs

@@ -0,0 +1,2912 @@
+/**
+ * @license MIT
+ *
+ * Copyright (c) 2025 Aiden Bai
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//#region src/utils/supports-display-p3.ts
+let cachedResult = null;
+const supportsDisplayP3 = () => {
+	if (cachedResult !== null) return cachedResult;
+	try {
+		cachedResult = window.matchMedia("(color-gamut: p3)").matches;
+	} catch {
+		cachedResult = false;
+	}
+	return cachedResult;
+};
+
+//#endregion
+//#region src/utils/overlay-color.ts
+const isWideGamut = supportsDisplayP3();
+const SRGB_COMPONENTS = "210, 57, 192";
+const P3_COMPONENTS = "0.84 0.19 0.78";
+const overlayColor = (alpha) => isWideGamut ? `color(display-p3 ${P3_COMPONENTS} / ${alpha})` : `rgba(${SRGB_COMPONENTS}, ${alpha})`;
+
+//#endregion
+//#region src/constants.ts
+const VERSION = "[DEV]";
+const OFFSCREEN_POSITION = -1e3;
+const SELECTION_LERP_FACTOR = .95;
+const FEEDBACK_DURATION_MS = 1500;
+const SYMBOLICATION_TIMEOUT_MS = 5e3;
+const MAX_SELECTOR_COMBINATIONS = 1e4;
+const Z_INDEX_OVERLAY = 2147483647;
+const Z_INDEX_OVERLAY_CANVAS = 2147483645;
+const DRAG_LERP_FACTOR = .7;
+const LERP_CONVERGENCE_THRESHOLD_PX = .5;
+const OPACITY_CONVERGENCE_THRESHOLD = .01;
+const OVERLAY_BORDER_COLOR_DRAG = overlayColor(.4);
+const OVERLAY_FILL_COLOR_DRAG = overlayColor(.05);
+const OVERLAY_BORDER_COLOR_DEFAULT = overlayColor(.5);
+const OVERLAY_FILL_COLOR_DEFAULT = overlayColor(.08);
+const OVERLAY_BORDER_COLOR_INSPECT = overlayColor(.3);
+const OVERLAY_FILL_COLOR_INSPECT = overlayColor(.04);
+const FROZEN_GLOW_COLOR = overlayColor(.15);
+const ARROW_MAX_LABEL_WIDTH_RATIO = .2;
+const PREVIEW_PRIORITY_ATTRS = [
+	"id",
+	"class",
+	"aria-label",
+	"data-testid",
+	"role",
+	"name",
+	"title"
+];
+const MODIFIER_KEYS = [
+	"Meta",
+	"Control",
+	"Shift",
+	"Alt"
+];
+const ARROW_KEYS = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight"
+]);
+const FROZEN_ELEMENT_ATTRIBUTE = "data-react-grab-frozen";
+const USER_IGNORE_ATTRIBUTE = "data-react-grab-ignore";
+const VIEWPORT_COVERAGE_THRESHOLD = .9;
+const OVERLAY_Z_INDEX_THRESHOLD = 1e3;
+const DEV_TOOLS_OVERLAY_Z_INDEX_THRESHOLD = 2147483600;
+const TOOLBAR_DEFAULT_POSITION_RATIO = .5;
+const DEFAULT_ACTION_ID = "comment";
+const TOOLBAR_SHAKE_TOOLTIP_DURATION_MS = 1500;
+const SELECTION_HINT_CYCLE_INTERVAL_MS = 3e3;
+const TOOLTIP_BASE_CLASS = "absolute whitespace-nowrap px-1.5 py-0.5 rounded-[10px] text-[10px] text-black/60 pointer-events-none [corner-shape:superellipse(1.25)] filter-[drop-shadow(0px_1px_2px_#51515140)]";
+const HINT_FLIP_IN_ANIMATION = "animate-[hint-flip-in_var(--transition-normal)_ease-out]";
+const DRAG_SELECTION_COVERAGE_THRESHOLD = .75;
+const ZOOM_DETECTION_THRESHOLD = .01;
+const MOUNT_ROOT_RECHECK_DELAY_MS = 1e3;
+const MAX_SESSION_STORAGE_SIZE_BYTES = 2 * 1024 * 1024;
+const DROPDOWN_OFFSCREEN_POSITION = {
+	left: -9999,
+	top: -9999
+};
+const DROPDOWN_EDGE_TRANSFORM_ORIGIN = {
+	left: "left center",
+	right: "right center",
+	top: "center top",
+	bottom: "center bottom"
+};
+const NEXTJS_REVALIDATION_DELAY_MS = 1e3;
+const SELECTION_LABEL_OFFSCREEN_PX = -9999;
+const RELEVANT_CSS_PROPERTIES = new Set([
+	"display",
+	"position",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"z-index",
+	"overflow",
+	"overflow-x",
+	"overflow-y",
+	"width",
+	"height",
+	"min-width",
+	"min-height",
+	"max-width",
+	"max-height",
+	"margin-top",
+	"margin-right",
+	"margin-bottom",
+	"margin-left",
+	"padding-top",
+	"padding-right",
+	"padding-bottom",
+	"padding-left",
+	"flex-direction",
+	"flex-wrap",
+	"justify-content",
+	"align-items",
+	"align-self",
+	"align-content",
+	"flex-grow",
+	"flex-shrink",
+	"flex-basis",
+	"order",
+	"gap",
+	"row-gap",
+	"column-gap",
+	"grid-template-columns",
+	"grid-template-rows",
+	"grid-template-areas",
+	"font-family",
+	"font-size",
+	"font-weight",
+	"font-style",
+	"line-height",
+	"letter-spacing",
+	"text-align",
+	"text-decoration-line",
+	"text-decoration-style",
+	"text-transform",
+	"text-overflow",
+	"text-shadow",
+	"white-space",
+	"word-break",
+	"overflow-wrap",
+	"vertical-align",
+	"color",
+	"background-color",
+	"background-image",
+	"background-position",
+	"background-size",
+	"background-repeat",
+	"border-top-width",
+	"border-right-width",
+	"border-bottom-width",
+	"border-left-width",
+	"border-top-style",
+	"border-right-style",
+	"border-bottom-style",
+	"border-left-style",
+	"border-top-color",
+	"border-right-color",
+	"border-bottom-color",
+	"border-left-color",
+	"border-top-left-radius",
+	"border-top-right-radius",
+	"border-bottom-left-radius",
+	"border-bottom-right-radius",
+	"box-shadow",
+	"opacity",
+	"transform",
+	"filter",
+	"backdrop-filter",
+	"object-fit",
+	"object-position"
+]);
+
+//#endregion
+//#region src/utils/get-tag-name.ts
+const getTagName = (element) => (element.tagName || "").toLowerCase();
+
+//#endregion
+//#region src/utils/detect-csp-nonce.ts
+let cachedNonce;
+const detectCspNonce = () => {
+	if (cachedNonce !== void 0) return cachedNonce;
+	const existingElement = document.querySelector("script[nonce], style[nonce]");
+	const nonce = existingElement?.nonce || existingElement?.getAttribute("nonce") || null;
+	if (nonce) cachedNonce = nonce;
+	return nonce;
+};
+
+//#endregion
+//#region src/utils/hide-from-third-parties.ts
+const THIRD_PARTY_PRIVACY_ATTRIBUTES = [
+	["data-rr-block", ""],
+	["data-rr-ignore", ""],
+	["data-rr-mask", ""],
+	["data-sentry-block", ""],
+	["data-sentry-ignore", ""],
+	["data-sentry-mask", ""],
+	["data-dd-privacy", "hidden"],
+	["data-fs-exclude", ""],
+	["data-lr-exclude", ""],
+	["data-hj-suppress", ""],
+	["data-recording-disable", ""],
+	["data-clarity-mask", "true"],
+	["data-heap-redact-text", ""]
+];
+const hideFromThirdParties = (element) => {
+	for (const [attributeName, attributeValue] of THIRD_PARTY_PRIVACY_ATTRIBUTES) element.setAttribute(attributeName, attributeValue);
+	element.setAttribute("data-testid", "react-grab-overlay");
+	element.classList.add("ph-no-capture");
+};
+
+//#endregion
+//#region src/utils/native-raf.ts
+const isClientSide = typeof window !== "undefined";
+const noopAnimationFrame = (_callback) => 0;
+const noopCancelFrame = (_id) => {};
+const nativeRequestAnimationFrame = isClientSide ? (Object.getOwnPropertyDescriptor(Window.prototype, "requestAnimationFrame")?.value ?? window.requestAnimationFrame).bind(window) : noopAnimationFrame;
+const nativeCancelAnimationFrame = isClientSide ? (Object.getOwnPropertyDescriptor(Window.prototype, "cancelAnimationFrame")?.value ?? window.cancelAnimationFrame).bind(window) : noopCancelFrame;
+const waitUntilNextFrame = () => isClientSide ? new Promise((resolve) => nativeRequestAnimationFrame(() => resolve())) : Promise.resolve();
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.37_react@19.2.3/node_modules/bippy/dist/rdt-hook.js
+/**
+* @license bippy
+*
+* Copyright (c) Aiden Bai
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+const e = `0.5.37`, t = `bippy-${e}`, n = Object.defineProperty, r = Object.prototype.hasOwnProperty, i$1 = () => {}, a$1 = (e) => {
+	try {
+		Function.prototype.toString.call(e).indexOf(`^_^`) > -1 && setTimeout(() => {
+			throw Error(`React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://reactjs.org/link/perf-use-production-build`);
+		});
+	} catch {}
+}, o$1 = (e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => !!(e && `getFiberRoots` in e);
+let s$1 = !1, c$1;
+const l$1 = (e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => s$1 ? !0 : (e && typeof e.inject == `function` && (c$1 = e.inject.toString()), !!c$1?.includes(`(injected)`)), u$1 = /* @__PURE__ */ new Set(), d$2 = /* @__PURE__ */ new Set(), f$2 = (e) => {
+	let r = /* @__PURE__ */ new Map(), o = 0, s = {
+		_instrumentationIsActive: !1,
+		_instrumentationSource: t,
+		checkDCE: a$1,
+		hasUnsupportedRendererAttached: !1,
+		inject(e) {
+			let t = ++o;
+			return r.set(t, e), d$2.add(e), s._instrumentationIsActive || (s._instrumentationIsActive = !0, u$1.forEach((e) => e())), t;
+		},
+		on: i$1,
+		onCommitFiberRoot: i$1,
+		onCommitFiberUnmount: i$1,
+		onPostCommitFiberRoot: i$1,
+		renderers: r,
+		supportsFiber: !0,
+		supportsFlight: !0
+	};
+	try {
+		n(globalThis, `__REACT_DEVTOOLS_GLOBAL_HOOK__`, {
+			configurable: !0,
+			enumerable: !0,
+			get() {
+				return s;
+			},
+			set(t) {
+				if (t && typeof t == `object`) {
+					let n = s.renderers;
+					s = t, n.size > 0 && (n.forEach((e, n) => {
+						d$2.add(e), t.renderers.set(n, e);
+					}), p$2(e));
+				}
+			}
+		});
+		let t = window.hasOwnProperty, r = !1;
+		n(window, `hasOwnProperty`, {
+			configurable: !0,
+			value: function(...e) {
+				try {
+					if (!r && e[0] === `__REACT_DEVTOOLS_GLOBAL_HOOK__`) return globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__ = void 0, r = !0, -0;
+				} catch {}
+				return t.apply(this, e);
+			},
+			writable: !0
+		});
+	} catch {
+		p$2(e);
+	}
+	return s;
+}, p$2 = (e) => {
+	e && u$1.add(e);
+	try {
+		let n = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+		if (!n) return;
+		if (!n._instrumentationSource) {
+			n.checkDCE = a$1, n.supportsFiber = !0, n.supportsFlight = !0, n.hasUnsupportedRendererAttached = !1, n._instrumentationSource = t, n._instrumentationIsActive = !1;
+			let e = o$1(n);
+			if (e || (n.on = i$1), n.renderers.size) {
+				n._instrumentationIsActive = !0, u$1.forEach((e) => e());
+				return;
+			}
+			let r = n.inject, c = l$1(n);
+			c && !e && (s$1 = !0, n.inject({ scheduleRefresh() {} }) && (n._instrumentationIsActive = !0)), n.inject = (e) => {
+				let t = r(e);
+				return d$2.add(e), c && n.renderers.set(t, e), n._instrumentationIsActive = !0, u$1.forEach((e) => e()), t;
+			};
+		}
+		(n.renderers.size || n._instrumentationIsActive || l$1()) && e?.();
+	} catch {}
+}, m$2 = () => r.call(globalThis, `__REACT_DEVTOOLS_GLOBAL_HOOK__`), h$2 = (e) => m$2() ? (p$2(e), globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) : f$2(e), g$2 = () => !!(typeof window < `u` && (window.document?.createElement || window.navigator?.product === `ReactNative`)), _$2 = () => {
+	try {
+		g$2() && h$2();
+	} catch {}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.37_react@19.2.3/node_modules/bippy/dist/core.js
+/**
+* @license bippy
+*
+* Copyright (c) Aiden Bai
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+const d$1 = 0, ee$1 = 1, te$1 = 3, ne$1 = 5, re$1 = 6, ie$1 = 7, f$1 = 9, p$1 = 11, m$1 = 13, h$1 = 14, g$1 = 15, ae$1 = 16, oe$1 = 18, se$1 = 19, ce$1 = 22, le$1 = 23, ue$1 = 26, de$1 = 27, fe$1 = 28, pe$1 = 30, _$1 = 60111, me$1 = `Symbol(react.element)`, he$1 = `Symbol(react.transitional.element)`, v$1 = `Symbol(react.concurrent_mode)`, y$1 = `Symbol(react.async_mode)`, b$1 = 13366, ge$1 = (e) => typeof e == `object` && !!e && `$$typeof` in e && [`Symbol(react.element)`, `Symbol(react.transitional.element)`].includes(String(e.$$typeof)), _e$1 = (e) => typeof e == `object` && !!e && `tag` in e && `stateNode` in e && `return` in e && `child` in e && `sibling` in e && `flags` in e, x$1 = (e) => {
+	switch (e.tag) {
+		case 5:
+		case 26:
+		case 27: return !0;
+		default: return typeof e.type == `string`;
+	}
+}, ve$1 = (e) => {
+	switch (e.tag) {
+		case 1:
+		case 11:
+		case 0:
+		case 14:
+		case 15: return !0;
+		default: return !1;
+	}
+}, ye$1 = (e) => !e || typeof e != `object` ? !1 : `pendingProps` in e && !(`containerInfo` in e), be$1 = (e, t) => e === t || e.alternate === t || t.alternate === e, xe$1 = (e, t) => {
+	try {
+		let n = e.dependencies, r = e.alternate?.dependencies;
+		if (!n || !r || typeof n != `object` || !(`firstContext` in n) || typeof r != `object` || !(`firstContext` in r)) return !1;
+		let i = n.firstContext, a = r.firstContext;
+		for (; i && typeof i == `object` && `memoizedValue` in i || a && typeof a == `object` && `memoizedValue` in a;) {
+			if (t(i, a) === !0) return !0;
+			i = i?.next, a = a?.next;
+		}
+	} catch {}
+	return !1;
+}, S$1 = (e, t) => {
+	try {
+		let n = e.memoizedState, r = e.alternate?.memoizedState;
+		for (; n || r;) {
+			if (t(n, r) === !0) return !0;
+			n = n?.next, r = r?.next;
+		}
+	} catch {}
+	return !1;
+}, C$1 = (e, t) => {
+	try {
+		let n = e.memoizedProps, r = e.alternate?.memoizedProps || {}, i = new Set([...Object.keys(n), ...Object.keys(r)]);
+		for (let e of i) {
+			let i = r?.[e], a = n?.[e];
+			if (t(e, a, i) === !0) return !0;
+		}
+	} catch {}
+	return !1;
+}, w$1 = (e) => {
+	let t = e.memoizedProps, n = e.alternate?.memoizedProps || {}, r = e.flags ?? e.effectTag ?? 0;
+	switch (e.tag) {
+		case 1:
+		case 9:
+		case 11:
+		case 0:
+		case 14:
+		case 15: return (r & 1) == 1;
+		default: return e.alternate ? n !== t || e.alternate.memoizedState !== e.memoizedState || e.alternate.ref !== e.ref : !0;
+	}
+}, T$1 = (e) => !!(e.flags & (b$1 | 8) || e.subtreeFlags & (b$1 | 8)), E$1 = (e) => {
+	let t = [], n = [e];
+	for (; n.length;) {
+		let e = n.pop();
+		e && (x$1(e) && T$1(e) && w$1(e) && t.push(e), e.child && n.push(e.child), e.sibling && n.push(e.sibling));
+	}
+	return t;
+}, D$1 = (e) => {
+	let t = [], n = e;
+	for (; n.return;) t.push(n), n = n.return;
+	return t;
+}, O$1 = (e) => {
+	switch (e.tag) {
+		case 18: return !0;
+		case 7:
+		case 6:
+		case 23:
+		case 22: return !0;
+		case 3: return !1;
+		default: {
+			let t = typeof e.type == `object` && e.type !== null ? e.type.$$typeof : e.type;
+			switch (typeof t == `symbol` ? t.toString() : t) {
+				case _$1:
+				case v$1:
+				case y$1: return !0;
+				default: return !1;
+			}
+		}
+	}
+}, k$1 = (e, t = !1) => {
+	let n = j$1(e, x$1, t);
+	return n ||= j$1(e, x$1, !t), n;
+}, A$1 = (e) => {
+	let t = [], n = [];
+	for (x$1(e) ? t.push(e) : e.child && n.push(e.child); n.length;) {
+		let e = n.pop();
+		if (!e) break;
+		x$1(e) ? t.push(e) : e.child && n.push(e.child), e.sibling && n.push(e.sibling);
+	}
+	return t;
+};
+function j$1(e, t, n = !1) {
+	if (!e) return null;
+	let r = t(e);
+	if (r instanceof Promise) return (async () => {
+		if (await r === !0) return e;
+		let i = n ? e.return : e.child;
+		for (; i;) {
+			let e = await N$1(i, t, n);
+			if (e) return e;
+			i = n ? null : i.sibling;
+		}
+		return null;
+	})();
+	if (r === !0) return e;
+	let i = n ? e.return : e.child;
+	for (; i;) {
+		let e = M$1(i, t, n);
+		if (e) return e;
+		i = n ? null : i.sibling;
+	}
+	return null;
+}
+const M$1 = (e, t, n = !1) => {
+	if (!e) return null;
+	if (t(e) === !0) return e;
+	let r = n ? e.return : e.child;
+	for (; r;) {
+		let e = M$1(r, t, n);
+		if (e) return e;
+		r = n ? null : r.sibling;
+	}
+	return null;
+}, N$1 = async (e, t, n = !1) => {
+	if (!e) return null;
+	if (await t(e) === !0) return e;
+	let r = n ? e.return : e.child;
+	for (; r;) {
+		let e = await N$1(r, t, n);
+		if (e) return e;
+		r = n ? null : r.sibling;
+	}
+	return null;
+}, Se = (e) => {
+	let t = e?.actualDuration ?? 0, n = t, r = e?.child ?? null;
+	for (; t > 0 && r != null;) n -= r.actualDuration ?? 0, r = r.sibling;
+	return {
+		selfTime: n,
+		totalTime: t
+	};
+}, Ce = (e) => !!e.updateQueue?.memoCache, P$1 = (e) => {
+	let t = e;
+	return typeof t == `function` ? t : typeof t == `object` && t ? P$1(t.type || t.render) : null;
+}, we = (e) => {
+	let t = e;
+	if (typeof t == `string`) return t;
+	if (typeof t != `function` && !(typeof t == `object` && t)) return null;
+	let n = t.displayName || t.name || null;
+	if (n) return n;
+	let r = P$1(t);
+	return r && (r.displayName || r.name) || null;
+}, F$1 = (e) => {
+	try {
+		if (typeof e.version == `string` && e.bundleType > 0) return `development`;
+	} catch {}
+	return `production`;
+}, Te = () => {
+	let e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	return !!e?._instrumentationIsActive || o$1(e) || l$1(e);
+}, Ee = (e) => {
+	let t = e.alternate;
+	if (!t) return e;
+	if (t.actualStartTime && e.actualStartTime) return t.actualStartTime > e.actualStartTime ? t : e;
+	for (let t of $$1) {
+		let n = j$1(t.current, (t) => {
+			if (t === e) return !0;
+		});
+		if (n) return n;
+	}
+	return e;
+};
+let G$1 = null, K$1 = null, q$1 = null;
+const J$1 = () => {
+	if (!m$2()) return null;
+	let e = h$2();
+	if (!e?.renderers) return null;
+	if (G$1 || K$1 || q$1) return {
+		overrideContext: q$1,
+		overrideHookState: K$1,
+		overrideProps: G$1
+	};
+	for (let [, t] of Array.from(e.renderers)) try {
+		if (K$1) {
+			let e = K$1;
+			K$1 = (n, r, i, a) => {
+				let o = n.memoizedState;
+				for (let e = 0; e < Number(r) && o?.next; e++) o = o.next;
+				if (o?.queue) {
+					let e = o.queue;
+					if (Y$1(e) && `dispatch` in e) {
+						let t = e.dispatch;
+						t(a);
+						return;
+					}
+				}
+				e(n, r, i, a), t.overrideHookState?.(n, r, i, a);
+			};
+		} else t.overrideHookState && (K$1 = t.overrideHookState);
+		if (G$1) {
+			let e = G$1;
+			G$1 = (n, r, i) => {
+				e(n, r, i), t.overrideProps?.(n, r, i);
+			};
+		} else t.overrideProps && (G$1 = t.overrideProps);
+		q$1 = (e, t, n, r) => {
+			let i = e;
+			for (; i;) {
+				let e = i.type;
+				if (e === t || e?.Provider === t) {
+					G$1 && (G$1(i, [`value`, ...n], r), i.alternate && G$1(i.alternate, [`value`, ...n], r));
+					break;
+				}
+				i = i.return;
+			}
+		};
+	} catch {}
+}, Y$1 = (e) => Object.prototype.toString.call(e) === `[object Object]` && (Object.getPrototypeOf(e) === Object.prototype || Object.getPrototypeOf(e) === null), X$1 = (e, t = []) => {
+	if (!Y$1(e)) return [{
+		path: t,
+		value: e
+	}];
+	let n = [];
+	for (let r in e) {
+		let i = e[r], a = t.concat(r);
+		Y$1(i) ? n.push(...X$1(i, a)) : n.push({
+			path: a,
+			value: i
+		});
+	}
+	return n;
+}, ke = (e, t) => {
+	J$1();
+	let n = X$1(t);
+	for (let { path: t, value: r } of n) try {
+		G$1?.(e, t, r);
+	} catch {}
+}, Ae = (e, t, n) => {
+	J$1();
+	let r = String(t);
+	if (Y$1(n)) {
+		let t = X$1(n);
+		for (let { path: n, value: i } of t) try {
+			K$1?.(e, r, n, i);
+		} catch {}
+	} else try {
+		K$1?.(e, r, [], n);
+	} catch {}
+}, je = (e, t, n) => {
+	if (J$1(), Y$1(n)) {
+		let r = X$1(n);
+		for (let { path: n, value: i } of r) try {
+			q$1?.(e, t, n, i);
+		} catch {}
+	} else try {
+		q$1?.(e, t, [], n);
+	} catch {}
+}, Me = (e) => {
+	let t$1 = h$2(e.onActive);
+	t$1._instrumentationSource = e.name ?? t;
+	let n = t$1.onCommitFiberRoot;
+	if (e.onCommitFiberRoot) {
+		let r = (t, i, a) => {
+			n !== r && (n?.(t, i, a), e.onCommitFiberRoot?.(t, i, a));
+		};
+		t$1.onCommitFiberRoot = r;
+	}
+	let r = t$1.onCommitFiberUnmount;
+	if (e.onCommitFiberUnmount) {
+		let n = (i, a) => {
+			t$1.onCommitFiberUnmount === n && (r?.(i, a), e.onCommitFiberUnmount?.(i, a));
+		};
+		t$1.onCommitFiberUnmount = n;
+	}
+	let i = t$1.onPostCommitFiberRoot;
+	if (e.onPostCommitFiberRoot) {
+		let n = (r, a) => {
+			t$1.onPostCommitFiberRoot === n && (i?.(r, a), e.onPostCommitFiberRoot?.(r, a));
+		};
+		t$1.onPostCommitFiberRoot = n;
+	}
+	return t$1;
+}, Z$1 = (e) => {
+	let t = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	if (t?.renderers) for (let n of t.renderers.values()) try {
+		let t = n.findFiberByHostInstance?.(e);
+		if (t) return t;
+	} catch {}
+	if (typeof e == `object` && e) {
+		if (`_reactRootContainer` in e) return e._reactRootContainer?._internalRoot?.current?.child;
+		for (let t in e) if (t.startsWith(`__reactContainer$`) || t.startsWith(`__reactInternalInstance$`) || t.startsWith(`__reactFiber`)) return e[t] || null;
+	}
+	return null;
+}, Q$1 = Error(), $$1 = /* @__PURE__ */ new Set(), Ne = (e, n = {}) => {
+	let i = e.onActive, a = m$2(), o = o$1(), l = l$1(), u, d = !n.isProduction;
+	return e.onActive = () => {
+		clearTimeout(u);
+		let t = !0;
+		try {
+			let e = h$2();
+			for (let r of e.renderers.values()) {
+				let [e] = r.version.split(`.`);
+				Number(e) < (n.minReactMajorVersion ?? 17) && (t = !1), F$1(r) === `development` ? d = !0 : n.dangerouslyRunInProduction || (t = !1);
+			}
+		} catch (e) {
+			n.onError?.(e);
+		}
+		if (!t) {
+			e.onCommitFiberRoot = void 0, e.onCommitFiberUnmount = void 0, e.onPostCommitFiberRoot = void 0, e.onActive = void 0;
+			return;
+		}
+		i?.();
+		try {
+			let t = e.onCommitFiberRoot;
+			t && (e.onCommitFiberRoot = (e, r, i) => {
+				$$1.has(r) || $$1.add(r);
+				try {
+					t(e, r, i);
+				} catch (e) {
+					n.onError?.(e);
+				}
+			});
+			let r = e.onCommitFiberUnmount;
+			r && (e.onCommitFiberUnmount = (e, t) => {
+				try {
+					r(e, t);
+				} catch (e) {
+					n.onError?.(e);
+				}
+			});
+			let i = e.onPostCommitFiberRoot;
+			i && (e.onPostCommitFiberRoot = (e, t) => {
+				try {
+					i(e, t);
+				} catch (e) {
+					n.onError?.(e);
+				}
+			});
+		} catch (e) {
+			n.onError?.(e);
+		}
+	}, !a && !o && !l && (u = setTimeout(() => {
+		d && n.onError?.(Q$1), stop();
+	}, n.installCheckTimeout ?? 100)), e;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.37_react@19.2.3/node_modules/bippy/dist/source.js
+/**
+* @license bippy
+*
+* Copyright (c) Aiden Bai
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+const i = /^[a-zA-Z][a-zA-Z\d+\-.]*:/, a = [
+	`rsc://`,
+	`file:///`,
+	`webpack://`,
+	`webpack-internal://`,
+	`node:`,
+	`turbopack://`,
+	`metro://`,
+	`/app-pages-browser/`,
+	`/(app-pages-browser)/`
+], o = [
+	`<anonymous>`,
+	`eval`,
+	``
+], s = /\.(jsx|tsx|ts|js)$/, c = /(\.min|bundle|chunk|vendor|vendors|runtime|polyfill|polyfills)\.(js|mjs|cjs)$|(chunk|bundle|vendor|vendors|runtime|polyfill|polyfills|framework|app|main|index)[-_.][A-Za-z0-9_-]{4,}\.(js|mjs|cjs)$|[\da-f]{8,}\.(js|mjs|cjs)$|[-_.][\da-f]{20,}\.(js|mjs|cjs)$|\/dist\/|\/build\/|\/.next\/|\/out\/|\/node_modules\/|\.webpack\.|\.vite\.|\.turbopack\./i, l = /^\?[\w~.-]+(?:=[^&#]*)?(?:&[\w~.-]+(?:=[^&#]*)?)*$/, u = /(^|@)\S+:\d+/, d = /^\s*at .*(\S+:\d+|\(native\))/m, f = /^(eval@)?(\[native code\])?$/, p = (e) => {
+	if (e && typeof e == `object`) {
+		let t = e.stacktrace;
+		return typeof t == `string` ? t : null;
+	}
+	return null;
+}, m = (e, t) => {
+	if (t?.includeInElement !== !1) {
+		let n = e.split(`
+`), r = [];
+		for (let e of n) if (/^\s*at\s+/.test(e)) {
+			let t = v(e, void 0)[0];
+			t && r.push(t);
+		} else if (/^\s*in\s+/.test(e)) {
+			let t = e.replace(/^\s*in\s+/, ``).replace(/\s*\(at .*\)$/, ``);
+			r.push({
+				functionName: t,
+				source: e
+			});
+		} else if (e.match(u)) {
+			let t = y(e, void 0)[0];
+			t && r.push(t);
+		}
+		return g(r, t);
+	}
+	return e.match(d) ? v(e, t) : y(e, t);
+}, h = (e) => {
+	if (!e.includes(`:`)) return [
+		e,
+		void 0,
+		void 0
+	];
+	let t = e.startsWith(`(`) && /:\d+\)$/.test(e) ? e.slice(1, -1) : e, n = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(t);
+	return n ? [
+		n[1],
+		n[2] || void 0,
+		n[3] || void 0
+	] : [
+		t,
+		void 0,
+		void 0
+	];
+}, g = (e, t) => t && t.slice != null ? Array.isArray(t.slice) ? e.slice(t.slice[0], t.slice[1]) : e.slice(0, t.slice) : e, _ = (e, t) => v(e.stack, t), v = (e, t) => g(e.split(`
+`).filter((e) => !!e.match(d)), t).map((e) => {
+	let t = e;
+	t.includes(`(eval `) && (t = t.replace(/eval code/g, `eval`).replace(/(\(eval at [^()]*)|(,.*$)/g, ``));
+	let n = t.replace(/^\s+/, ``).replace(/\(eval code/g, `(`).replace(/^.*?\s+/, ``), r = n.match(/ (\(.+\)$)/);
+	n = r ? n.replace(r[0], ``) : n;
+	let i = h(r ? r[1] : n);
+	return {
+		functionName: r && n || void 0,
+		fileName: [`eval`, `<anonymous>`].includes(i[0]) ? void 0 : i[0],
+		lineNumber: i[1] ? +i[1] : void 0,
+		columnNumber: i[2] ? +i[2] : void 0,
+		source: t
+	};
+}), ee = (e, t) => y(e.stack, t), y = (e, t) => g(e.split(`
+`).filter((e) => !e.match(f)), t).map((e) => {
+	let t = e;
+	if (t.includes(` > eval`) && (t = t.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, `:$1`)), !t.includes(`@`) && !t.includes(`:`)) return { functionName: t };
+	{
+		let e = /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/, n = t.match(e), r = n && n[1] ? n[1] : void 0, i = h(t.replace(e, ``));
+		return {
+			functionName: r,
+			fileName: i[0],
+			lineNumber: i[1] ? +i[1] : void 0,
+			columnNumber: i[2] ? +i[2] : void 0,
+			source: t
+		};
+	}
+}), te = (e, t) => {
+	let n = p(e);
+	return !n || e.message.includes(`
+`) && e.message.split(`
+`).length > n.split(`
+`).length ? b(e, t) : e.stack ? S(e, t) : x(e, t);
+}, b = (e, t) => {
+	let n = /Line (\d+).*script (?:in )?(\S+)/i, r = e.message.split(`
+`), i = [];
+	for (let e = 2, t = r.length; e < t; e += 2) {
+		let t = n.exec(r[e]);
+		t && i.push({
+			fileName: t[2],
+			lineNumber: +t[1],
+			source: r[e]
+		});
+	}
+	return g(i, t);
+}, x = (e, t) => {
+	let n = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i, r = (p(e) || ``).split(`
+`), i = [];
+	for (let e = 0, t = r.length; e < t; e += 2) {
+		let t = n.exec(r[e]);
+		t && i.push({
+			functionName: t[3] || void 0,
+			fileName: t[2],
+			lineNumber: t[1] ? +t[1] : void 0,
+			source: r[e]
+		});
+	}
+	return g(i, t);
+}, S = (e, t) => g(e.stack.split(`
+`).filter((e) => !!e.match(u) && !e.match(/^Error created at/)), t).map((e) => {
+	let t = e.split(`@`), n = h(t.pop()), r = t.shift() || ``, i = r.replace(/<anonymous function(: (\w+))?>/, `$2`).replace(/\([^)]*\)/g, ``) || void 0, a;
+	return r.match(/\(([^)]*)\)/) && (a = r.replace(/^[^(]+\(([^)]*)\)$/, `$1`)), {
+		functionName: i,
+		args: a === void 0 || a === `[arguments not available]` ? void 0 : a.split(`,`),
+		fileName: n[0],
+		lineNumber: n[1] ? +n[1] : void 0,
+		columnNumber: n[2] ? +n[2] : void 0,
+		source: e
+	};
+});
+var ne = 44, C = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`, re = new Uint8Array(64), w = new Uint8Array(128);
+for (let e = 0; e < C.length; e++) {
+	let t = C.charCodeAt(e);
+	re[e] = t, w[t] = e;
+}
+function T(e, t) {
+	let n = 0, r = 0, i = 0;
+	do
+		i = w[e.next()], n |= (i & 31) << r, r += 5;
+	while (i & 32);
+	let a = n & 1;
+	return n >>>= 1, a && (n = -2147483648 | -n), t + n;
+}
+function E(e, t) {
+	return e.pos >= t ? !1 : e.peek() !== ne;
+}
+var D = class {
+	constructor(e) {
+		this.pos = 0, this.buffer = e;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(e) {
+		let { buffer: t, pos: n } = this, r = t.indexOf(e, n);
+		return r === -1 ? t.length : r;
+	}
+};
+function O(e) {
+	let { length: t } = e, n = new D(e), r = [], i = 0, a = 0, o = 0, s = 0, c = 0;
+	do {
+		let e = n.indexOf(`;`), t = [], l = !0, u = 0;
+		for (i = 0; n.pos < e;) {
+			let r;
+			i = T(n, i), i < u && (l = !1), u = i, E(n, e) ? (a = T(n, a), o = T(n, o), s = T(n, s), E(n, e) ? (c = T(n, c), r = [
+				i,
+				a,
+				o,
+				s,
+				c
+			]) : r = [
+				i,
+				a,
+				o,
+				s
+			]) : r = [i], t.push(r), n.pos++;
+		}
+		l || ie(t), r.push(t), n.pos = e + 1;
+	} while (n.pos <= t);
+	return r;
+}
+function ie(e) {
+	e.sort(ae);
+}
+function ae(e, t) {
+	return e[0] - t[0];
+}
+const k = /^[a-zA-Z][a-zA-Z\d+\-.]*:/, oe = /^data:application\/json[^,]+base64,/, se = /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/, A = typeof WeakRef < `u`, j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), ce = (e) => A && e instanceof WeakRef, N = (e, t, n, r) => {
+	if (n < 0 || n >= e.length) return null;
+	let i = e[n];
+	if (!i || i.length === 0) return null;
+	let a = null;
+	for (let e of i) if (e[0] <= r) a = e;
+	else break;
+	if (!a || a.length < 4) return null;
+	let [, o, s, c] = a;
+	if (o === void 0 || s === void 0 || c === void 0) return null;
+	let l = t[o];
+	return l ? {
+		columnNumber: c,
+		fileName: l,
+		lineNumber: s + 1
+	} : null;
+}, P = (e, t, n) => {
+	if (e.sections) {
+		let r = null;
+		for (let i of e.sections) if (t > i.offset.line || t === i.offset.line && n >= i.offset.column) r = i;
+		else break;
+		if (!r) return null;
+		let i = t - r.offset.line, a = t === r.offset.line ? n - r.offset.column : n;
+		return N(r.map.mappings, r.map.sources, i, a);
+	}
+	return N(e.mappings, e.sources, t - 1, n);
+}, le = (e, t) => {
+	let n = t.split(`
+`), r;
+	for (let e = n.length - 1; e >= 0 && !r; e--) {
+		let t = n[e].match(se);
+		t && (r = t[1] || t[2]);
+	}
+	if (!r) return null;
+	let i = k.test(r);
+	if (!(oe.test(r) || i || r.startsWith(`/`))) {
+		let t = e.split(`/`);
+		t[t.length - 1] = r, r = t.join(`/`);
+	}
+	return r;
+}, F = (e) => ({
+	file: e.file,
+	mappings: O(e.mappings),
+	names: e.names,
+	sourceRoot: e.sourceRoot,
+	sources: e.sources,
+	sourcesContent: e.sourcesContent,
+	version: 3
+}), ue = (e) => {
+	let t = e.sections.map(({ map: e, offset: t }) => ({
+		map: {
+			...e,
+			mappings: O(e.mappings)
+		},
+		offset: t
+	})), n = /* @__PURE__ */ new Set();
+	for (let e of t) for (let t of e.map.sources) n.add(t);
+	return {
+		file: e.file,
+		mappings: [],
+		names: [],
+		sections: t,
+		sourceRoot: void 0,
+		sources: Array.from(n),
+		sourcesContent: void 0,
+		version: 3
+	};
+}, I = (e) => {
+	if (!e) return !1;
+	let t = e.trim();
+	if (!t) return !1;
+	let n = t.match(k);
+	if (!n) return !0;
+	let r = n[0].toLowerCase();
+	return r === `http:` || r === `https:`;
+}, L = async (e, t = fetch) => {
+	if (!I(e)) return null;
+	let n;
+	try {
+		let r = await t(e);
+		if (!r.ok) return null;
+		n = await r.text();
+	} catch {
+		return null;
+	}
+	if (!n) return null;
+	let r = le(e, n);
+	if (!r || !I(r)) return null;
+	try {
+		let e = await t(r);
+		if (!e.ok) return null;
+		let n = await e.json();
+		return `sections` in n ? ue(n) : F(n);
+	} catch {
+		return null;
+	}
+}, R = async (e, t = !0, n) => {
+	if (t && j.has(e)) {
+		let t = j.get(e);
+		if (t == null) return null;
+		if (ce(t)) {
+			let n = t.deref();
+			if (n) return n;
+			j.delete(e);
+		} else return t;
+	}
+	if (t && M.has(e)) return M.get(e);
+	let r = L(e, n);
+	t && M.set(e, r);
+	let i = await r;
+	return t && M.delete(e), t && (i === null ? j.set(e, null) : j.set(e, A ? new WeakRef(i) : i)), i;
+}, z = async (e, t = !0, n) => await Promise.all(e.map(async (e) => {
+	if (!e.fileName) return e;
+	let r = await R(e.fileName, t, n);
+	if (!r || typeof e.lineNumber != `number` || typeof e.columnNumber != `number`) return e;
+	let i = P(r, e.lineNumber, e.columnNumber);
+	return i ? {
+		...e,
+		source: i.fileName && e.source ? e.source.replace(e.fileName, i.fileName) : e.source,
+		fileName: i.fileName,
+		lineNumber: i.lineNumber,
+		columnNumber: i.columnNumber,
+		isSymbolicated: !0
+	} : e;
+})), B = (e) => e._debugStack instanceof Error && typeof e._debugStack?.stack == `string`, V = () => {
+	let n = h$2();
+	for (let t of [...Array.from(d$2), ...Array.from(n.renderers.values())]) {
+		let e = t.currentDispatcherRef;
+		if (e && typeof e == `object`) return `H` in e ? e.H : e.current;
+	}
+	return null;
+}, H = (t) => {
+	for (let n of d$2) {
+		let e = n.currentDispatcherRef;
+		e && typeof e == `object` && (`H` in e ? e.H = t : e.current = t);
+	}
+}, U = (e) => `\n    in ${e}`, W = (e, t) => {
+	let n = U(e);
+	return t && (n += ` (at ${t})`), n;
+};
+let G = !1;
+const K = (e, t) => {
+	if (!e || G) return ``;
+	let r = Error.prepareStackTrace;
+	Error.prepareStackTrace = void 0, G = !0;
+	let i = V();
+	H(null);
+	let a = console.error, o = console.warn;
+	console.error = () => {}, console.warn = () => {};
+	try {
+		let r = { DetermineComponentFrameRoot() {
+			let n;
+			try {
+				if (t) {
+					let t = function() {
+						throw Error();
+					};
+					if (Object.defineProperty(t.prototype, `props`, { set: function() {
+						throw Error();
+					} }), typeof Reflect == `object` && Reflect.construct) {
+						try {
+							Reflect.construct(t, []);
+						} catch (e) {
+							n = e;
+						}
+						Reflect.construct(e, [], t);
+					} else {
+						try {
+							t.call();
+						} catch (e) {
+							n = e;
+						}
+						e.call(t.prototype);
+					}
+				} else {
+					try {
+						throw Error();
+					} catch (e) {
+						n = e;
+					}
+					let t = e();
+					t && typeof t.catch == `function` && t.catch(() => {});
+				}
+			} catch (e) {
+				if (e instanceof Error && n instanceof Error && typeof e.stack == `string`) return [e.stack, n.stack];
+			}
+			return [null, null];
+		} };
+		r.DetermineComponentFrameRoot.displayName = `DetermineComponentFrameRoot`, Object.getOwnPropertyDescriptor(r.DetermineComponentFrameRoot, `name`)?.configurable && Object.defineProperty(r.DetermineComponentFrameRoot, `name`, { value: `DetermineComponentFrameRoot` });
+		let [i, a] = r.DetermineComponentFrameRoot();
+		if (i && a) {
+			let t = i.split(`
+`), r = a.split(`
+`), o = 0, s = 0;
+			for (; o < t.length && !t[o].includes(`DetermineComponentFrameRoot`);) o++;
+			for (; s < r.length && !r[s].includes(`DetermineComponentFrameRoot`);) s++;
+			if (o === t.length || s === r.length) for (o = t.length - 1, s = r.length - 1; o >= 1 && s >= 0 && t[o] !== r[s];) s--;
+			for (; o >= 1 && s >= 0; o--, s--) if (t[o] !== r[s]) {
+				if (o !== 1 || s !== 1) do
+					if (o--, s--, s < 0 || t[o] !== r[s]) {
+						let r = `\n${t[o].replace(` at new `, ` at `)}`, i = we(e);
+						return i && r.includes(`<anonymous>`) && (r = r.replace(`<anonymous>`, i)), r;
+					}
+				while (o >= 1 && s >= 0);
+				break;
+			}
+		}
+	} finally {
+		G = !1, Error.prepareStackTrace = r, H(i), console.error = a, console.warn = o;
+	}
+	let s = e ? we(e) : ``;
+	return s ? U(s) : ``;
+}, q = (e, t) => {
+	let n = e.tag, r = ``;
+	switch (n) {
+		case 28:
+			r = U(`Activity`);
+			break;
+		case 1:
+			r = K(e.type, !0);
+			break;
+		case 11:
+			r = K(e.type.render, !1);
+			break;
+		case 0:
+		case 15:
+			r = K(e.type, !1);
+			break;
+		case 5:
+		case 26:
+		case 27:
+			r = U(e.type);
+			break;
+		case 16:
+			r = U(`Lazy`);
+			break;
+		case 13:
+			r = e.child !== t && t !== null ? U(`Suspense Fallback`) : U(`Suspense`);
+			break;
+		case 19:
+			r = U(`SuspenseList`);
+			break;
+		case 30:
+			r = U(`ViewTransition`);
+			break;
+		default: return ``;
+	}
+	return r;
+}, J = (e) => {
+	try {
+		let t = ``, n = e, r = null;
+		do {
+			t += q(n, r);
+			let e = n._debugInfo;
+			if (e && Array.isArray(e)) for (let n = e.length - 1; n >= 0; n--) {
+				let r = e[n];
+				typeof r.name == `string` && (t += W(r.name, r.env));
+			}
+			r = n, n = n.return;
+		} while (n);
+		return t;
+	} catch (e) {
+		return e instanceof Error ? `\nError generating stack: ${e.message}\n${e.stack}` : ``;
+	}
+}, Y = (e) => {
+	let t = Error.prepareStackTrace;
+	Error.prepareStackTrace = void 0;
+	let n = e;
+	if (!n) return ``;
+	Error.prepareStackTrace = t, n.startsWith(`Error: react-stack-top-frame
+`) && (n = n.slice(29));
+	let r = n.indexOf(`
+`);
+	if (r !== -1 && (n = n.slice(r + 1)), r = Math.max(n.indexOf(`react_stack_bottom_frame`), n.indexOf(`react-stack-bottom-frame`)), r !== -1 && (r = n.lastIndexOf(`
+`, r)), r !== -1) n = n.slice(0, r);
+	else return ``;
+	return n;
+}, de = (e) => !!(e.fileName?.startsWith(`rsc://`) && e.functionName), fe = (e, t) => e.fileName === t.fileName && e.lineNumber === t.lineNumber && e.columnNumber === t.columnNumber, pe = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) for (let e of n.stackFrames) {
+		if (!de(e)) continue;
+		let n = e.functionName, r = t.get(n) ?? [];
+		r.some((t) => fe(t, e)) || (r.push(e), t.set(n, r));
+	}
+	return t;
+}, me = (e, t, n) => {
+	if (!e.functionName) return {
+		...e,
+		isServer: !0
+	};
+	let r = t.get(e.functionName);
+	if (!r || r.length === 0) return {
+		...e,
+		isServer: !0
+	};
+	let i = n.get(e.functionName) ?? 0, a = r[i % r.length];
+	return n.set(e.functionName, i + 1), {
+		...e,
+		isServer: !0,
+		fileName: a.fileName,
+		lineNumber: a.lineNumber,
+		columnNumber: a.columnNumber,
+		source: e.source?.replace(`(at Server)`, `(${a.fileName}:${a.lineNumber}:${a.columnNumber})`)
+	};
+}, he = (e) => {
+	let t = [];
+	return j$1(e, (e) => {
+		if (!B(e)) return;
+		let r = typeof e.type == `string` ? e.type : we(e.type) || `<anonymous>`;
+		t.push({
+			componentName: r,
+			stackFrames: m(Y(e._debugStack?.stack))
+		});
+	}, !0), t;
+}, X = async (e, t = !0, n) => {
+	let r = he(e), i = m(J(e)), a = pe(r), o = /* @__PURE__ */ new Map();
+	return z(i.map((e) => e.source?.includes(`(at Server)`) ?? !1 ? me(e, a, o) : e).filter((e, t, n) => {
+		if (t === 0) return !0;
+		let r = n[t - 1];
+		return e.functionName !== r.functionName;
+	}), t, n);
+}, Z = (e) => {
+	let t = e._debugSource;
+	return t ? typeof t == `object` && !!t && `fileName` in t && typeof t.fileName == `string` && `lineNumber` in t && typeof t.lineNumber == `number` : !1;
+}, ge = async (e, t = !0, n) => {
+	if (Z(e)) return e._debugSource || null;
+	let r = await X(e, t, n);
+	for (let e of r) if (e.fileName) return {
+		fileName: e.fileName,
+		lineNumber: e.lineNumber,
+		columnNumber: e.columnNumber,
+		functionName: e.functionName
+	};
+	return null;
+}, Q = (e) => e.split(`/`).filter(Boolean).length, _e = (e) => e.split(`/`).filter(Boolean)[0] ?? null, ve = (e) => {
+	let t = e.indexOf(`/`, 1);
+	if (t === -1 || Q(e.slice(0, t)) !== 1) return e;
+	let n = e.slice(t);
+	if (!s.test(n) || Q(n) < 2) return e;
+	let r = _e(n);
+	return !r || r.startsWith(`@`) || r.length > 4 ? e : n;
+}, $ = (e) => {
+	if (!e || o.some((t) => t === e)) return ``;
+	let t = e, n = t.startsWith(`http://`) || t.startsWith(`https://`);
+	if (n) try {
+		t = new URL(t).pathname;
+	} catch {}
+	if (n && (t = ve(t)), t.startsWith(`about://React/`)) {
+		let e = t.slice(14), n = e.indexOf(`/`), r = e.indexOf(`:`);
+		t = n !== -1 && (r === -1 || n < r) ? e.slice(n + 1) : e;
+	}
+	let r = !0;
+	for (; r;) {
+		r = !1;
+		for (let e of a) if (t.startsWith(e)) {
+			t = t.slice(e.length), e === `file:///` && (t = `/${t.replace(/^\/+/, ``)}`), r = !0;
+			break;
+		}
+	}
+	if (i.test(t)) {
+		let e = t.match(i);
+		e && (t = t.slice(e[0].length));
+	}
+	if (t.startsWith(`//`)) {
+		let e = t.indexOf(`/`, 2);
+		t = e === -1 ? `` : t.slice(e);
+	}
+	let s = t.indexOf(`?`);
+	if (s !== -1) {
+		let e = t.slice(s);
+		l.test(e) && (t = t.slice(0, s));
+	}
+	return t;
+}, ye = (e) => {
+	let t = $(e);
+	return !(!t || !s.test(t) || c.test(t));
+}, be = (e, t) => {
+	let n = e.split(`
+`), r = t - 1;
+	if (r < 0 || r >= n.length) return null;
+	let i = Math.max(0, r - 5), a = Math.min(n.length, r + 5), o = n.slice(i, a).join(`
+`), s = /(?:^|export\s+)(?:const|let|var)\s+(\w+)\s*=/m, c = /(?:^|export\s+)function\s+(\w+)/m, l = /(?:^|export\s+)class\s+(\w+)/m, u = o.match(s);
+	if (u?.[1]) return u[1];
+	let d = o.match(c);
+	if (d?.[1]) return d[1];
+	let f = o.match(l);
+	return f?.[1] ? f[1] : null;
+}, xe = async (e, t = !0, r) => {
+	let i = (await X(e, t, r)).filter((e) => e.fileName)[0];
+	if (!i?.fileName) return we(e.type);
+	let a = await R(i.fileName, t, r);
+	if (!a) return we(e.type);
+	let o = null;
+	if (typeof i.lineNumber == `number` && typeof i.columnNumber == `number` && (o = P(a, i.lineNumber, i.columnNumber)), !o?.fileName || !o.lineNumber || !a.sourcesContent) return we(e.type);
+	let s = a.sources.indexOf(o.fileName);
+	if (s === -1 || !a.sourcesContent[s]) return we(e.type);
+	let c = a.sourcesContent[s];
+	return be(c, o.lineNumber) || we(e.type);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.37_react@19.2.3/node_modules/bippy/dist/install-hook-only.js
+/**
+* @license bippy
+*
+* Copyright (c) Aiden Bai
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+_$2();
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.37_react@19.2.3/node_modules/bippy/dist/index.js
+/**
+* @license bippy
+*
+* Copyright (c) Aiden Bai
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+//#endregion
+//#region src/utils/truncate-string.ts
+const truncateString = (text, maxLength) => text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+
+//#endregion
+//#region src/utils/get-next-base-path.ts
+let cachedNextBasePath;
+const getNextBasePath = () => {
+	if (cachedNextBasePath !== void 0) return cachedNextBasePath;
+	const source = document.querySelector("script[src*=\"/_next/\"]")?.src;
+	const pathname = source ? new URL(source).pathname : "";
+	const assetPathIndex = pathname.indexOf("/_next/");
+	cachedNextBasePath = assetPathIndex > 0 ? pathname.slice(0, assetPathIndex) : "";
+	return cachedNextBasePath;
+};
+
+//#endregion
+//#region src/core/context.ts
+const NON_COMPONENT_PREFIXES = new Set([
+	"_",
+	"$",
+	"motion.",
+	"styled.",
+	"chakra.",
+	"ark.",
+	"Primitive.",
+	"Slot."
+]);
+const NEXT_INTERNAL_COMPONENT_NAMES = new Set([
+	"InnerLayoutRouter",
+	"RedirectErrorBoundary",
+	"RedirectBoundary",
+	"HTTPAccessFallbackErrorBoundary",
+	"HTTPAccessFallbackBoundary",
+	"LoadingBoundary",
+	"ErrorBoundary",
+	"InnerScrollAndFocusHandler",
+	"ScrollAndFocusHandler",
+	"RenderFromTemplateContext",
+	"OuterLayoutRouter",
+	"body",
+	"html",
+	"DevRootHTTPAccessFallbackBoundary",
+	"AppDevOverlayErrorBoundary",
+	"AppDevOverlay",
+	"HotReload",
+	"Router",
+	"ErrorBoundaryHandler",
+	"AppRouter",
+	"ServerRoot",
+	"SegmentStateProvider",
+	"RootErrorBoundary",
+	"LoadableComponent",
+	"MotionDOMComponent"
+]);
+const REACT_INTERNAL_COMPONENT_NAMES = new Set([
+	"Suspense",
+	"Fragment",
+	"StrictMode",
+	"Profiler",
+	"SuspenseList"
+]);
+let cachedIsNextProject;
+const checkIsNextProject = (revalidate) => {
+	if (revalidate) cachedIsNextProject = void 0;
+	cachedIsNextProject ??= typeof document !== "undefined" && Boolean(document.getElementById("__NEXT_DATA__") || document.querySelector("nextjs-portal"));
+	return cachedIsNextProject;
+};
+const isInternalComponentName = (name) => {
+	if (NEXT_INTERNAL_COMPONENT_NAMES.has(name)) return true;
+	if (REACT_INTERNAL_COMPONENT_NAMES.has(name)) return true;
+	for (const prefix of NON_COMPONENT_PREFIXES) if (name.startsWith(prefix)) return true;
+	return false;
+};
+const isUsefulComponentName = (name) => {
+	if (!name) return false;
+	if (isInternalComponentName(name)) return false;
+	if (name === "SlotClone" || name === "Slot") return false;
+	return true;
+};
+const isSourceComponentName = (name) => {
+	if (name.length <= 1) return false;
+	if (isInternalComponentName(name)) return false;
+	if (name[0] !== name[0].toUpperCase()) return false;
+	if (name.endsWith("Provider") || name.endsWith("Context")) return false;
+	return true;
+};
+const SERVER_COMPONENT_URL_PREFIXES = ["about://React/", "rsc://React/"];
+const isServerComponentUrl = (url) => SERVER_COMPONENT_URL_PREFIXES.some((prefix) => url.startsWith(prefix));
+const devirtualizeServerUrl = (url) => {
+	for (const prefix of SERVER_COMPONENT_URL_PREFIXES) {
+		if (!url.startsWith(prefix)) continue;
+		const environmentEndIndex = url.indexOf("/", prefix.length);
+		const querySuffixIndex = url.lastIndexOf("?");
+		if (environmentEndIndex > -1 && querySuffixIndex > -1) return decodeURI(url.slice(environmentEndIndex + 1, querySuffixIndex));
+	}
+	return url;
+};
+const symbolicateServerFrames = async (frames) => {
+	const serverFrameIndices = [];
+	const requestFrames = [];
+	for (let frameIndex = 0; frameIndex < frames.length; frameIndex++) {
+		const frame = frames[frameIndex];
+		if (!frame.isServer || !frame.fileName) continue;
+		serverFrameIndices.push(frameIndex);
+		requestFrames.push({
+			file: devirtualizeServerUrl(frame.fileName),
+			methodName: frame.functionName ?? "<unknown>",
+			line1: frame.lineNumber ?? null,
+			column1: frame.columnNumber ?? null,
+			arguments: []
+		});
+	}
+	if (requestFrames.length === 0) return frames;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), SYMBOLICATION_TIMEOUT_MS);
+	try {
+		const response = await fetch(`${getNextBasePath()}/__nextjs_original-stack-frames`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				frames: requestFrames,
+				isServer: true,
+				isEdgeServer: false,
+				isAppDirectory: true
+			}),
+			signal: controller.signal
+		});
+		if (!response.ok) return frames;
+		const results = await response.json();
+		const resolvedFrames = [...frames];
+		for (let resultIndex = 0; resultIndex < serverFrameIndices.length; resultIndex++) {
+			const result = results[resultIndex];
+			if (result?.status !== "fulfilled") continue;
+			const resolved = result.value?.originalStackFrame;
+			if (!resolved?.file || resolved.ignored) continue;
+			const originalFrameIndex = serverFrameIndices[resultIndex];
+			resolvedFrames[originalFrameIndex] = {
+				...frames[originalFrameIndex],
+				fileName: resolved.file,
+				lineNumber: resolved.line1 ?? void 0,
+				columnNumber: resolved.column1 ?? void 0,
+				isSymbolicated: true
+			};
+		}
+		return resolvedFrames;
+	} catch {
+		return frames;
+	} finally {
+		clearTimeout(timeout);
+	}
+};
+const extractServerFramesFromDebugStack = (rootFiber) => {
+	const serverFramesByName = /* @__PURE__ */ new Map();
+	j$1(rootFiber, (currentFiber) => {
+		if (!B(currentFiber)) return false;
+		const ownerStack = Y(currentFiber._debugStack.stack);
+		if (!ownerStack) return false;
+		for (const frame of m(ownerStack)) {
+			if (!frame.functionName || !frame.fileName) continue;
+			if (!isServerComponentUrl(frame.fileName)) continue;
+			if (serverFramesByName.has(frame.functionName)) continue;
+			serverFramesByName.set(frame.functionName, {
+				...frame,
+				isServer: true
+			});
+		}
+		return false;
+	}, true);
+	return serverFramesByName;
+};
+const enrichServerFrameLocations = (rootFiber, frames) => {
+	if (!frames.some((frame) => frame.isServer && !frame.fileName && frame.functionName)) return frames;
+	const serverFramesByName = extractServerFramesFromDebugStack(rootFiber);
+	if (serverFramesByName.size === 0) return frames;
+	return frames.map((frame) => {
+		if (!frame.isServer || frame.fileName || !frame.functionName) return frame;
+		const resolved = serverFramesByName.get(frame.functionName);
+		if (!resolved) return frame;
+		return {
+			...frame,
+			fileName: resolved.fileName,
+			lineNumber: resolved.lineNumber,
+			columnNumber: resolved.columnNumber
+		};
+	});
+};
+const findNearestFiberElement = (element) => {
+	if (!Te()) return element;
+	let current = element;
+	while (current) {
+		if (Z$1(current)) return current;
+		current = current.parentElement;
+	}
+	return element;
+};
+const stackCache = /* @__PURE__ */ new WeakMap();
+const fetchStackForElement = async (element) => {
+	try {
+		const fiber = Z$1(element);
+		if (!fiber) return null;
+		const frames = await X(fiber);
+		if (checkIsNextProject()) return await symbolicateServerFrames(enrichServerFrameLocations(fiber, frames));
+		return frames;
+	} catch {
+		return null;
+	}
+};
+const getStack = (element) => {
+	if (!Te()) return Promise.resolve([]);
+	const resolvedElement = findNearestFiberElement(element);
+	const cached = stackCache.get(resolvedElement);
+	if (cached) return cached;
+	const promise = fetchStackForElement(resolvedElement);
+	stackCache.set(resolvedElement, promise);
+	return promise;
+};
+const getNearestComponentName = async (element) => {
+	if (!Te()) return null;
+	const stack = await getStack(element);
+	if (!stack) return null;
+	for (const frame of stack) if (frame.functionName && isSourceComponentName(frame.functionName)) return frame.functionName;
+	return null;
+};
+const resolveSource = async (element) => {
+	const stack = await getStack(findNearestFiberElement(element));
+	if (!stack || stack.length === 0) return null;
+	const sourceFrames = stack.filter((frame) => frame.fileName && ye(frame.fileName));
+	const resolvedFrame = sourceFrames.find((frame) => frame.functionName && isSourceComponentName(frame.functionName)) ?? sourceFrames[0];
+	if (!resolvedFrame?.fileName) return null;
+	return {
+		filePath: $(resolvedFrame.fileName),
+		lineNumber: resolvedFrame.lineNumber ?? null,
+		columnNumber: resolvedFrame.columnNumber ?? null,
+		componentName: resolvedFrame.functionName && isSourceComponentName(resolvedFrame.functionName) ? resolvedFrame.functionName : null
+	};
+};
+const getComponentDisplayName = (element) => {
+	if (!Te()) return null;
+	const fiber = Z$1(findNearestFiberElement(element));
+	if (!fiber) return null;
+	let currentFiber = fiber.return;
+	while (currentFiber) {
+		if (ve$1(currentFiber)) {
+			const name = we(currentFiber.type);
+			if (name && isUsefulComponentName(name)) return name;
+		}
+		currentFiber = currentFiber.return;
+	}
+	return null;
+};
+const hasFormattableFrames = (stack) => {
+	if (!stack) return false;
+	return stack.some((frame) => {
+		if (frame.fileName && ye(frame.fileName)) return true;
+		if (frame.isServer && (!frame.functionName || isSourceComponentName(frame.functionName))) return true;
+		return false;
+	});
+};
+const getComponentNamesFromFiber = (element, maxCount) => {
+	if (!Te()) return [];
+	const fiber = Z$1(element);
+	if (!fiber) return [];
+	const componentNames = [];
+	j$1(fiber, (currentFiber) => {
+		if (componentNames.length >= maxCount) return true;
+		if (ve$1(currentFiber)) {
+			const name = we(currentFiber.type);
+			if (name && isUsefulComponentName(name)) componentNames.push(name);
+		}
+		return false;
+	}, true);
+	return componentNames;
+};
+const formatStackContext = (stack, options = {}) => {
+	const { maxLines = 3 } = options;
+	const isNextProject = checkIsNextProject();
+	const formattedLines = [];
+	for (const frame of stack) {
+		if (formattedLines.length >= maxLines) break;
+		const hasResolvedSource = frame.fileName && ye(frame.fileName);
+		if (frame.isServer && !hasResolvedSource && (!frame.functionName || isSourceComponentName(frame.functionName))) {
+			formattedLines.push(`\n  in ${frame.functionName || "<anonymous>"} (at Server)`);
+			continue;
+		}
+		if (hasResolvedSource) {
+			let line = "\n  in ";
+			const hasComponentName = frame.functionName && isSourceComponentName(frame.functionName);
+			if (hasComponentName) line += `${frame.functionName} (at `;
+			line += $(frame.fileName);
+			if (isNextProject && frame.lineNumber) {
+				line += `:${frame.lineNumber}`;
+				if (frame.columnNumber) line += `:${frame.columnNumber}`;
+			}
+			if (hasComponentName) line += `)`;
+			formattedLines.push(line);
+		}
+	}
+	return formattedLines.join("");
+};
+const getStackContext = async (element, options = {}) => {
+	const maxLines = options.maxLines ?? 3;
+	const stack = await getStack(element);
+	if (stack && hasFormattableFrames(stack)) return formatStackContext(stack, options);
+	const componentNames = getComponentNamesFromFiber(element, maxLines);
+	if (componentNames.length > 0) return componentNames.map((name) => `\n  in ${name}`).join("");
+	return "";
+};
+const getElementContext = async (element, options = {}) => {
+	const resolvedElement = findNearestFiberElement(element);
+	const html = getHTMLPreview(resolvedElement);
+	const stackContext = await getStackContext(resolvedElement, options);
+	if (stackContext) return `${html}${stackContext}`;
+	return getFallbackContext(resolvedElement);
+};
+const getFallbackContext = (element) => {
+	const tagName = getTagName(element);
+	if (!(element instanceof HTMLElement)) return `<${tagName}${formatPriorityAttrs(element, {
+		truncate: false,
+		maxAttrs: PREVIEW_PRIORITY_ATTRS.length
+	})} />`;
+	const text = element.innerText?.trim() ?? element.textContent?.trim() ?? "";
+	let attrsText = "";
+	for (const { name, value } of element.attributes) attrsText += ` ${name}="${value}"`;
+	const truncatedText = truncateString(text, 100);
+	if (truncatedText.length > 0) return `<${tagName}${attrsText}>\n  ${truncatedText}\n</${tagName}>`;
+	return `<${tagName}${attrsText} />`;
+};
+const truncateAttrValue = (value) => truncateString(value, 15);
+const formatPriorityAttrs = (element, options = {}) => {
+	const { truncate = true, maxAttrs = 3 } = options;
+	const priorityAttrs = [];
+	for (const name of PREVIEW_PRIORITY_ATTRS) {
+		if (priorityAttrs.length >= maxAttrs) break;
+		const value = element.getAttribute(name);
+		if (value) {
+			const formattedValue = truncate ? truncateAttrValue(value) : value;
+			priorityAttrs.push(`${name}="${formattedValue}"`);
+		}
+	}
+	return priorityAttrs.length > 0 ? ` ${priorityAttrs.join(" ")}` : "";
+};
+const getHTMLPreview = (element) => {
+	const tagName = getTagName(element);
+	const text = element instanceof HTMLElement ? element.innerText?.trim() ?? element.textContent?.trim() ?? "" : element.textContent?.trim() ?? "";
+	let attrsText = "";
+	for (const { name, value } of element.attributes) attrsText += ` ${name}="${truncateAttrValue(value)}"`;
+	const topElements = [];
+	const bottomElements = [];
+	let foundFirstText = false;
+	const childNodes = Array.from(element.childNodes);
+	for (const node of childNodes) {
+		if (node.nodeType === Node.COMMENT_NODE) continue;
+		if (node.nodeType === Node.TEXT_NODE) {
+			if (node.textContent && node.textContent.trim().length > 0) foundFirstText = true;
+		} else if (node instanceof Element) if (!foundFirstText) topElements.push(node);
+		else bottomElements.push(node);
+	}
+	const formatElements = (elements) => {
+		if (elements.length === 0) return "";
+		if (elements.length <= 2) return elements.map((childElement) => `<${getTagName(childElement)} ...>`).join("\n  ");
+		return `(${elements.length} elements)`;
+	};
+	let content = "";
+	const topElementsStr = formatElements(topElements);
+	if (topElementsStr) content += `\n  ${topElementsStr}`;
+	if (text.length > 0) content += `\n  ${truncateString(text, 100)}`;
+	const bottomElementsStr = formatElements(bottomElements);
+	if (bottomElementsStr) content += `\n  ${bottomElementsStr}`;
+	if (content.length > 0) return `<${tagName}${attrsText}>${content}\n</${tagName}>`;
+	return `<${tagName}${attrsText} />`;
+};
+
+//#endregion
+//#region src/utils/is-element-visible.ts
+const isElementVisible = (element, computedStyle = window.getComputedStyle(element)) => {
+	return computedStyle.display !== "none" && computedStyle.visibility !== "hidden" && computedStyle.opacity !== "0";
+};
+
+//#endregion
+//#region src/utils/is-root-element.ts
+const isRootElement = (element) => {
+	const tagName = getTagName(element);
+	return tagName === "html" || tagName === "body";
+};
+
+//#endregion
+//#region src/utils/is-valid-grabbable-element.ts
+const isReactGrabElement = (element) => {
+	if (element.hasAttribute("data-react-grab")) return true;
+	const rootNode = element.getRootNode();
+	return rootNode instanceof ShadowRoot && rootNode.host.hasAttribute("data-react-grab");
+};
+const isUserIgnoredElement = (element) => element.hasAttribute("data-react-grab-ignore") || element.closest(`[${"data-react-grab-ignore"}]`) !== null;
+const isDevToolsOverlay = (computedStyle) => {
+	const zIndex = parseInt(computedStyle.zIndex, 10);
+	return computedStyle.pointerEvents === "none" && computedStyle.position === "fixed" && !isNaN(zIndex) && zIndex >= 2147483600;
+};
+const isFullViewportOverlay = (element, computedStyle) => {
+	const position = computedStyle.position;
+	if (position !== "fixed" && position !== "absolute") return false;
+	const rect = element.getBoundingClientRect();
+	if (!(rect.width / window.innerWidth >= .9 && rect.height / window.innerHeight >= .9)) return false;
+	const backgroundColor = computedStyle.backgroundColor;
+	if (backgroundColor === "transparent" || backgroundColor === "rgba(0, 0, 0, 0)" || parseFloat(computedStyle.opacity) < .1) return true;
+	const zIndex = parseInt(computedStyle.zIndex, 10);
+	return !isNaN(zIndex) && zIndex > 1e3;
+};
+let visibilityCache = /* @__PURE__ */ new WeakMap();
+const clearVisibilityCache = () => {
+	visibilityCache = /* @__PURE__ */ new WeakMap();
+};
+const isValidGrabbableElement = (element) => {
+	if (isRootElement(element)) return false;
+	if (isReactGrabElement(element)) return false;
+	if (isUserIgnoredElement(element)) return false;
+	const now = performance.now();
+	const cached = visibilityCache.get(element);
+	if (cached && now - cached.timestamp < 50) return cached.isVisible;
+	const computedStyle = window.getComputedStyle(element);
+	if (!isElementVisible(element, computedStyle)) {
+		visibilityCache.set(element, {
+			isVisible: false,
+			timestamp: now
+		});
+		return false;
+	}
+	if (element.clientWidth / window.innerWidth >= .9 && element.clientHeight / window.innerHeight >= .9) {
+		if (isDevToolsOverlay(computedStyle)) return false;
+		if (isFullViewportOverlay(element, computedStyle)) return false;
+	}
+	visibilityCache.set(element, {
+		isVisible: true,
+		timestamp: now
+	});
+	return true;
+};
+
+//#endregion
+//#region src/utils/create-style-element.ts
+const createStyleElement = (attribute, content) => {
+	const element = document.createElement("style");
+	element.setAttribute(attribute, "");
+	const nonce = detectCspNonce();
+	if (nonce) element.nonce = nonce;
+	hideFromThirdParties(element);
+	element.textContent = content;
+	document.head.appendChild(element);
+	return element;
+};
+
+//#endregion
+//#region src/utils/freeze-pseudo-states.ts
+const POINTER_EVENTS_STYLES = "html { pointer-events: none !important; }";
+const MOUSE_EVENTS_TO_BLOCK = [
+	"mouseenter",
+	"mouseleave",
+	"mouseover",
+	"mouseout",
+	"pointerenter",
+	"pointerleave",
+	"pointerover",
+	"pointerout"
+];
+const FOCUS_EVENTS_TO_BLOCK = [
+	"focus",
+	"blur",
+	"focusin",
+	"focusout"
+];
+const HOVER_STYLE_PROPERTIES = [
+	"background-color",
+	"color",
+	"border-color",
+	"box-shadow",
+	"transform",
+	"opacity",
+	"outline",
+	"filter",
+	"scale",
+	"visibility"
+];
+const FOCUS_STYLE_PROPERTIES = [
+	"background-color",
+	"color",
+	"border-color",
+	"box-shadow",
+	"outline",
+	"outline-offset",
+	"outline-width",
+	"outline-color",
+	"outline-style",
+	"filter",
+	"opacity",
+	"ring-color",
+	"ring-width"
+];
+const frozenHoverElements = /* @__PURE__ */ new Map();
+const frozenFocusElements = /* @__PURE__ */ new Map();
+let pointerEventsStyle = null;
+const stopEvent = (event) => {
+	event.stopImmediatePropagation();
+};
+const preventFocusChange = (event) => {
+	event.preventDefault();
+	event.stopImmediatePropagation();
+};
+const collectOriginalPropertyValues = (element, properties) => {
+	const originalPropertyValues = /* @__PURE__ */ new Map();
+	for (const prop of properties) {
+		const inlineValue = element.style.getPropertyValue(prop);
+		if (inlineValue) originalPropertyValues.set(prop, inlineValue);
+	}
+	return originalPropertyValues;
+};
+const collectPseudoStates = (selector, properties, alreadyFrozen) => {
+	const elementsToFreeze = [];
+	for (const element of document.querySelectorAll(selector)) {
+		if (!(element instanceof HTMLElement)) continue;
+		if (alreadyFrozen?.has(element)) continue;
+		const computed = getComputedStyle(element);
+		let frozenStyles = element.style.cssText;
+		const originalPropertyValues = collectOriginalPropertyValues(element, properties);
+		for (const prop of properties) {
+			const computedValue = computed.getPropertyValue(prop);
+			if (computedValue) frozenStyles += `${prop}: ${computedValue} !important; `;
+		}
+		elementsToFreeze.push({
+			element,
+			frozenStyles,
+			originalPropertyValues
+		});
+	}
+	return elementsToFreeze;
+};
+const applyFrozenStates = (states, storageMap) => {
+	for (const { element, frozenStyles, originalPropertyValues } of states) {
+		storageMap.set(element, originalPropertyValues);
+		element.style.cssText = frozenStyles;
+	}
+};
+const restoreFrozenStates = (storageMap, styleProperties) => {
+	for (const [element, originalPropertyValues] of storageMap) for (const prop of styleProperties) {
+		const originalValue = originalPropertyValues.get(prop);
+		if (originalValue) element.style.setProperty(prop, originalValue);
+		else element.style.removeProperty(prop);
+	}
+	storageMap.clear();
+};
+const suspendPointerEventsFreeze = () => {
+	if (pointerEventsStyle) pointerEventsStyle.disabled = true;
+};
+const resumePointerEventsFreeze = () => {
+	if (pointerEventsStyle) pointerEventsStyle.disabled = false;
+};
+const freezePseudoStates = () => {
+	if (pointerEventsStyle) return;
+	for (const eventType of MOUSE_EVENTS_TO_BLOCK) document.addEventListener(eventType, stopEvent, true);
+	for (const eventType of FOCUS_EVENTS_TO_BLOCK) document.addEventListener(eventType, preventFocusChange, true);
+	const hoverStates = collectPseudoStates(":hover", HOVER_STYLE_PROPERTIES);
+	const focusStates = collectPseudoStates(":focus, :focus-visible", FOCUS_STYLE_PROPERTIES, frozenFocusElements);
+	applyFrozenStates(hoverStates, frozenHoverElements);
+	applyFrozenStates(focusStates, frozenFocusElements);
+	pointerEventsStyle = createStyleElement("data-react-grab-frozen-pseudo", POINTER_EVENTS_STYLES);
+};
+const unfreezePseudoStates = () => {
+	clearElementPositionCache();
+	for (const eventType of MOUSE_EVENTS_TO_BLOCK) document.removeEventListener(eventType, stopEvent, true);
+	for (const eventType of FOCUS_EVENTS_TO_BLOCK) document.removeEventListener(eventType, preventFocusChange, true);
+	restoreFrozenStates(frozenHoverElements, HOVER_STYLE_PROPERTIES);
+	restoreFrozenStates(frozenFocusElements, FOCUS_STYLE_PROPERTIES);
+	pointerEventsStyle?.remove();
+	pointerEventsStyle = null;
+};
+
+//#endregion
+//#region src/utils/get-element-at-position.ts
+let cache = null;
+let resumeTimerId = null;
+const scheduleResume = () => {
+	if (resumeTimerId !== null) clearTimeout(resumeTimerId);
+	resumeTimerId = setTimeout(() => {
+		resumeTimerId = null;
+		resumePointerEventsFreeze();
+	}, 100);
+};
+const cancelScheduledResume = () => {
+	if (resumeTimerId !== null) {
+		clearTimeout(resumeTimerId);
+		resumeTimerId = null;
+	}
+};
+const isWithinThreshold = (x1, y1, x2, y2) => {
+	const deltaX = Math.abs(x1 - x2);
+	const deltaY = Math.abs(y1 - y2);
+	return deltaX <= 2 && deltaY <= 2;
+};
+const getElementsAtPoint = (clientX, clientY) => {
+	cancelScheduledResume();
+	suspendPointerEventsFreeze();
+	const elements = document.elementsFromPoint(clientX, clientY);
+	scheduleResume();
+	return elements;
+};
+const getElementAtPosition = (clientX, clientY) => {
+	const now = performance.now();
+	if (cache) {
+		const isPositionClose = isWithinThreshold(clientX, clientY, cache.clientX, cache.clientY);
+		const isWithinThrottle = now - cache.timestamp < 16;
+		if (isPositionClose || isWithinThrottle) return cache.element;
+	}
+	cancelScheduledResume();
+	suspendPointerEventsFreeze();
+	let result = null;
+	const topElement = document.elementFromPoint(clientX, clientY);
+	if (topElement && isValidGrabbableElement(topElement)) result = topElement;
+	else {
+		const elementsAtPoint = document.elementsFromPoint(clientX, clientY);
+		for (const candidateElement of elementsAtPoint) if (candidateElement !== topElement && isValidGrabbableElement(candidateElement)) {
+			result = candidateElement;
+			break;
+		}
+	}
+	scheduleResume();
+	cache = {
+		clientX,
+		clientY,
+		element: result,
+		timestamp: now
+	};
+	return result;
+};
+const clearElementPositionCache = () => {
+	cancelScheduledResume();
+	resumePointerEventsFreeze();
+	cache = null;
+};
+
+//#endregion
+//#region src/utils/open-file.ts
+const OPEN_FILE_BASE_URL = "http://localhost:3000";
+const tryDevServerOpen = async (filePath, lineNumber) => {
+	const isNextProject = checkIsNextProject();
+	const params = new URLSearchParams({ file: filePath });
+	const lineKey = isNextProject ? "line1" : "line";
+	const columnKey = isNextProject ? "column1" : "column";
+	if (lineNumber) params.set(lineKey, String(lineNumber));
+	params.set(columnKey, "1");
+	const endpoint = isNextProject ? `${getNextBasePath()}/__nextjs_launch-editor` : "/__open-in-editor";
+	return (await fetch(`${endpoint}?${params}`)).ok;
+};
+const openFile = async (filePath, lineNumber, transformUrl) => {
+	filePath = $(filePath);
+	if (await tryDevServerOpen(filePath, lineNumber).catch(() => false)) return;
+	const lineParam = lineNumber ? `&line=${lineNumber}` : "";
+	const rawUrl = `${OPEN_FILE_BASE_URL}/open-file?url=${encodeURIComponent(filePath)}${lineParam}`;
+	const url = transformUrl ? transformUrl(rawUrl, filePath, lineNumber) : rawUrl;
+	window.open(url, "_blank", "noopener,noreferrer");
+};
+
+//#endregion
+//#region src/utils/freeze-gsap.ts
+let isRafFrozen = false;
+const pendingRafCallbacks = /* @__PURE__ */ new Map();
+let nextFakeRafId = -1;
+const knownAnimationCallbacks = /* @__PURE__ */ new WeakSet();
+const nativeIdToHeldId = /* @__PURE__ */ new Map();
+const replayedFakeToNativeId = /* @__PURE__ */ new Map();
+const isAnimationLibraryCallback = (callback) => {
+	if (knownAnimationCallbacks.has(callback)) return true;
+	if (!isRafFrozen || !("gsapVersions" in window)) return false;
+	if (!((/* @__PURE__ */ new Error()).stack ?? "").includes("_tick")) return false;
+	knownAnimationCallbacks.add(callback);
+	return true;
+};
+if (typeof window !== "undefined") {
+	window.requestAnimationFrame = (callback) => {
+		if (!isAnimationLibraryCallback(callback)) return nativeRequestAnimationFrame(callback);
+		if (isRafFrozen) {
+			const identifier = nextFakeRafId--;
+			pendingRafCallbacks.set(identifier, callback);
+			return identifier;
+		}
+		const nativeId = nativeRequestAnimationFrame((timestamp) => {
+			if (isRafFrozen) {
+				const identifier = nextFakeRafId--;
+				pendingRafCallbacks.set(identifier, callback);
+				nativeIdToHeldId.set(nativeId, identifier);
+				return;
+			}
+			callback(timestamp);
+		});
+		return nativeId;
+	};
+	window.cancelAnimationFrame = (identifier) => {
+		if (pendingRafCallbacks.has(identifier)) {
+			pendingRafCallbacks.delete(identifier);
+			return;
+		}
+		const replayed = replayedFakeToNativeId.get(identifier);
+		if (replayed !== void 0) {
+			nativeCancelAnimationFrame(replayed.nativeId);
+			replayedFakeToNativeId.delete(identifier);
+			return;
+		}
+		const heldId = nativeIdToHeldId.get(identifier);
+		if (heldId !== void 0) {
+			pendingRafCallbacks.delete(heldId);
+			nativeIdToHeldId.delete(identifier);
+			return;
+		}
+		nativeCancelAnimationFrame(identifier);
+	};
+}
+const freezeGsap = () => {
+	if (isRafFrozen) return;
+	isRafFrozen = true;
+	pendingRafCallbacks.clear();
+	nativeIdToHeldId.clear();
+	for (const [fakeId, { nativeId, callback }] of replayedFakeToNativeId) {
+		nativeCancelAnimationFrame(nativeId);
+		pendingRafCallbacks.set(fakeId, callback);
+	}
+	replayedFakeToNativeId.clear();
+};
+const unfreezeGsap = () => {
+	if (!isRafFrozen) return;
+	isRafFrozen = false;
+	for (const [fakeId, callback] of pendingRafCallbacks.entries()) {
+		const nativeId = nativeRequestAnimationFrame((timestamp) => {
+			replayedFakeToNativeId.delete(fakeId);
+			callback(timestamp);
+		});
+		replayedFakeToNativeId.set(fakeId, {
+			nativeId,
+			callback
+		});
+	}
+	pendingRafCallbacks.clear();
+	nativeIdToHeldId.clear();
+};
+
+//#endregion
+//#region src/utils/freeze-animations.ts
+const FROZEN_STYLES = `
+[${FROZEN_ELEMENT_ATTRIBUTE}],
+[${FROZEN_ELEMENT_ATTRIBUTE}] * {
+  animation-play-state: paused !important;
+  transition: none !important;
+}
+`;
+const GLOBAL_FREEZE_STYLES = `
+*, *::before, *::after {
+  animation-play-state: paused !important;
+  transition: none !important;
+}
+`;
+const SVG_ROOT_SELECTOR = "svg";
+let styleElement = null;
+let frozenElements = [];
+let frozenSvgElements = [];
+let lastInputElements = [];
+let globalAnimationStyleElement = null;
+let globalFrozenSvgElements = [];
+const svgFreezeDepthMap = /* @__PURE__ */ new Map();
+let frozenWaapiAnimations = [];
+const ensureStylesInjected = () => {
+	if (styleElement) return;
+	styleElement = createStyleElement("data-react-grab-frozen-styles", FROZEN_STYLES);
+};
+const areElementsSame = (firstElements, secondElements) => firstElements.length === secondElements.length && firstElements.every((currentElement, index) => currentElement === secondElements[index]);
+const collectFrozenSvgElements = (elements) => {
+	const svgElements = /* @__PURE__ */ new Set();
+	for (const element of elements) {
+		if (element instanceof SVGSVGElement) svgElements.add(element);
+		else if (element instanceof SVGElement && element.ownerSVGElement) svgElements.add(element.ownerSVGElement);
+		for (const innerSvgElement of element.querySelectorAll(SVG_ROOT_SELECTOR)) if (innerSvgElement instanceof SVGSVGElement) svgElements.add(innerSvgElement);
+	}
+	return [...svgElements];
+};
+const callSvgAnimationMethod = (svgElement, methodName) => {
+	const animationMethod = Reflect.get(svgElement, methodName);
+	if (typeof animationMethod !== "function") return;
+	animationMethod.call(svgElement);
+};
+const pauseSvgAnimations = (svgElements) => {
+	for (const svgElement of svgElements) {
+		const currentFreezeDepth = svgFreezeDepthMap.get(svgElement) ?? 0;
+		if (currentFreezeDepth === 0) callSvgAnimationMethod(svgElement, "pauseAnimations");
+		svgFreezeDepthMap.set(svgElement, currentFreezeDepth + 1);
+	}
+};
+const resumeSvgAnimations = (svgElements) => {
+	for (const svgElement of svgElements) {
+		const currentFreezeDepth = svgFreezeDepthMap.get(svgElement);
+		if (!currentFreezeDepth) continue;
+		if (currentFreezeDepth === 1) {
+			svgFreezeDepthMap.delete(svgElement);
+			callSvgAnimationMethod(svgElement, "unpauseAnimations");
+			continue;
+		}
+		svgFreezeDepthMap.set(svgElement, currentFreezeDepth - 1);
+	}
+};
+const collectWaapiAnimations = (elements) => {
+	const animations = [];
+	for (const element of elements) for (const animation of element.getAnimations({ subtree: true })) if (animation.playState === "running") animations.push(animation);
+	return animations;
+};
+const finishAnimations = (animations) => {
+	for (const animation of animations) try {
+		animation.finish();
+	} catch {}
+};
+const freezeAllAnimations = (elements) => {
+	if (elements.length === 0) return;
+	if (areElementsSame(elements, lastInputElements)) return;
+	unfreezeAllAnimations();
+	lastInputElements = [...elements];
+	ensureStylesInjected();
+	frozenElements = elements;
+	frozenSvgElements = collectFrozenSvgElements(frozenElements);
+	pauseSvgAnimations(frozenSvgElements);
+	for (const element of frozenElements) element.setAttribute(FROZEN_ELEMENT_ATTRIBUTE, "");
+	frozenWaapiAnimations = collectWaapiAnimations(frozenElements);
+	for (const animation of frozenWaapiAnimations) animation.pause();
+};
+const unfreezeAllAnimations = () => {
+	if (frozenElements.length === 0 && frozenSvgElements.length === 0 && frozenWaapiAnimations.length === 0) return;
+	for (const element of frozenElements) element.removeAttribute(FROZEN_ELEMENT_ATTRIBUTE);
+	resumeSvgAnimations(frozenSvgElements);
+	finishAnimations(frozenWaapiAnimations);
+	frozenElements = [];
+	frozenSvgElements = [];
+	frozenWaapiAnimations = [];
+	lastInputElements = [];
+};
+const freezeAnimations = (elements) => {
+	if (elements.length === 0) {
+		unfreezeAllAnimations();
+		return () => {};
+	}
+	freezeAllAnimations(elements);
+	return unfreezeAllAnimations;
+};
+const freezeGlobalAnimations = () => {
+	if (globalAnimationStyleElement) return;
+	globalAnimationStyleElement = createStyleElement("data-react-grab-global-freeze", GLOBAL_FREEZE_STYLES);
+	globalFrozenSvgElements = collectFrozenSvgElements(Array.from(document.querySelectorAll(SVG_ROOT_SELECTOR)));
+	pauseSvgAnimations(globalFrozenSvgElements);
+	freezeGsap();
+};
+const unfreezeGlobalAnimations = () => {
+	if (!globalAnimationStyleElement) return;
+	globalAnimationStyleElement.textContent = `
+*, *::before, *::after {
+  transition: none !important;
+}
+`;
+	const animations = [];
+	for (const animation of document.getAnimations()) {
+		if (animation.effect instanceof KeyframeEffect) {
+			const target = animation.effect.target;
+			if (target instanceof Element) {
+				if (target.getRootNode() instanceof ShadowRoot) continue;
+			}
+		}
+		animations.push(animation);
+	}
+	finishAnimations(animations);
+	globalAnimationStyleElement.remove();
+	globalAnimationStyleElement = null;
+	resumeSvgAnimations(globalFrozenSvgElements);
+	globalFrozenSvgElements = [];
+	unfreezeGsap();
+};
+
+//#endregion
+//#region src/utils/log-recoverable-error.ts
+const logRecoverableError = (context, error) => {
+	console.warn(`[react-grab] ${context}:`, error);
+};
+
+//#endregion
+//#region src/utils/freeze-updates.ts
+let isUpdatesPaused = false;
+const getOrCache = (cache, key, create) => {
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const value = create();
+	cache.set(key, value);
+	return value;
+};
+const patchedDispatchers = /* @__PURE__ */ new WeakMap();
+const wrappedDispatchCache = /* @__PURE__ */ new WeakMap();
+const wrappedStartTransitionCache = /* @__PURE__ */ new WeakMap();
+const pendingStoreCallbacks = /* @__PURE__ */ new Set();
+const pendingTransitionCallbacks = [];
+const pendingStateUpdates = [];
+const pausedQueueStates = /* @__PURE__ */ new WeakMap();
+const pausedContextStates = /* @__PURE__ */ new WeakMap();
+const renderersWithPatchedDispatcher = /* @__PURE__ */ new WeakSet();
+const typedFiberRoots = $$1;
+const getFiberRoot = (fiber) => {
+	let current = fiber;
+	while (current.return) current = current.return;
+	return current.stateNode ?? null;
+};
+const collectFiberRoots = () => {
+	if (typedFiberRoots.size > 0) return typedFiberRoots;
+	const collectedRoots = /* @__PURE__ */ new Set();
+	const traverseDOM = (element) => {
+		const fiber = Z$1(element);
+		if (fiber) {
+			const fiberRoot = getFiberRoot(fiber);
+			if (fiberRoot) collectedRoots.add(fiberRoot);
+			return;
+		}
+		for (const childElement of Array.from(element.children)) {
+			traverseDOM(childElement);
+			if (collectedRoots.size > 0) return;
+		}
+	};
+	traverseDOM(document.body);
+	return collectedRoots;
+};
+const mergePendingChains = (original, buffered) => {
+	if (!original) return buffered;
+	if (!buffered) return original;
+	if (!original.next || !buffered.next) return buffered;
+	const originalFirst = original.next;
+	const bufferedFirst = buffered.next;
+	const isOriginalSingle = original === originalFirst;
+	const isBufferedSingle = buffered === bufferedFirst;
+	if (isOriginalSingle && isBufferedSingle) {
+		original.next = buffered;
+		buffered.next = original;
+	} else if (isOriginalSingle) {
+		original.next = bufferedFirst;
+		buffered.next = original;
+	} else if (isBufferedSingle) {
+		buffered.next = originalFirst;
+		original.next = buffered;
+	} else {
+		original.next = bufferedFirst;
+		buffered.next = originalFirst;
+	}
+	return buffered;
+};
+const pauseHookQueue = (queue) => {
+	if (!queue || pausedQueueStates.has(queue)) return;
+	const pauseState = {
+		originalPendingDescriptor: Object.getOwnPropertyDescriptor(queue, "pending"),
+		pendingValueAtPause: queue.pending,
+		bufferedPending: null
+	};
+	if (typeof queue.getSnapshot === "function") {
+		pauseState.originalGetSnapshot = queue.getSnapshot;
+		pauseState.snapshotValueAtPause = queue.getSnapshot();
+		queue.getSnapshot = () => isUpdatesPaused ? pauseState.snapshotValueAtPause : pauseState.originalGetSnapshot();
+	}
+	let currentPendingValue = pauseState.pendingValueAtPause;
+	Object.defineProperty(queue, "pending", {
+		configurable: true,
+		enumerable: true,
+		get: () => isUpdatesPaused ? null : currentPendingValue,
+		set: (newValue) => {
+			if (isUpdatesPaused) {
+				if (newValue !== null) pauseState.bufferedPending = mergePendingChains(pauseState.bufferedPending ?? null, newValue);
+				return;
+			}
+			currentPendingValue = newValue;
+		}
+	});
+	pausedQueueStates.set(queue, pauseState);
+};
+const extractActionsFromChain = (pending) => {
+	if (!pending) return [];
+	const actions = [];
+	const first = pending.next;
+	if (!first) return [];
+	let current = first;
+	do
+		if (current) {
+			actions.push(current.action);
+			current = current.next;
+		}
+	while (current && current !== first);
+	return actions;
+};
+const resumeHookQueue = (queue) => {
+	const pauseState = pausedQueueStates.get(queue);
+	if (!pauseState) return;
+	if (pauseState.originalGetSnapshot) queue.getSnapshot = pauseState.originalGetSnapshot;
+	if (pauseState.originalPendingDescriptor) Object.defineProperty(queue, "pending", pauseState.originalPendingDescriptor);
+	else delete queue.pending;
+	queue.pending = null;
+	const dispatch = queue.dispatch;
+	if (typeof dispatch === "function") {
+		const pendingActions = extractActionsFromChain(pauseState.pendingValueAtPause ?? null);
+		const bufferedActions = extractActionsFromChain(pauseState.bufferedPending ?? null);
+		for (const action of [...pendingActions, ...bufferedActions]) pendingStateUpdates.push(() => dispatch(action));
+	}
+	pausedQueueStates.delete(queue);
+};
+const pauseContextDependency = (contextDependency) => {
+	if (pausedContextStates.has(contextDependency)) return;
+	const pauseState = {
+		originalDescriptor: Object.getOwnPropertyDescriptor(contextDependency, "memoizedValue"),
+		frozenValue: contextDependency.memoizedValue
+	};
+	Object.defineProperty(contextDependency, "memoizedValue", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (isUpdatesPaused) return pauseState.frozenValue;
+			if (pauseState.originalDescriptor?.get) return pauseState.originalDescriptor.get.call(this);
+			return this._memoizedValue;
+		},
+		set(value) {
+			if (isUpdatesPaused) {
+				pauseState.pendingValue = value;
+				pauseState.didReceivePendingValue = true;
+				return;
+			}
+			if (pauseState.originalDescriptor?.set) pauseState.originalDescriptor.set.call(this, value);
+			else this._memoizedValue = value;
+		}
+	});
+	if (!pauseState.originalDescriptor?.get) contextDependency._memoizedValue = pauseState.frozenValue;
+	pausedContextStates.set(contextDependency, pauseState);
+};
+const resumeContextDependency = (contextDependency) => {
+	const pauseState = pausedContextStates.get(contextDependency);
+	if (!pauseState) return;
+	if (pauseState.originalDescriptor) Object.defineProperty(contextDependency, "memoizedValue", pauseState.originalDescriptor);
+	else delete contextDependency.memoizedValue;
+	if (pauseState.didReceivePendingValue) contextDependency.memoizedValue = pauseState.pendingValue;
+	pausedContextStates.delete(contextDependency);
+};
+const forEachHookQueue = (fiber, callback) => {
+	let hookState = fiber.memoizedState;
+	while (hookState) {
+		if (hookState.queue && typeof hookState.queue === "object") callback(hookState.queue);
+		hookState = hookState.next;
+	}
+};
+const forEachContextDependency = (fiber, callback) => {
+	let contextDependency = fiber.dependencies?.firstContext;
+	while (contextDependency && typeof contextDependency === "object" && "memoizedValue" in contextDependency) {
+		callback(contextDependency);
+		contextDependency = contextDependency.next;
+	}
+};
+const traverseFibers = (fiber, onCompositeFiber) => {
+	if (!fiber) return;
+	if (ve$1(fiber)) onCompositeFiber(fiber);
+	traverseFibers(fiber.child, onCompositeFiber);
+	traverseFibers(fiber.sibling, onCompositeFiber);
+};
+const pauseFiber = (fiber) => {
+	forEachHookQueue(fiber, pauseHookQueue);
+	forEachContextDependency(fiber, pauseContextDependency);
+};
+const resumeFiber = (fiber) => {
+	forEachHookQueue(fiber, resumeHookQueue);
+	forEachContextDependency(fiber, resumeContextDependency);
+};
+const patchDispatcher = (dispatcher) => {
+	if (patchedDispatchers.has(dispatcher)) return;
+	const typedDispatcher = dispatcher;
+	const originalHooks = {
+		useState: typedDispatcher.useState,
+		useReducer: typedDispatcher.useReducer,
+		useTransition: typedDispatcher.useTransition,
+		useSyncExternalStore: typedDispatcher.useSyncExternalStore
+	};
+	patchedDispatchers.set(dispatcher, originalHooks);
+	typedDispatcher.useState = (...args) => {
+		const result = originalHooks.useState.apply(dispatcher, args);
+		if (!isUpdatesPaused) return result;
+		if (!Array.isArray(result) || typeof result[1] !== "function") return result;
+		const [state, dispatch] = result;
+		return [state, getOrCache(wrappedDispatchCache, dispatch, () => (...dispatchArgs) => {
+			if (isUpdatesPaused) pendingStateUpdates.push(() => dispatch(...dispatchArgs));
+			else dispatch(...dispatchArgs);
+		})];
+	};
+	typedDispatcher.useReducer = (...args) => {
+		const result = originalHooks.useReducer.apply(dispatcher, args);
+		if (!isUpdatesPaused) return result;
+		if (!Array.isArray(result) || typeof result[1] !== "function") return result;
+		const [state, dispatch] = result;
+		return [state, getOrCache(wrappedDispatchCache, dispatch, () => (...dispatchArgs) => {
+			if (isUpdatesPaused) pendingStateUpdates.push(() => dispatch(...dispatchArgs));
+			else dispatch(...dispatchArgs);
+		})];
+	};
+	typedDispatcher.useTransition = (...args) => {
+		const result = originalHooks.useTransition.apply(dispatcher, args);
+		if (!isUpdatesPaused) return result;
+		if (!Array.isArray(result) || typeof result[1] !== "function") return result;
+		const [isPending, startTransition] = result;
+		return [isPending, getOrCache(wrappedStartTransitionCache, startTransition, () => (transitionCallback) => {
+			if (isUpdatesPaused) pendingTransitionCallbacks.push(() => startTransition(transitionCallback));
+			else startTransition(transitionCallback);
+		})];
+	};
+	typedDispatcher.useSyncExternalStore = ((subscribe, getSnapshot, getServerSnapshot) => {
+		if (!isUpdatesPaused) return originalHooks.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+		const wrappedSubscribe = (onChange) => subscribe(() => {
+			if (isUpdatesPaused) pendingStoreCallbacks.add(onChange);
+			else onChange();
+		});
+		return originalHooks.useSyncExternalStore(wrappedSubscribe, getSnapshot, getServerSnapshot);
+	});
+};
+const installDispatcherPatching = (renderer) => {
+	const dispatcherRef = renderer.currentDispatcherRef;
+	if (!dispatcherRef || typeof dispatcherRef !== "object") return;
+	const dispatcherKey = "H" in dispatcherRef ? "H" : "current";
+	let currentDispatcher = dispatcherRef[dispatcherKey];
+	Object.defineProperty(dispatcherRef, dispatcherKey, {
+		configurable: true,
+		enumerable: true,
+		get: () => {
+			if (currentDispatcher && typeof currentDispatcher === "object") patchDispatcher(currentDispatcher);
+			return currentDispatcher;
+		},
+		set: (newDispatcher) => {
+			currentDispatcher = newDispatcher;
+		}
+	});
+};
+const scheduleReactUpdate = (fiberRoots) => {
+	queueMicrotask(() => {
+		try {
+			for (const renderer of h$2().renderers.values()) {
+				if (typeof renderer.scheduleUpdate !== "function") continue;
+				for (const fiberRoot of fiberRoots) if (fiberRoot.current) try {
+					renderer.scheduleUpdate(fiberRoot.current);
+				} catch (error) {
+					logRecoverableError("scheduleUpdate failed during unfreeze", error);
+				}
+			}
+		} catch (error) {
+			logRecoverableError("scheduleReactUpdate failed", error);
+		}
+	});
+};
+const invokeCallbacks = (callbacks) => {
+	for (const callback of callbacks) try {
+		callback();
+	} catch (error) {
+		logRecoverableError("Callback failed during state replay", error);
+	}
+};
+const initializeFreezeSupport = () => {
+	for (const renderer of h$2().renderers.values()) {
+		if (renderersWithPatchedDispatcher.has(renderer)) continue;
+		installDispatcherPatching(renderer);
+		renderersWithPatchedDispatcher.add(renderer);
+	}
+};
+const freezeUpdates = () => {
+	if (isUpdatesPaused) return () => {};
+	initializeFreezeSupport();
+	isUpdatesPaused = true;
+	const fiberRoots = collectFiberRoots();
+	for (const fiberRoot of fiberRoots) traverseFibers(fiberRoot.current, pauseFiber);
+	return () => {
+		if (!isUpdatesPaused) return;
+		try {
+			const fiberRootsToResume = collectFiberRoots();
+			for (const fiberRoot of fiberRootsToResume) traverseFibers(fiberRoot.current, resumeFiber);
+			const storeCallbacksToInvoke = Array.from(pendingStoreCallbacks);
+			const transitionCallbacksToInvoke = pendingTransitionCallbacks.slice();
+			const stateUpdatesToInvoke = pendingStateUpdates.slice();
+			isUpdatesPaused = false;
+			invokeCallbacks(storeCallbacksToInvoke);
+			invokeCallbacks(transitionCallbacksToInvoke);
+			invokeCallbacks(stateUpdatesToInvoke);
+			scheduleReactUpdate(fiberRootsToResume);
+		} finally {
+			pendingStoreCallbacks.clear();
+			pendingTransitionCallbacks.length = 0;
+			pendingStateUpdates.length = 0;
+		}
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'ARROW_KEYS', {
+  enumerable: true,
+  get: function () {
+    return ARROW_KEYS;
+  }
+});
+Object.defineProperty(exports, 'ARROW_MAX_LABEL_WIDTH_RATIO', {
+  enumerable: true,
+  get: function () {
+    return ARROW_MAX_LABEL_WIDTH_RATIO;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_ACTION_ID', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_ACTION_ID;
+  }
+});
+Object.defineProperty(exports, 'DRAG_LERP_FACTOR', {
+  enumerable: true,
+  get: function () {
+    return DRAG_LERP_FACTOR;
+  }
+});
+Object.defineProperty(exports, 'DRAG_SELECTION_COVERAGE_THRESHOLD', {
+  enumerable: true,
+  get: function () {
+    return DRAG_SELECTION_COVERAGE_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, 'DROPDOWN_EDGE_TRANSFORM_ORIGIN', {
+  enumerable: true,
+  get: function () {
+    return DROPDOWN_EDGE_TRANSFORM_ORIGIN;
+  }
+});
+Object.defineProperty(exports, 'DROPDOWN_OFFSCREEN_POSITION', {
+  enumerable: true,
+  get: function () {
+    return DROPDOWN_OFFSCREEN_POSITION;
+  }
+});
+Object.defineProperty(exports, 'FEEDBACK_DURATION_MS', {
+  enumerable: true,
+  get: function () {
+    return FEEDBACK_DURATION_MS;
+  }
+});
+Object.defineProperty(exports, 'FROZEN_GLOW_COLOR', {
+  enumerable: true,
+  get: function () {
+    return FROZEN_GLOW_COLOR;
+  }
+});
+Object.defineProperty(exports, 'HINT_FLIP_IN_ANIMATION', {
+  enumerable: true,
+  get: function () {
+    return HINT_FLIP_IN_ANIMATION;
+  }
+});
+Object.defineProperty(exports, 'LERP_CONVERGENCE_THRESHOLD_PX', {
+  enumerable: true,
+  get: function () {
+    return LERP_CONVERGENCE_THRESHOLD_PX;
+  }
+});
+Object.defineProperty(exports, 'MAX_SELECTOR_COMBINATIONS', {
+  enumerable: true,
+  get: function () {
+    return MAX_SELECTOR_COMBINATIONS;
+  }
+});
+Object.defineProperty(exports, 'MAX_SESSION_STORAGE_SIZE_BYTES', {
+  enumerable: true,
+  get: function () {
+    return MAX_SESSION_STORAGE_SIZE_BYTES;
+  }
+});
+Object.defineProperty(exports, 'MODIFIER_KEYS', {
+  enumerable: true,
+  get: function () {
+    return MODIFIER_KEYS;
+  }
+});
+Object.defineProperty(exports, 'MOUNT_ROOT_RECHECK_DELAY_MS', {
+  enumerable: true,
+  get: function () {
+    return MOUNT_ROOT_RECHECK_DELAY_MS;
+  }
+});
+Object.defineProperty(exports, 'NEXTJS_REVALIDATION_DELAY_MS', {
+  enumerable: true,
+  get: function () {
+    return NEXTJS_REVALIDATION_DELAY_MS;
+  }
+});
+Object.defineProperty(exports, 'OFFSCREEN_POSITION', {
+  enumerable: true,
+  get: function () {
+    return OFFSCREEN_POSITION;
+  }
+});
+Object.defineProperty(exports, 'OPACITY_CONVERGENCE_THRESHOLD', {
+  enumerable: true,
+  get: function () {
+    return OPACITY_CONVERGENCE_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_BORDER_COLOR_DEFAULT', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_BORDER_COLOR_DEFAULT;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_BORDER_COLOR_DRAG', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_BORDER_COLOR_DRAG;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_BORDER_COLOR_INSPECT', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_BORDER_COLOR_INSPECT;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_FILL_COLOR_DEFAULT', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_FILL_COLOR_DEFAULT;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_FILL_COLOR_DRAG', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_FILL_COLOR_DRAG;
+  }
+});
+Object.defineProperty(exports, 'OVERLAY_FILL_COLOR_INSPECT', {
+  enumerable: true,
+  get: function () {
+    return OVERLAY_FILL_COLOR_INSPECT;
+  }
+});
+Object.defineProperty(exports, 'RELEVANT_CSS_PROPERTIES', {
+  enumerable: true,
+  get: function () {
+    return RELEVANT_CSS_PROPERTIES;
+  }
+});
+Object.defineProperty(exports, 'SELECTION_HINT_CYCLE_INTERVAL_MS', {
+  enumerable: true,
+  get: function () {
+    return SELECTION_HINT_CYCLE_INTERVAL_MS;
+  }
+});
+Object.defineProperty(exports, 'SELECTION_LABEL_OFFSCREEN_PX', {
+  enumerable: true,
+  get: function () {
+    return SELECTION_LABEL_OFFSCREEN_PX;
+  }
+});
+Object.defineProperty(exports, 'SELECTION_LERP_FACTOR', {
+  enumerable: true,
+  get: function () {
+    return SELECTION_LERP_FACTOR;
+  }
+});
+Object.defineProperty(exports, 'TOOLBAR_DEFAULT_POSITION_RATIO', {
+  enumerable: true,
+  get: function () {
+    return TOOLBAR_DEFAULT_POSITION_RATIO;
+  }
+});
+Object.defineProperty(exports, 'TOOLBAR_SHAKE_TOOLTIP_DURATION_MS', {
+  enumerable: true,
+  get: function () {
+    return TOOLBAR_SHAKE_TOOLTIP_DURATION_MS;
+  }
+});
+Object.defineProperty(exports, 'TOOLTIP_BASE_CLASS', {
+  enumerable: true,
+  get: function () {
+    return TOOLTIP_BASE_CLASS;
+  }
+});
+Object.defineProperty(exports, 'Te', {
+  enumerable: true,
+  get: function () {
+    return Te;
+  }
+});
+Object.defineProperty(exports, 'VERSION', {
+  enumerable: true,
+  get: function () {
+    return VERSION;
+  }
+});
+Object.defineProperty(exports, 'Z', {
+  enumerable: true,
+  get: function () {
+    return Z$1;
+  }
+});
+Object.defineProperty(exports, 'ZOOM_DETECTION_THRESHOLD', {
+  enumerable: true,
+  get: function () {
+    return ZOOM_DETECTION_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, 'Z_INDEX_OVERLAY', {
+  enumerable: true,
+  get: function () {
+    return Z_INDEX_OVERLAY;
+  }
+});
+Object.defineProperty(exports, 'Z_INDEX_OVERLAY_CANVAS', {
+  enumerable: true,
+  get: function () {
+    return Z_INDEX_OVERLAY_CANVAS;
+  }
+});
+Object.defineProperty(exports, 'checkIsNextProject', {
+  enumerable: true,
+  get: function () {
+    return checkIsNextProject;
+  }
+});
+Object.defineProperty(exports, 'clearElementPositionCache', {
+  enumerable: true,
+  get: function () {
+    return clearElementPositionCache;
+  }
+});
+Object.defineProperty(exports, 'clearVisibilityCache', {
+  enumerable: true,
+  get: function () {
+    return clearVisibilityCache;
+  }
+});
+Object.defineProperty(exports, 'detectCspNonce', {
+  enumerable: true,
+  get: function () {
+    return detectCspNonce;
+  }
+});
+Object.defineProperty(exports, 'freezeAllAnimations', {
+  enumerable: true,
+  get: function () {
+    return freezeAllAnimations;
+  }
+});
+Object.defineProperty(exports, 'freezeAnimations', {
+  enumerable: true,
+  get: function () {
+    return freezeAnimations;
+  }
+});
+Object.defineProperty(exports, 'freezeGlobalAnimations', {
+  enumerable: true,
+  get: function () {
+    return freezeGlobalAnimations;
+  }
+});
+Object.defineProperty(exports, 'freezePseudoStates', {
+  enumerable: true,
+  get: function () {
+    return freezePseudoStates;
+  }
+});
+Object.defineProperty(exports, 'freezeUpdates', {
+  enumerable: true,
+  get: function () {
+    return freezeUpdates;
+  }
+});
+Object.defineProperty(exports, 'getComponentDisplayName', {
+  enumerable: true,
+  get: function () {
+    return getComponentDisplayName;
+  }
+});
+Object.defineProperty(exports, 'getElementAtPosition', {
+  enumerable: true,
+  get: function () {
+    return getElementAtPosition;
+  }
+});
+Object.defineProperty(exports, 'getElementContext', {
+  enumerable: true,
+  get: function () {
+    return getElementContext;
+  }
+});
+Object.defineProperty(exports, 'getElementsAtPoint', {
+  enumerable: true,
+  get: function () {
+    return getElementsAtPoint;
+  }
+});
+Object.defineProperty(exports, 'getHTMLPreview', {
+  enumerable: true,
+  get: function () {
+    return getHTMLPreview;
+  }
+});
+Object.defineProperty(exports, 'getNearestComponentName', {
+  enumerable: true,
+  get: function () {
+    return getNearestComponentName;
+  }
+});
+Object.defineProperty(exports, 'getStack', {
+  enumerable: true,
+  get: function () {
+    return getStack;
+  }
+});
+Object.defineProperty(exports, 'getStackContext', {
+  enumerable: true,
+  get: function () {
+    return getStackContext;
+  }
+});
+Object.defineProperty(exports, 'getTagName', {
+  enumerable: true,
+  get: function () {
+    return getTagName;
+  }
+});
+Object.defineProperty(exports, 'hideFromThirdParties', {
+  enumerable: true,
+  get: function () {
+    return hideFromThirdParties;
+  }
+});
+Object.defineProperty(exports, 'isRootElement', {
+  enumerable: true,
+  get: function () {
+    return isRootElement;
+  }
+});
+Object.defineProperty(exports, 'isValidGrabbableElement', {
+  enumerable: true,
+  get: function () {
+    return isValidGrabbableElement;
+  }
+});
+Object.defineProperty(exports, 'logRecoverableError', {
+  enumerable: true,
+  get: function () {
+    return logRecoverableError;
+  }
+});
+Object.defineProperty(exports, 'nativeCancelAnimationFrame', {
+  enumerable: true,
+  get: function () {
+    return nativeCancelAnimationFrame;
+  }
+});
+Object.defineProperty(exports, 'nativeRequestAnimationFrame', {
+  enumerable: true,
+  get: function () {
+    return nativeRequestAnimationFrame;
+  }
+});
+Object.defineProperty(exports, 'openFile', {
+  enumerable: true,
+  get: function () {
+    return openFile;
+  }
+});
+Object.defineProperty(exports, 'resolveSource', {
+  enumerable: true,
+  get: function () {
+    return resolveSource;
+  }
+});
+Object.defineProperty(exports, 'resumePointerEventsFreeze', {
+  enumerable: true,
+  get: function () {
+    return resumePointerEventsFreeze;
+  }
+});
+Object.defineProperty(exports, 'supportsDisplayP3', {
+  enumerable: true,
+  get: function () {
+    return supportsDisplayP3;
+  }
+});
+Object.defineProperty(exports, 'suspendPointerEventsFreeze', {
+  enumerable: true,
+  get: function () {
+    return suspendPointerEventsFreeze;
+  }
+});
+Object.defineProperty(exports, 'unfreezeGlobalAnimations', {
+  enumerable: true,
+  get: function () {
+    return unfreezeGlobalAnimations;
+  }
+});
+Object.defineProperty(exports, 'unfreezePseudoStates', {
+  enumerable: true,
+  get: function () {
+    return unfreezePseudoStates;
+  }
+});
+Object.defineProperty(exports, 'waitUntilNextFrame', {
+  enumerable: true,
+  get: function () {
+    return waitUntilNextFrame;
+  }
+});