grab 0.1.35 → 0.1.36

package/dist/freeze-updates-DC22uWxG.cjs

@@ -0,0 +1,3347 @@
+/**
+ * @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 PANEL_BACKGROUND = "var(--rg-panel-bg)";
+const PANEL_SHADOW = "var(--rg-shadow)";
+const OFFSCREEN_POSITION = -1e3;
+const SELECTION_LERP_FACTOR = .95;
+const FEEDBACK_DURATION_MS = 1500;
+const COPY_DEBUG_GRABBING_DELAY_MS = 1e3;
+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 BASELINE_FRAME_DURATION_MS = 1e3 / 60;
+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 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 COMPACT_IDENTIFYING_ATTRS = ["id", "data-testid"];
+const PREVIEW_IDENTIFYING_ATTRS = new Set([
+	"id",
+	"data-testid",
+	"aria-label",
+	"href",
+	"src",
+	"alt",
+	"type",
+	"name",
+	"placeholder",
+	"role",
+	"for",
+	"action",
+	"method",
+	"title",
+	"disabled",
+	"checked",
+	"readonly",
+	"required",
+	"selected",
+	"open"
+]);
+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 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.41_react@19.2.6/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.41`, 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.41_react@19.2.6/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, f$1 = 3, p$1 = 4, m$1 = 5, h$1 = 6, te$1 = 7, ne$1 = 9, re$1 = 11, ie$1 = 13, ae$1 = 14, oe$1 = 15, se$1 = 16, ce$1 = 18, le$1 = 19, ue$1 = 22, de$1 = 23, fe$1 = 26, pe$1 = 27, me$1 = 28, he$1 = 30, g$1 = 60111, ge$1 = `Symbol(react.element)`, _e$1 = `Symbol(react.transitional.element)`, _$1 = `Symbol(react.concurrent_mode)`, v$1 = `Symbol(react.async_mode)`, y$1 = 13366, ve$1 = (e) => typeof e == `object` && !!e && `$$typeof` in e && [`Symbol(react.element)`, `Symbol(react.transitional.element)`].includes(String(e.$$typeof)), ye$1 = (e) => typeof e == `object` && !!e && `tag` in e && `stateNode` in e && `return` in e && `child` in e && `sibling` in e && `flags` in e, b$1 = (e) => {
+	switch (e.tag) {
+		case 5:
+		case 26:
+		case 27: return !0;
+		default: return typeof e.type == `string`;
+	}
+}, be$1 = (e) => {
+	switch (e.tag) {
+		case 1:
+		case 11:
+		case 0:
+		case 14:
+		case 15: return !0;
+		default: return !1;
+	}
+}, xe$1 = (e) => !e || typeof e != `object` ? !1 : `pendingProps` in e && !(`containerInfo` in e), Se$1 = (e, t) => e === t || e.alternate === t || t.alternate === e, Ce$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;
+}, x$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;
+}, S$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;
+}, C$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;
+	}
+}, w$1 = (e) => !!(e.flags & (y$1 | 8) || e.subtreeFlags & (y$1 | 8)), T$1 = (e) => {
+	let t = [], n = [e];
+	for (; n.length;) {
+		let e = n.pop();
+		e && (b$1(e) && w$1(e) && C$1(e) && t.push(e), e.child && n.push(e.child), e.sibling && n.push(e.sibling));
+	}
+	return t;
+}, E$1 = (e) => {
+	let t = [], n = e;
+	for (; n.return;) t.push(n), n = n.return;
+	return t;
+}, D$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 g$1:
+				case _$1:
+				case v$1: return !0;
+				default: return !1;
+			}
+		}
+	}
+}, O$1 = (e, t = !1) => {
+	let n = A$1(e, b$1, t);
+	return n ||= A$1(e, b$1, !t), n;
+}, k$1 = (e) => {
+	let t = [], n = [];
+	for (b$1(e) ? t.push(e) : e.child && n.push(e.child); n.length;) {
+		let e = n.pop();
+		if (!e) break;
+		b$1(e) ? t.push(e) : e.child && n.push(e.child), e.sibling && n.push(e.sibling);
+	}
+	return t;
+};
+function A$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 M$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 = j$1(i, t, n);
+		if (e) return e;
+		i = n ? null : i.sibling;
+	}
+	return null;
+}
+const j$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 = j$1(r, t, n);
+		if (e) return e;
+		r = n ? null : r.sibling;
+	}
+	return null;
+}, M$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 M$1(r, t, n);
+		if (e) return e;
+		r = n ? null : r.sibling;
+	}
+	return null;
+}, we$1 = (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
+	};
+}, Te$1 = (e) => !!e.updateQueue?.memoCache, N$1 = (e) => {
+	let t = e;
+	return typeof t == `function` ? t : typeof t == `object` && t ? N$1(t.type || t.render) : null;
+}, Ee$1 = (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 = N$1(t);
+	return r && (r.displayName || r.name) || null;
+}, P$1 = (e) => {
+	try {
+		if (typeof e.version == `string` && e.bundleType > 0) return `development`;
+	} catch {}
+	return `production`;
+}, De$1 = () => {
+	let e = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	return !!e?._instrumentationIsActive || o$1(e) || l$1(e);
+}, Oe$1 = (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 Q$1) {
+		let n = A$1(t.current, (t) => {
+			if (t === e) return !0;
+		});
+		if (n) return n;
+	}
+	return e;
+};
+let W$1 = null, G$1 = null, K$1 = null;
+const q$1 = () => {
+	if (!m$2()) return null;
+	let e = h$2();
+	if (!e?.renderers) return null;
+	if (W$1 || G$1 || K$1) return {
+		overrideContext: K$1,
+		overrideHookState: G$1,
+		overrideProps: W$1
+	};
+	for (let [, t] of Array.from(e.renderers)) try {
+		if (G$1) {
+			let e = G$1;
+			G$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 (J$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 && (G$1 = t.overrideHookState);
+		if (W$1) {
+			let e = W$1;
+			W$1 = (n, r, i) => {
+				e(n, r, i), t.overrideProps?.(n, r, i);
+			};
+		} else t.overrideProps && (W$1 = t.overrideProps);
+		K$1 = (e, t, n, r) => {
+			let i = e;
+			for (; i;) {
+				let e = i.type;
+				if (e === t || e?.Provider === t) {
+					W$1 && (W$1(i, [`value`, ...n], r), i.alternate && W$1(i.alternate, [`value`, ...n], r));
+					break;
+				}
+				i = i.return;
+			}
+		};
+	} catch {}
+}, J$1 = (e) => Object.prototype.toString.call(e) === `[object Object]` && (Object.getPrototypeOf(e) === Object.prototype || Object.getPrototypeOf(e) === null), Y$1 = (e, t = []) => {
+	if (!J$1(e)) return [{
+		path: t,
+		value: e
+	}];
+	let n = [];
+	for (let r in e) {
+		let i = e[r], a = t.concat(r);
+		J$1(i) ? n.push(...Y$1(i, a)) : n.push({
+			path: a,
+			value: i
+		});
+	}
+	return n;
+}, je$1 = (e, t) => {
+	q$1();
+	let n = Y$1(t);
+	for (let { path: t, value: r } of n) try {
+		W$1?.(e, t, r);
+	} catch {}
+}, X$1 = (e, t, n) => {
+	q$1();
+	let r = String(t);
+	if (J$1(n)) {
+		let t = Y$1(n);
+		for (let { path: n, value: i } of t) try {
+			G$1?.(e, r, n, i);
+		} catch {}
+	} else try {
+		G$1?.(e, r, [], n);
+	} catch {}
+}, Me$1 = (e, t, n) => {
+	if (q$1(), J$1(n)) {
+		let r = Y$1(n);
+		for (let { path: n, value: i } of r) try {
+			K$1?.(e, t, n, i);
+		} catch {}
+	} else try {
+		K$1?.(e, t, [], n);
+	} catch {}
+}, Ne$1 = (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;
+}, Pe$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;
+}, Z$1 = Error(), Q$1 = /* @__PURE__ */ new Set(), Fe$1 = (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), P$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) => {
+				Q$1.has(r) || Q$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?.(Z$1), stop();
+	}, n.installCheckTimeout ?? 100)), e;
+}, $ = (e, t, n) => {
+	e.type = t, e.alternate && (e.alternate.type = t), e.memoizedProps = { ...e.memoizedProps }, n.scheduleUpdate && n.scheduleUpdate(e);
+}, Ie$1 = (e, t) => {
+	let n = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	if (!n?.renderers) return;
+	let r = Array.from(n.renderers.values()).find((e) => !!e.scheduleUpdate);
+	if (!r) return;
+	let i = N$1(e.type);
+	if (!i) {
+		$(e, t, r);
+		return;
+	}
+	let a = e;
+	for (; a.return;) a = a.return;
+	j$1(a, (e) => {
+		N$1(e.type) === i && $(e, t, r);
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.41_react@19.2.6/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-internal://`,
+	`webpack://`,
+	`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 = /\(at [^)]+\)$/, d = /(^|@)\S+:\d+/, f = /^\s*at .*(\S+:\d+|\(native\))/m, ee = /^(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 = _(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(d)) {
+			let t = v(e, void 0)[0];
+			t && r.push(t);
+		}
+		return g(r, t);
+	}
+	return e.match(f) ? _(e, t) : v(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, te = (e, t) => _(e.stack, t), _ = (e, t) => g(e.split(`
+`).filter((e) => !!e.match(f)), 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
+	};
+}), ne = (e, t) => v(e.stack, t), v = (e, t) => g(e.split(`
+`).filter((e) => !e.match(ee)), 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
+		};
+	}
+}), re = (e, t) => {
+	let n = p(e);
+	return !n || e.message.includes(`
+`) && e.message.split(`
+`).length > n.split(`
+`).length ? ie(e, t) : e.stack ? oe(e, t) : ae(e, t);
+}, ie = (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);
+}, ae = (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);
+}, oe = (e, t) => g(e.stack.split(`
+`).filter((e) => !!e.match(d) && !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 se = 44, y = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`, ce = new Uint8Array(64), le = new Uint8Array(128);
+for (let e = 0; e < y.length; e++) {
+	let t = y.charCodeAt(e);
+	ce[e] = t, le[t] = e;
+}
+function b(e, t) {
+	let n = 0, r = 0, i = 0;
+	do
+		i = le[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 ue(e, t) {
+	return e.pos >= t ? !1 : e.peek() !== se;
+}
+var de = 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 x(e) {
+	let { length: t } = e, n = new de(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 = b(n, i), i < u && (l = !1), u = i, ue(n, e) ? (a = b(n, a), o = b(n, o), s = b(n, s), ue(n, e) ? (c = b(n, c), r = [
+				i,
+				a,
+				o,
+				s,
+				c
+			]) : r = [
+				i,
+				a,
+				o,
+				s
+			]) : r = [i], t.push(r), n.pos++;
+		}
+		l || fe(t), r.push(t), n.pos = e + 1;
+	} while (n.pos <= t);
+	return r;
+}
+function fe(e) {
+	e.sort(pe);
+}
+function pe(e, t) {
+	return e[0] - t[0];
+}
+const me = /^[a-zA-Z][a-zA-Z\d+\-.]*:/, he = /^data:application\/json[^,]+base64,/, ge = /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/, S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), _e = (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;
+}, w = (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 _e(r.map.mappings, r.map.sources, i, a);
+	}
+	return _e(e.mappings, e.sources, t - 1, n);
+}, ve = (e, t) => {
+	let n = t.split(`
+`), r;
+	for (let e = n.length - 1; e >= 0 && !r; e--) {
+		let t = n[e].match(ge);
+		t && (r = t[1] || t[2]);
+	}
+	if (!r) return null;
+	let i = me.test(r);
+	if (!(he.test(r) || i || r.startsWith(`/`))) {
+		let t = e.split(`/`);
+		t[t.length - 1] = r, r = t.join(`/`);
+	}
+	return r;
+}, ye = (e) => ({
+	file: e.file,
+	mappings: x(e.mappings),
+	names: e.names,
+	sourceRoot: e.sourceRoot,
+	sources: e.sources,
+	sourcesContent: e.sourcesContent,
+	version: 3
+}), be = (e) => {
+	let t = e.sections.map(({ map: e, offset: t }) => ({
+		map: {
+			...e,
+			mappings: x(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
+	};
+}, T = (e) => {
+	if (!e) return !1;
+	let t = e.trim();
+	if (!t) return !1;
+	let n = t.match(me);
+	if (!n) return !0;
+	let r = n[0].toLowerCase();
+	return r === `http:` || r === `https:`;
+}, E = async (e, t = fetch) => {
+	if (!T(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 = ve(e, n);
+	if (!r || !T(r)) return null;
+	try {
+		let e = await t(r);
+		if (!e.ok) return null;
+		let n = await e.json();
+		return `sections` in n ? be(n) : ye(n);
+	} catch {
+		return null;
+	}
+}, D = async (e, t = !0, n) => {
+	if (t && S.has(e)) return S.get(e) ?? null;
+	if (t && C.has(e)) return C.get(e);
+	let r = E(e, n);
+	t && C.set(e, r);
+	let i = await r;
+	return t && C.delete(e), t && (i === null ? S.set(e, null) : S.set(e, i)), i;
+}, O = async (e, t = !0, n) => await Promise.all(e.map(async (e) => {
+	if (!e.fileName) return e;
+	let r = await D(e.fileName, t, n);
+	if (!r || typeof e.lineNumber != `number` || typeof e.columnNumber != `number`) return e;
+	let i = w(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;
+})), k = (e) => e._debugStack instanceof Error && typeof e._debugStack?.stack == `string`, xe = () => {
+	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;
+}, A = (t) => {
+	for (let n of d$2) {
+		let e = n.currentDispatcherRef;
+		e && typeof e == `object` && (`H` in e ? e.H = t : e.current = t);
+	}
+}, j = (e) => `\n    in ${e}`, M = (e, t) => {
+	let n = j(e);
+	return t && (n += ` (at ${t})`), n;
+};
+let N = !1;
+const P = (e, t) => {
+	if (!e || N) return ``;
+	let r = Error.prepareStackTrace;
+	Error.prepareStackTrace = void 0, N = !0;
+	let i = xe();
+	A(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 = Ee$1(e);
+						return i && r.includes(`<anonymous>`) && (r = r.replace(`<anonymous>`, i)), r;
+					}
+				while (o >= 1 && s >= 0);
+				break;
+			}
+		}
+	} finally {
+		N = !1, Error.prepareStackTrace = r, A(i), console.error = a, console.warn = o;
+	}
+	let s = e ? Ee$1(e) : ``;
+	return s ? j(s) : ``;
+}, F = (e, t) => {
+	let n = e.tag, r = ``;
+	switch (n) {
+		case 28:
+			r = j(`Activity`);
+			break;
+		case 1:
+			r = P(e.type, !0);
+			break;
+		case 11:
+			r = P(e.type.render, !1);
+			break;
+		case 0:
+		case 15:
+			r = P(e.type, !1);
+			break;
+		case 5:
+		case 26:
+		case 27:
+			r = j(e.type);
+			break;
+		case 16:
+			r = j(`Lazy`);
+			break;
+		case 13:
+			r = e.child !== t && t !== null ? j(`Suspense Fallback`) : j(`Suspense`);
+			break;
+		case 19:
+			r = j(`SuspenseList`);
+			break;
+		case 30:
+			r = j(`ViewTransition`);
+			break;
+		default: return ``;
+	}
+	return r;
+}, I = (e) => {
+	try {
+		let t = ``, n = e, r = null;
+		do {
+			t += F(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 += M(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}` : ``;
+	}
+}, L = (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;
+}, Se = (e) => !!(e.functionName && e.fileName && (e.fileName.startsWith(`rsc://`) || e.fileName.startsWith(`about://React/`))), Ce = (e, t) => e.fileName === t.fileName && e.lineNumber === t.lineNumber && e.columnNumber === t.columnNumber, we = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) for (let e of n.stackFrames) {
+		if (!Se(e)) continue;
+		let n = e.functionName, r = t.get(n) ?? [];
+		r.some((t) => Ce(t, e)) || (r.push(e), t.set(n, r));
+	}
+	return t;
+}, Te = (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})`)
+	};
+}, Ee = (e) => {
+	let t = [];
+	return A$1(e, (e) => {
+		if (!k(e)) return;
+		let r = typeof e.type == `string` ? e.type : Ee$1(e.type) || `<anonymous>`;
+		t.push({
+			componentName: r,
+			stackFrames: m(L(e._debugStack?.stack))
+		});
+	}, !0), t;
+}, R = async (e, t = !0, n) => {
+	let r = Ee(e), i = m(I(e)), a = we(r), o = /* @__PURE__ */ new Map();
+	return O(i.map((e) => (e.source?.includes(`(at Server)`) ?? !1) || e.source != null && u.test(e.source) ? Te(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;
+}, De = async (e, t = !0, n) => {
+	if (z(e)) return e._debugSource || null;
+	let r = await R(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;
+}, Oe = (e) => e.split(`/`).filter(Boolean).length, ke = (e) => e.split(`/`).filter(Boolean)[0] ?? null, Ae = (e) => {
+	let t = e.indexOf(`/`, 1);
+	if (t === -1 || Oe(e.slice(0, t)) !== 1) return e;
+	let n = e.slice(t);
+	if (!s.test(n) || Oe(n) < 2) return e;
+	let r = ke(n);
+	return !r || r.startsWith(`@`) || r.length > 4 ? e : n;
+}, je = (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 = Ae(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;
+}, Me = (e) => {
+	let t = je(e);
+	return !(!t || !s.test(t) || c.test(t));
+}, Ne = (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;
+}, Pe = async (e, t = !0, r) => {
+	let i = (await R(e, t, r)).filter((e) => e.fileName)[0];
+	if (!i?.fileName) return Ee$1(e.type);
+	let a = await D(i.fileName, t, r);
+	if (!a) return Ee$1(e.type);
+	let o = null;
+	if (typeof i.lineNumber == `number` && typeof i.columnNumber == `number` && (o = w(a, i.lineNumber, i.columnNumber)), !o?.fileName || !o.lineNumber || !a.sourcesContent) return Ee$1(e.type);
+	let s = a.sources.indexOf(o.fileName);
+	if (s === -1 || !a.sourcesContent[s]) return Ee$1(e.type);
+	let c = a.sourcesContent[s];
+	return Ne(c, o.lineNumber) || Ee$1(e.type);
+}, Fe = Symbol.for(`react.context`), Ie = Symbol.for(`react.memo_cache_sentinel`);
+let B = [], V = null, H = null, U = null, W = null, G = 0, K = null;
+const q = Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render."), J = (e) => m(e.stack || ``, { includeInElement: !1 }), Y = () => {
+	let e = U;
+	return e !== null && (U = e.next), e;
+}, X = (e) => {
+	if (H === null) return e._currentValue;
+	if (W === null) throw Error(`Context reads do not line up with context dependencies.`);
+	if (Object.prototype.hasOwnProperty.call(W, `memoizedValue`)) {
+		let e = W.memoizedValue;
+		return W = W.next, e;
+	}
+	return e._currentValue;
+}, Le = () => {
+	let n = h$2(), r = [...d$2, ...n.renderers.values()];
+	for (let e of r) {
+		let t = e.currentDispatcherRef;
+		if (t && typeof t == `object`) return t;
+	}
+	return null;
+}, Re = (e) => `H` in e ? e.H : e.current, ze = (e, t) => {
+	`H` in e ? e.H = t : e.current = t;
+}, Z = (e, t, n, r = null) => {
+	B.push({
+		displayName: r,
+		primitive: e,
+		stackError: Error(),
+		value: t,
+		dispatcherHookName: n
+	});
+}, Be = (e) => {
+	if (typeof e == `object` && e) {
+		let t = e;
+		if (typeof t.then == `function`) {
+			let e = K !== null && G < K.length ? K[G++] : t;
+			switch (e.status) {
+				case `fulfilled`: return Z(`Promise`, e.value, `Use`), e.value;
+				case `rejected`: throw e.reason;
+			}
+			throw Z(`Unresolved`, e, `Use`), q;
+		}
+		if (t.$$typeof === Fe && `_currentValue` in t) {
+			let e = t, n = X(e);
+			return Z(`Context (use)`, n, `Use`, e.displayName || `Context`), n;
+		}
+	}
+	throw Error(`An unsupported type was passed to use(): ` + String(e));
+}, Ve = (e) => {
+	let t = X(e);
+	return Z(`Context`, t, `Context`, e.displayName || null), t;
+}, He = (e) => {
+	let t = Y(), n = t === null ? typeof e == `function` ? e() : e : t.memoizedState;
+	return Z(`State`, n, `State`), [n, () => {}];
+}, Ue = (e, t, n) => {
+	let r = Y(), i = r === null ? n === void 0 ? t : n(t) : r.memoizedState;
+	return Z(`Reducer`, i, `Reducer`), [i, () => {}];
+}, We = (e) => {
+	let t = Y(), n = t === null ? { current: e } : t.memoizedState;
+	return Z(`Ref`, n.current, `Ref`), n;
+}, Ge = () => {
+	let e = Y();
+	return Z(`CacheRefresh`, e === null ? () => {} : e.memoizedState, `CacheRefresh`), () => {};
+}, Ke = (e) => {
+	Y(), Z(`LayoutEffect`, e, `LayoutEffect`);
+}, qe = (e) => {
+	Y(), Z(`InsertionEffect`, e, `InsertionEffect`);
+}, Je = (e) => {
+	Y(), Z(`Effect`, e, `Effect`);
+}, Ye = (e) => {
+	Y();
+	let t;
+	typeof e == `object` && e && `current` in e && (t = e.current), Z(`ImperativeHandle`, t, `ImperativeHandle`);
+}, Xe = (e, t) => {
+	Z(`DebugValue`, typeof t == `function` ? t(e) : e, `DebugValue`);
+}, Ze = (e) => {
+	let t = Y();
+	return Z(`Callback`, t === null ? e : t.memoizedState[0], `Callback`), e;
+}, Qe = (e) => {
+	let t = Y(), n = t === null ? e() : t.memoizedState[0];
+	return Z(`Memo`, n, `Memo`), n;
+}, $e = (e, t) => {
+	let n = Y();
+	Y();
+	let r = n === null ? t() : n.memoizedState;
+	return Z(`SyncExternalStore`, r, `SyncExternalStore`), r;
+}, et = () => {
+	let e = Y();
+	Y();
+	let t = e === null ? !1 : e.memoizedState;
+	return Z(`Transition`, t, `Transition`), [t, () => {}];
+}, tt = (e) => {
+	let t = Y(), n = t === null ? e : t.memoizedState;
+	return Z(`DeferredValue`, n, `DeferredValue`), n;
+}, nt = () => {
+	let e = Y(), t = e === null ? `` : e.memoizedState;
+	return Z(`Id`, t, `Id`), t;
+}, rt = (e) => {
+	let t = H;
+	if (t == null) return [];
+	let n = t.updateQueue?.memoCache;
+	if (n == null) return [];
+	let r = n.data[n.index];
+	return r === void 0 && (r = n.data[n.index] = Array.from({ length: e }, () => Ie)), n.index++, r;
+}, it = (e) => {
+	let t = Y(), n = t === null ? e : t.memoizedState;
+	return Z(`Optimistic`, n, `Optimistic`), [n, () => {}];
+}, at = (e, t) => {
+	let n, r = null;
+	if (e !== null) {
+		let t = e.memoizedState;
+		if (typeof t == `object` && t && `then` in t && typeof t.then == `function`) {
+			let e = t;
+			switch (e.status) {
+				case `fulfilled`:
+					n = e.value;
+					break;
+				case `rejected`:
+					r = e.reason;
+					break;
+				default: r = q, n = e;
+			}
+		} else n = t;
+	} else n = t;
+	return {
+		value: n,
+		error: r
+	};
+}, ot = (e) => (t, n) => {
+	let r = Y();
+	Y(), Y();
+	let i = Error(), { value: a, error: o } = at(r, n);
+	if (B.push({
+		displayName: null,
+		primitive: e,
+		stackError: i,
+		value: a,
+		dispatcherHookName: e
+	}), o !== null) throw o;
+	return [
+		a,
+		() => {},
+		!1
+	];
+}, st = ot(`ActionState`), Q = {
+	readContext: X,
+	use: Be,
+	useCallback: Ze,
+	useContext: Ve,
+	useEffect: Je,
+	useImperativeHandle: Ye,
+	useLayoutEffect: Ke,
+	useInsertionEffect: qe,
+	useMemo: Qe,
+	useReducer: Ue,
+	useRef: We,
+	useState: He,
+	useDebugValue: Xe,
+	useDeferredValue: tt,
+	useTransition: et,
+	useSyncExternalStore: $e,
+	useId: nt,
+	useHostTransitionStatus: () => {
+		let e = X({ _currentValue: null });
+		return Z(`HostTransitionStatus`, e, `HostTransitionStatus`), e;
+	},
+	useFormState: ot(`FormState`),
+	useActionState: st,
+	useOptimistic: it,
+	useMemoCache: rt,
+	useCacheRefresh: Ge,
+	useEffectEvent: (e) => (Y(), Z(`EffectEvent`, e, `EffectEvent`), e)
+}, ct = typeof Proxy > `u` ? Q : new Proxy(Q, { get(e, t) {
+	if (Object.prototype.hasOwnProperty.call(e, t)) return e[t];
+	let n = Error(`Missing method in Dispatcher: ` + t);
+	throw n.name = `ReactDebugToolsUnsupportedHookError`, n;
+} }), lt = () => {
+	if (V !== null) return V;
+	let e = /* @__PURE__ */ new Map(), t;
+	try {
+		if (Q.useContext({ _currentValue: null }), Q.useState(null), Q.useReducer((e) => e, null), Q.useRef(null), typeof Q.useCacheRefresh == `function` && Q.useCacheRefresh(), Q.useLayoutEffect(() => {}), Q.useInsertionEffect(() => {}), Q.useEffect(() => {}), Q.useImperativeHandle(void 0, () => null), Q.useDebugValue(null), Q.useCallback(() => {}), Q.useTransition(), Q.useSyncExternalStore(() => () => {}, () => null, () => null), Q.useDeferredValue(null), Q.useMemo(() => null), Q.useOptimistic(null, (e) => e), Q.useFormState((e) => e, null), Q.useActionState((e) => e, null), Q.useHostTransitionStatus(), typeof Q.useMemoCache == `function` && Q.useMemoCache(0), typeof Q.use == `function`) {
+			Q.use({
+				$$typeof: Fe,
+				_currentValue: null
+			}), Q.use({
+				then() {},
+				status: `fulfilled`,
+				value: null
+			});
+			try {
+				Q.use({ then() {} });
+			} catch {}
+		}
+		Q.useId(), typeof Q.useEffectEvent == `function` && Q.useEffectEvent(() => {});
+	} finally {
+		t = B, B = [];
+	}
+	for (let n of t) e.set(n.primitive, J(n.stackError));
+	return V = e, V;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.5.41_react@19.2.6/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.41_react@19.2.6/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/utils/normalize-file-path.ts
+const BUNDLER_LAYER_PREFIX_REGEX = /^(?:\.\/)?\/?\([a-z][a-z0-9-]*\)\//;
+const normalizeFilePath = (fileName) => {
+	let normalized = je(fileName);
+	normalized = normalized.replace(BUNDLER_LAYER_PREFIX_REGEX, "");
+	if (normalized.startsWith("./")) normalized = normalized.slice(2);
+	return normalized;
+};
+
+//#endregion
+//#region src/utils/safe-decode-uri-component.ts
+const safeDecodeURIComponent = (input) => {
+	try {
+		return decodeURIComponent(input);
+	} catch {
+		return input;
+	}
+};
+
+//#endregion
+//#region src/utils/parse-package-name.ts
+const NODE_MODULES_PATTERN = /(?:^|[/\\])node_modules[/\\]/g;
+const VITE_OPTIMIZED_DEPS_PATTERN = /[/\\]\.vite[/\\]deps[^/\\]*[/\\]/g;
+const FILE_EXTENSION_PATTERN = /\.[mc]?[jt]sx?$/i;
+const VITE_INTERNAL_CHUNK_PATTERN = /^chunk-[A-Za-z0-9_-]+$/;
+const PATH_SEPARATOR_PATTERN = /[/\\]/;
+const NAME_AT_VERSION_PATTERN = /^(.+?)@v?\d/;
+const splitPathSegments = (path) => path.split(PATH_SEPARATOR_PATTERN).filter(Boolean);
+const readNodeModulesPackage = (afterMarker) => {
+	const [first, second] = splitPathSegments(afterMarker);
+	if (!first || first.startsWith(".")) return null;
+	if (!first.startsWith("@")) return first;
+	return second ? `${first}/${second}` : null;
+};
+const readViteOptimizedDepPackage = (afterMarker) => {
+	const firstSegment = splitPathSegments(afterMarker)[0];
+	if (!firstSegment) return null;
+	const stem = firstSegment.replace(FILE_EXTENSION_PATTERN, "");
+	if (VITE_INTERNAL_CHUNK_PATTERN.test(stem)) return null;
+	if (!stem.startsWith("@")) return stem;
+	const scopeBoundary = stem.indexOf("_");
+	if (scopeBoundary === -1) return null;
+	return `${stem.slice(0, scopeBoundary)}/${stem.slice(scopeBoundary + 1)}`;
+};
+const extractAfterLastMarker = (input, pattern, read) => {
+	let lastMatch = null;
+	let match;
+	while ((match = pattern.exec(input)) !== null) lastMatch = match;
+	if (!lastMatch) return null;
+	return read(input.slice(lastMatch.index + lastMatch[0].length));
+};
+const extractNameAtVersion = (segment) => segment?.match(NAME_AT_VERSION_PATTERN)?.[1] ?? null;
+const extractVersionedPackageFromUrl = (rawFileName) => {
+	let url;
+	try {
+		url = new URL(rawFileName);
+	} catch {
+		return null;
+	}
+	if (!url.hostname) return null;
+	const segments = splitPathSegments(url.pathname).map(safeDecodeURIComponent);
+	for (const [index, segment] of segments.entries()) {
+		if (segment.startsWith("@")) {
+			const name = extractNameAtVersion(segments[index + 1]);
+			if (name) return `${segment}/${name}`;
+			continue;
+		}
+		const name = extractNameAtVersion(segment);
+		if (name) return name;
+	}
+	return null;
+};
+const extractFromLocalPath = (normalizedPath) => extractAfterLastMarker(normalizedPath, VITE_OPTIMIZED_DEPS_PATTERN, readViteOptimizedDepPackage) ?? extractAfterLastMarker(normalizedPath, NODE_MODULES_PATTERN, readNodeModulesPackage);
+const parsePackageName = (fileName) => {
+	if (!fileName) return null;
+	const normalized = je(fileName);
+	if (!normalized) return null;
+	const localResult = extractFromLocalPath(safeDecodeURIComponent(normalized));
+	if (localResult) return localResult;
+	const cdnResult = extractVersionedPackageFromUrl(fileName);
+	if (cdnResult) return cdnResult;
+	return null;
+};
+
+//#endregion
+//#region src/utils/strip-internal-attributes.ts
+const isInternalAttribute = (name) => name.startsWith("data-react-grab-");
+
+//#endregion
+//#region src/utils/is-useful-component-name.ts
+const NON_COMPONENT_PREFIXES = new Set([
+	"_",
+	"$",
+	"motion.",
+	"styled.",
+	"chakra.",
+	"ark.",
+	"Primitive.",
+	"Slot."
+]);
+const NEXT_INTERNAL_COMPONENT_NAMES = new Set([
+	"AppRouter",
+	"AppRouterAnnouncer",
+	"AppDevOverlay",
+	"AppDevOverlayErrorBoundary",
+	"ClientPageRoot",
+	"ClientSegmentRoot",
+	"DevRootHTTPAccessFallbackBoundary",
+	"ErrorBoundary",
+	"ErrorBoundaryHandler",
+	"GracefulDegradeBoundary",
+	"HTTPAccessErrorFallback",
+	"HTTPAccessFallbackBoundary",
+	"HTTPAccessFallbackErrorBoundary",
+	"HandleRedirect",
+	"Head",
+	"HistoryUpdater",
+	"HotReload",
+	"InnerLayoutRouter",
+	"InnerScrollAndFocusHandler",
+	"InnerScrollAndFocusHandlerOld",
+	"InnerScrollAndMaybeFocusHandler",
+	"InnerScrollHandlerNew",
+	"LoadableComponent",
+	"LoadingBoundary",
+	"LoadingBoundaryProvider",
+	"NotAllowedRootHTTPFallbackError",
+	"OfflineProvider",
+	"OuterLayoutRouter",
+	"RedirectBoundary",
+	"RedirectErrorBoundary",
+	"RenderFromTemplateContext",
+	"RenderValidationBoundaryAtThisLevel",
+	"ReplaySsrOnlyErrors",
+	"RootErrorBoundary",
+	"RootLevelDevOverlayElement",
+	"Router",
+	"ScrollAndFocusHandler",
+	"ScrollAndMaybeFocusHandler",
+	"SegmentBoundaryTrigger",
+	"SegmentBoundaryTriggerNode",
+	"SegmentStateProvider",
+	"SegmentTrieNode",
+	"SegmentViewNode",
+	"SegmentViewStateNode",
+	"ServerRoot",
+	"body",
+	"html"
+]);
+const REACT_INTERNAL_COMPONENT_NAMES = new Set([
+	"Suspense",
+	"Fragment",
+	"StrictMode",
+	"Profiler",
+	"SuspenseList"
+]);
+const LIBRARY_INTERNAL_COMPONENT_NAMES = new Set(["MotionDOMComponent"]);
+const isInternalComponentName = (name) => {
+	if (NEXT_INTERNAL_COMPONENT_NAMES.has(name)) return true;
+	if (REACT_INTERNAL_COMPONENT_NAMES.has(name)) return true;
+	if (LIBRARY_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;
+};
+
+//#endregion
+//#region src/core/context.ts
+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 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);
+		if (environmentEndIndex === -1) continue;
+		const pathStart = environmentEndIndex + 1;
+		const querySuffixIndex = url.lastIndexOf("?");
+		return safeDecodeURIComponent(querySuffixIndex > pathStart ? url.slice(pathStart, querySuffixIndex) : url.slice(pathStart));
+	}
+	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();
+	A$1(rootFiber, (currentFiber) => {
+		if (!k(currentFiber)) return false;
+		const ownerStack = L(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 (!De$1()) return element;
+	let current = element;
+	while (current) {
+		if (Pe$1(current)) return current;
+		current = current.parentElement;
+	}
+	return element;
+};
+const stackCache = /* @__PURE__ */ new WeakMap();
+const fetchStackForElement = async (element) => {
+	try {
+		const fiber = Pe$1(element);
+		if (!fiber) return null;
+		const frames = await R(fiber);
+		if (checkIsNextProject()) return await symbolicateServerFrames(enrichServerFrameLocations(fiber, frames));
+		return frames;
+	} catch {
+		return null;
+	}
+};
+const getStack = (element) => {
+	if (!De$1()) 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 (!De$1()) 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 && Me(frame.fileName));
+	const resolvedFrame = sourceFrames.find((frame) => frame.functionName && isSourceComponentName(frame.functionName)) ?? sourceFrames[0];
+	if (!resolvedFrame?.fileName) return null;
+	return {
+		filePath: normalizeFilePath(resolvedFrame.fileName),
+		lineNumber: resolvedFrame.lineNumber ?? null,
+		columnNumber: resolvedFrame.columnNumber ?? null,
+		componentName: resolvedFrame.functionName && isSourceComponentName(resolvedFrame.functionName) ? resolvedFrame.functionName : null
+	};
+};
+const getComponentDisplayName = (element) => {
+	if (!De$1()) return null;
+	const fiber = Pe$1(findNearestFiberElement(element));
+	if (!fiber) return null;
+	let currentFiber = fiber.return;
+	while (currentFiber) {
+		if (be$1(currentFiber)) {
+			const name = Ee$1(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 && Me(frame.fileName)) return true;
+		if (frame.isServer && (!frame.functionName || isSourceComponentName(frame.functionName))) return true;
+		if (frame.functionName && isSourceComponentName(frame.functionName)) return true;
+		return false;
+	});
+};
+const getComponentNamesFromFiber = (element, maxCount) => {
+	if (!De$1()) return [];
+	const fiber = Pe$1(element);
+	if (!fiber) return [];
+	const componentNames = [];
+	A$1(fiber, (currentFiber) => {
+		if (componentNames.length >= maxCount) return true;
+		if (be$1(currentFiber)) {
+			const name = Ee$1(currentFiber.type);
+			if (name && isUsefulComponentName(name)) componentNames.push(name);
+		}
+		return false;
+	}, true);
+	return componentNames;
+};
+const formatResolvedSourceLine = (frame, filePath, componentName, isNextProject) => {
+	const location = isNextProject && frame.lineNumber ? `${normalizeFilePath(filePath)}:${frame.lineNumber}${frame.columnNumber ? `:${frame.columnNumber}` : ""}` : normalizeFilePath(filePath);
+	return componentName ? `\n  in ${componentName} (at ${location})` : `\n  in ${location}`;
+};
+const formatStackContext = (stack, options = {}) => {
+	const { maxLines = 3 } = options;
+	const isNextProject = checkIsNextProject();
+	const lines = [];
+	let previousLibraryPackage = null;
+	const emit = (line, libraryPackage) => {
+		lines.push(line);
+		previousLibraryPackage = libraryPackage;
+	};
+	for (const frame of stack) {
+		if (lines.length >= maxLines) break;
+		const resolvedSource = frame.fileName && Me(frame.fileName) ? frame.fileName : null;
+		const libraryPackage = resolvedSource ? null : parsePackageName(frame.fileName);
+		if (libraryPackage && libraryPackage === previousLibraryPackage) continue;
+		const componentName = frame.functionName && isSourceComponentName(frame.functionName) ? frame.functionName : null;
+		if (frame.isServer && !resolvedSource && (componentName || !frame.functionName)) {
+			const tag = libraryPackage ? `${libraryPackage} at Server` : "at Server";
+			emit(`\n  in ${componentName ?? "<anonymous>"} (${tag})`, libraryPackage);
+			continue;
+		}
+		if (!resolvedSource && componentName) {
+			emit(libraryPackage ? `\n  in ${componentName} (${libraryPackage})` : `\n  in ${componentName}`, libraryPackage);
+			continue;
+		}
+		if (resolvedSource) emit(formatResolvedSourceLine(frame, resolvedSource, componentName, isNextProject), null);
+	}
+	return lines.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) => {
+	if (!(element instanceof HTMLElement)) return getInlineHTMLPreview(element);
+	const tagName = getTagName(element);
+	const attrsText = formatAttrsForPreview(element);
+	const truncatedText = truncateString(getDirectTextContent(element), 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 isClassOrStyleAttr = (name) => name === "class" || name === "className" || name === "style";
+const formatAttrsForPreview = (element) => {
+	const identifyingParts = [];
+	const remainingParts = [];
+	let classAttr = "";
+	for (const { name, value } of element.attributes) {
+		if (isInternalAttribute(name)) continue;
+		if (isClassOrStyleAttr(name)) {
+			if (name !== "style" && value) classAttr = ` class="${truncateAttrValue(value)}"`;
+			continue;
+		}
+		if (PREVIEW_IDENTIFYING_ATTRS.has(name)) identifyingParts.push(value ? ` ${name}="${value}"` : ` ${name}`);
+		else if (value) remainingParts.push(` ${name}="${truncateAttrValue(value)}"`);
+	}
+	return identifyingParts.join("") + remainingParts.join("") + classAttr;
+};
+const getDirectTextContent = (element) => {
+	let directText = "";
+	for (const node of element.childNodes) if (node.nodeType === Node.TEXT_NODE) {
+		const trimmed = node.textContent?.trim() ?? "";
+		if (trimmed) directText += (directText ? " " : "") + trimmed;
+	}
+	return directText;
+};
+const formatChildElements = (elements) => {
+	if (elements.length === 0) return "";
+	if (elements.length <= 2) return elements.map((childElement) => `<${getTagName(childElement)} ...>`).join("\n  ");
+	return `(${elements.length} elements)`;
+};
+const getInlineHTMLPreview = (element) => {
+	const tagName = getTagName(element);
+	if (!(element instanceof HTMLElement)) return `<${tagName}${formatPriorityAttrs(element, {
+		truncate: false,
+		maxAttrs: PREVIEW_PRIORITY_ATTRS.length
+	})} />`;
+	const attrsText = formatAttrsForPreview(element);
+	const truncatedText = truncateString(getDirectTextContent(element), 100);
+	if (truncatedText) return `<${tagName}${attrsText}>${truncatedText}</${tagName}>`;
+	return `<${tagName}${attrsText} />`;
+};
+const getHTMLPreview = (element) => {
+	const tagName = getTagName(element);
+	const attrsText = formatAttrsForPreview(element);
+	const directText = getDirectTextContent(element);
+	const topElements = [];
+	const bottomElements = [];
+	let foundFirstText = false;
+	for (const node of element.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);
+	}
+	let content = "";
+	const topElementsStr = formatChildElements(topElements);
+	if (topElementsStr) content += `\n  ${topElementsStr}`;
+	if (directText.length > 0) content += `\n  ${truncateString(directText, 100)}`;
+	const bottomElementsStr = formatChildElements(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 hasTransparentBackground = (computedStyle) => {
+	const backgroundColor = computedStyle.backgroundColor;
+	return backgroundColor === "transparent" || backgroundColor === "rgba(0, 0, 0, 0)";
+};
+const isFullViewportOverlay = (computedStyle) => {
+	const position = computedStyle.position;
+	if (position !== "fixed" && position !== "absolute") return false;
+	if (hasTransparentBackground(computedStyle) || 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(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/pointer-events-freeze.ts
+const POINTER_EVENTS_STYLES = "html { pointer-events: none !important; }";
+let pointerEventsStyle = null;
+const isPointerEventsFreezeInstalled = () => pointerEventsStyle !== null;
+const installPointerEventsFreeze = () => {
+	if (pointerEventsStyle) return;
+	pointerEventsStyle = createStyleElement("data-react-grab-frozen-pseudo", POINTER_EVENTS_STYLES);
+};
+const uninstallPointerEventsFreeze = () => {
+	pointerEventsStyle?.remove();
+	pointerEventsStyle = null;
+};
+const suspendPointerEventsFreeze = () => {
+	if (pointerEventsStyle) pointerEventsStyle.disabled = true;
+};
+const resumePointerEventsFreeze = () => {
+	if (pointerEventsStyle) pointerEventsStyle.disabled = false;
+};
+
+//#endregion
+//#region src/utils/get-element-at-position.ts
+let cache = null;
+let hoveredIframe = null;
+let resumeTimerId = null;
+const isPointInsideRect = (clientX, clientY, rect) => clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
+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) => {
+	if (!Number.isFinite(clientX) || !Number.isFinite(clientY)) return [];
+	cancelScheduledResume();
+	suspendPointerEventsFreeze();
+	const elements = document.elementsFromPoint(clientX, clientY);
+	scheduleResume();
+	return elements;
+};
+const getElementAtPosition = (clientX, clientY) => {
+	if (!Number.isFinite(clientX) || !Number.isFinite(clientY)) return null;
+	const now = performance.now();
+	if (hoveredIframe && isPointInsideRect(clientX, clientY, hoveredIframe.rect)) return hoveredIframe.element;
+	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();
+	hoveredIframe = result instanceof HTMLIFrameElement ? {
+		element: result,
+		rect: result.getBoundingClientRect()
+	} : null;
+	cache = {
+		clientX,
+		clientY,
+		element: result,
+		timestamp: now
+	};
+	return result;
+};
+const clearElementPositionCache = () => {
+	cancelScheduledResume();
+	resumePointerEventsFreeze();
+	cache = null;
+	hoveredIframe = 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 = normalizeFilePath(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 animationsToFinish = [];
+	for (const animation of document.getAnimations()) {
+		if (animation.effect instanceof KeyframeEffect) {
+			const target = animation.effect.target;
+			if (target instanceof Element && target.getRootNode() instanceof ShadowRoot) continue;
+		}
+		animationsToFinish.push(animation);
+	}
+	finishAnimations(animationsToFinish);
+	globalAnimationStyleElement.remove();
+	globalAnimationStyleElement = null;
+	resumeSvgAnimations(globalFrozenSvgElements);
+	globalFrozenSvgElements = [];
+	unfreezeGsap();
+};
+
+//#endregion
+//#region src/utils/freeze-pseudo-states.ts
+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();
+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 freezeElement = (element, properties, alreadyFrozen) => {
+	if (alreadyFrozen?.has(element)) return null;
+	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; `;
+	}
+	return {
+		element,
+		frozenStyles,
+		originalPropertyValues
+	};
+};
+const collectHoveredElements = (cursorX, cursorY) => {
+	const hoveredElements = [];
+	let current = document.elementFromPoint(cursorX, cursorY);
+	while (current && current !== document.documentElement) {
+		if (current instanceof HTMLElement) hoveredElements.push(current);
+		current = current.parentElement;
+	}
+	return hoveredElements;
+};
+const collectFocusedElements = () => {
+	const focusedElements = [];
+	let current = document.activeElement;
+	while (current && current !== document.body) {
+		if (current instanceof HTMLElement) focusedElements.push(current);
+		current = current.shadowRoot?.activeElement ?? null;
+	}
+	return focusedElements;
+};
+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 freezePseudoStates = (cursorX, cursorY) => {
+	if (isPointerEventsFreezeInstalled()) 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 = [];
+	const hoveredElements = cursorX !== void 0 && cursorY !== void 0 && cursorX >= 0 && cursorY >= 0 && cursorX < window.innerWidth && cursorY < window.innerHeight ? collectHoveredElements(cursorX, cursorY) : Array.from(document.querySelectorAll(":hover")).filter((element) => element instanceof HTMLElement);
+	for (const element of hoveredElements) {
+		const state = freezeElement(element, HOVER_STYLE_PROPERTIES);
+		if (state) hoverStates.push(state);
+	}
+	const focusStates = [];
+	for (const element of collectFocusedElements()) {
+		const state = freezeElement(element, FOCUS_STYLE_PROPERTIES, frozenFocusElements);
+		if (state) focusStates.push(state);
+	}
+	applyFrozenStates(hoverStates, frozenHoverElements);
+	applyFrozenStates(focusStates, frozenFocusElements);
+	installPointerEventsFreeze();
+};
+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);
+	uninstallPointerEventsFreeze();
+};
+
+//#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 = Q$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 = Pe$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 (be$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, 'BASELINE_FRAME_DURATION_MS', {
+  enumerable: true,
+  get: function () {
+    return BASELINE_FRAME_DURATION_MS;
+  }
+});
+Object.defineProperty(exports, 'COMPACT_IDENTIFYING_ATTRS', {
+  enumerable: true,
+  get: function () {
+    return COMPACT_IDENTIFYING_ATTRS;
+  }
+});
+Object.defineProperty(exports, 'COPY_DEBUG_GRABBING_DELAY_MS', {
+  enumerable: true,
+  get: function () {
+    return COPY_DEBUG_GRABBING_DELAY_MS;
+  }
+});
+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, 'De', {
+  enumerable: true,
+  get: function () {
+    return De$1;
+  }
+});
+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, '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_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, 'PANEL_BACKGROUND', {
+  enumerable: true,
+  get: function () {
+    return PANEL_BACKGROUND;
+  }
+});
+Object.defineProperty(exports, 'PANEL_SHADOW', {
+  enumerable: true,
+  get: function () {
+    return PANEL_SHADOW;
+  }
+});
+Object.defineProperty(exports, 'Pe', {
+  enumerable: true,
+  get: function () {
+    return Pe$1;
+  }
+});
+Object.defineProperty(exports, 'RELEVANT_CSS_PROPERTIES', {
+  enumerable: true,
+  get: function () {
+    return RELEVANT_CSS_PROPERTIES;
+  }
+});
+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, 'VERSION', {
+  enumerable: true,
+  get: function () {
+    return VERSION;
+  }
+});
+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, 'getDirectTextContent', {
+  enumerable: true,
+  get: function () {
+    return getDirectTextContent;
+  }
+});
+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, 'getInlineHTMLPreview', {
+  enumerable: true,
+  get: function () {
+    return getInlineHTMLPreview;
+  }
+});
+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, 'truncateString', {
+  enumerable: true,
+  get: function () {
+    return truncateString;
+  }
+});
+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;
+  }
+});