react-grab 0.1.28 → 0.1.30

package/dist/freeze-updates-Db4Id665.cjs

@@ -0,0 +1,2267 @@
+/**
+ * @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.
+ */
+let bippy_source = require("bippy/source");
+
+//#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/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.34_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.34`, t = `bippy-${e}`, n = Object.defineProperty, r = Object.prototype.hasOwnProperty, i = () => {}, a = (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 = (e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => !!(e && `getFiberRoots` in e);
+let s = !1, c;
+const l = (e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) => s ? !0 : (e && typeof e.inject == `function` && (c = e.inject.toString()), !!c?.includes(`(injected)`)), u = /* @__PURE__ */ new Set(), d$1 = /* @__PURE__ */ new Set(), f$1 = (e) => {
+	let r = /* @__PURE__ */ new Map(), o = 0, s = {
+		_instrumentationIsActive: !1,
+		_instrumentationSource: t,
+		checkDCE: a,
+		hasUnsupportedRendererAttached: !1,
+		inject(e) {
+			let t = ++o;
+			return r.set(t, e), d$1.add(e), s._instrumentationIsActive || (s._instrumentationIsActive = !0, u.forEach((e) => e())), t;
+		},
+		on: i,
+		onCommitFiberRoot: i,
+		onCommitFiberUnmount: i,
+		onPostCommitFiberRoot: i,
+		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$1.add(e), t.renderers.set(n, e);
+					}), p$1(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$1(e);
+	}
+	return s;
+}, p$1 = (e) => {
+	e && u.add(e);
+	try {
+		let n = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+		if (!n) return;
+		if (!n._instrumentationSource) {
+			n.checkDCE = a, n.supportsFiber = !0, n.supportsFlight = !0, n.hasUnsupportedRendererAttached = !1, n._instrumentationSource = t, n._instrumentationIsActive = !1;
+			let e = o(n);
+			if (e || (n.on = i), n.renderers.size) {
+				n._instrumentationIsActive = !0, u.forEach((e) => e());
+				return;
+			}
+			let r = n.inject, c = l(n);
+			c && !e && (s = !0, n.inject({ scheduleRefresh() {} }) && (n._instrumentationIsActive = !0)), n.inject = (e) => {
+				let t = r(e);
+				return d$1.add(e), c && n.renderers.set(t, e), n._instrumentationIsActive = !0, u.forEach((e) => e()), t;
+			};
+		}
+		(n.renderers.size || n._instrumentationIsActive || l()) && e?.();
+	} catch {}
+}, m$1 = () => r.call(globalThis, `__REACT_DEVTOOLS_GLOBAL_HOOK__`), h$1 = (e) => m$1() ? (p$1(e), globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__) : f$1(e), g$1 = () => !!(typeof window < `u` && (window.document?.createElement || window.navigator?.product === `ReactNative`)), _$1 = () => {
+	try {
+		g$1() && h$1();
+	} catch {}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.34_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.
+*/
+_$1();
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.34_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 = 0, ee = 1, te = 3, ne = 5, re = 6, ie = 7, f = 9, p = 11, m = 13, h = 14, g = 15, ae = 16, oe = 18, se = 19, ce = 22, le = 23, ue = 26, de = 27, fe = 28, pe = 30, _ = 60111, me = `Symbol(react.element)`, he = `Symbol(react.transitional.element)`, v = `Symbol(react.concurrent_mode)`, y = `Symbol(react.async_mode)`, b = 13366, ge = (e) => typeof e == `object` && !!e && `$$typeof` in e && [`Symbol(react.element)`, `Symbol(react.transitional.element)`].includes(String(e.$$typeof)), _e = (e) => typeof e == `object` && !!e && `tag` in e && `stateNode` in e && `return` in e && `child` in e && `sibling` in e && `flags` in e, x = (e) => {
+	switch (e.tag) {
+		case 5:
+		case 26:
+		case 27: return !0;
+		default: return typeof e.type == `string`;
+	}
+}, ve = (e) => {
+	switch (e.tag) {
+		case 1:
+		case 11:
+		case 0:
+		case 14:
+		case 15: return !0;
+		default: return !1;
+	}
+}, ye = (e) => !e || typeof e != `object` ? !1 : `pendingProps` in e && !(`containerInfo` in e), be = (e, t) => e === t || e.alternate === t || t.alternate === e, xe = (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 = (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 = (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 = (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 = (e) => !!(e.flags & (b | 8) || e.subtreeFlags & (b | 8)), E = (e) => {
+	let t = [], n = [e];
+	for (; n.length;) {
+		let e = n.pop();
+		e && (x(e) && T(e) && w(e) && t.push(e), e.child && n.push(e.child), e.sibling && n.push(e.sibling));
+	}
+	return t;
+}, D = (e) => {
+	let t = [], n = e;
+	for (; n.return;) t.push(n), n = n.return;
+	return t;
+}, O = (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 _:
+				case v:
+				case y: return !0;
+				default: return !1;
+			}
+		}
+	}
+}, k = (e, t = !1) => {
+	let n = j(e, x, t);
+	return n ||= j(e, x, !t), n;
+}, A = (e) => {
+	let t = [], n = [];
+	for (x(e) ? t.push(e) : e.child && n.push(e.child); n.length;) {
+		let e = n.pop();
+		if (!e) break;
+		x(e) ? t.push(e) : e.child && n.push(e.child), e.sibling && n.push(e.sibling);
+	}
+	return t;
+};
+function j(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(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(i, t, n);
+		if (e) return e;
+		i = n ? null : i.sibling;
+	}
+	return null;
+}
+const M = (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(r, t, n);
+		if (e) return e;
+		r = n ? null : r.sibling;
+	}
+	return null;
+}, N = 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(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 = (e) => {
+	let t = e;
+	return typeof t == `function` ? t : typeof t == `object` && t ? P(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(t);
+	return r && (r.displayName || r.name) || null;
+}, F = (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(e) || l(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 $) {
+		let n = j(t.current, (t) => {
+			if (t === e) return !0;
+		});
+		if (n) return n;
+	}
+	return e;
+};
+let G = null, K = null, q = null;
+const J = () => {
+	if (!m$1()) return null;
+	let e = h$1();
+	if (!e?.renderers) return null;
+	if (G || K || q) return {
+		overrideContext: q,
+		overrideHookState: K,
+		overrideProps: G
+	};
+	for (let [, t] of Array.from(e.renderers)) try {
+		if (K) {
+			let e = K;
+			K = (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(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 = t.overrideHookState);
+		if (G) {
+			let e = G;
+			G = (n, r, i) => {
+				e(n, r, i), t.overrideProps?.(n, r, i);
+			};
+		} else t.overrideProps && (G = t.overrideProps);
+		q = (e, t, n, r) => {
+			let i = e;
+			for (; i;) {
+				let e = i.type;
+				if (e === t || e?.Provider === t) {
+					G && (G(i, [`value`, ...n], r), i.alternate && G(i.alternate, [`value`, ...n], r));
+					break;
+				}
+				i = i.return;
+			}
+		};
+	} catch {}
+}, Y = (e) => Object.prototype.toString.call(e) === `[object Object]` && (Object.getPrototypeOf(e) === Object.prototype || Object.getPrototypeOf(e) === null), X = (e, t = []) => {
+	if (!Y(e)) return [{
+		path: t,
+		value: e
+	}];
+	let n = [];
+	for (let r in e) {
+		let i = e[r], a = t.concat(r);
+		Y(i) ? n.push(...X(i, a)) : n.push({
+			path: a,
+			value: i
+		});
+	}
+	return n;
+}, ke = (e, t) => {
+	J();
+	let n = X(t);
+	for (let { path: t, value: r } of n) try {
+		G?.(e, t, r);
+	} catch {}
+}, Ae = (e, t, n) => {
+	J();
+	let r = String(t);
+	if (Y(n)) {
+		let t = X(n);
+		for (let { path: n, value: i } of t) try {
+			K?.(e, r, n, i);
+		} catch {}
+	} else try {
+		K?.(e, r, [], n);
+	} catch {}
+}, je = (e, t, n) => {
+	if (J(), Y(n)) {
+		let r = X(n);
+		for (let { path: n, value: i } of r) try {
+			q?.(e, t, n, i);
+		} catch {}
+	} else try {
+		q?.(e, t, [], n);
+	} catch {}
+}, Me = (e) => {
+	let t$1 = h$1(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 = (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 = Error(), $ = /* @__PURE__ */ new Set(), Ne = (e, n = {}) => {
+	let i = e.onActive, a = m$1(), o$1 = o(), l$1 = l(), u, d = !n.isProduction;
+	return e.onActive = () => {
+		clearTimeout(u);
+		let t = !0;
+		try {
+			let e = h$1();
+			for (let r of e.renderers.values()) {
+				let [e] = r.version.split(`.`);
+				Number(e) < (n.minReactMajorVersion ?? 17) && (t = !1), F(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) => {
+				$.has(r) || $.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$1 && !l$1 && (u = setTimeout(() => {
+		d && n.onError?.(Q), stop();
+	}, n.installCheckTimeout ?? 100)), e;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.34_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(rootFiber, (currentFiber) => {
+		if (!(0, bippy_source.hasDebugStack)(currentFiber)) return false;
+		const ownerStack = (0, bippy_source.formatOwnerStack)(currentFiber._debugStack.stack);
+		if (!ownerStack) return false;
+		for (const frame of (0, bippy_source.parseStack)(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(current)) return current;
+		current = current.parentElement;
+	}
+	return element;
+};
+const stackCache = /* @__PURE__ */ new WeakMap();
+const fetchStackForElement = async (element) => {
+	try {
+		const fiber = Z(element);
+		if (!fiber) return null;
+		const frames = await (0, bippy_source.getOwnerStack)(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 && (0, bippy_source.isSourceFile)(frame.fileName));
+	const resolvedFrame = sourceFrames.find((frame) => frame.functionName && isSourceComponentName(frame.functionName)) ?? sourceFrames[0];
+	if (!resolvedFrame?.fileName) return null;
+	return {
+		filePath: (0, bippy_source.normalizeFileName)(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(findNearestFiberElement(element));
+	if (!fiber) return null;
+	let currentFiber = fiber.return;
+	while (currentFiber) {
+		if (ve(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 && (0, bippy_source.isSourceFile)(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(element);
+	if (!fiber) return [];
+	const componentNames = [];
+	j(fiber, (currentFiber) => {
+		if (componentNames.length >= maxCount) return true;
+		if (ve(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 && (0, bippy_source.isSourceFile)(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 += (0, bippy_source.normalizeFileName)(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, "");
+	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 = (0, bippy_source.normalizeFileName)(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 = $;
+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(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(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$1().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$1().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;
+  }
+});
+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, '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, '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;
+  }
+});