likec4 1.59.4 → 1.61.0

package/__app__/src/chunks/libs/react-resizable-panels.mjs

@@ -0,0 +1,2792 @@
+import "../rolldown-runtime.mjs";
+import { Children, createContext, isValidElement, useCallback, useContext, useEffect, useId, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// ../../node_modules/.pnpm/react-resizable-panels@4.14.3_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/react-resizable-panels/dist/react-resizable-panels.js
+function Te(e) {
+	const t = useId();
+	return `${e ?? t}`;
+}
+var ne = typeof window < "u" ? useLayoutEffect : useEffect;
+function ge(e) {
+	const t = useRef(e);
+	return ne(() => {
+		t.current = e;
+	}, [e]), useCallback((...n) => t.current?.(...n), [t]);
+}
+function qe(...e) {
+	return ge((t) => {
+		e.forEach((n) => {
+			if (n) switch (typeof n) {
+				case "function":
+					n(t);
+					break;
+				case "object": n.current = t;
+			}
+		});
+	});
+}
+function nt(e, t) {
+	return t ? e * 2 + 1 : e + 1;
+}
+function Sn(e, t) {
+	return t ? e * 2 - 1 : e;
+}
+function ht(e, t, n) {
+	const o = nt(e, n);
+	return t === void 0 ? `${o} / -1` : `${o} / span ${Sn(t, n)}`;
+}
+function vn(e) {
+	return `${e * 2} / span 1`;
+}
+function bn({ crossCount: e, crossSpan: t, crossStart: n, hasGutters: o }) {
+	const r = t === void 0 ? e : n + t;
+	if (n === 0 && r === e) return "1 / -1";
+	let i = nt(n, o);
+	let s = nt(r - 1, o) + 1;
+	return o && (n > 0 && i--, r < e && s++), `${i} / ${s}`;
+}
+function at(e, t) {
+	return Number.isInteger(e) && e >= 1 && e < t;
+}
+function D(e, t = "Assertion error") {
+	if (!e) throw Error(t);
+}
+var jt = createContext(null);
+function Ut() {
+	const e = useContext(jt);
+	return D(e, "Grid Context not found; did you render a Cell or Gridline outside of a Grid?"), e;
+}
+function xn({ children: e, className: t, column: n, columnSpan: o = 1, elementRef: r, id: i, row: s, rowSpan: l = 1, style: a, ...c }) {
+	const u = Te(i), { gutters: d, registerCell: p } = Ut(), y = useRef(null), m = qe(y, r);
+	return ne(() => {
+		const f = y.current;
+		if (f !== null) return p({
+			column: n,
+			columnSpan: o,
+			element: f,
+			id: u,
+			row: s,
+			rowSpan: l
+		});
+	}, [
+		n,
+		o,
+		u,
+		p,
+		s,
+		l
+	]), /* @__PURE__ */ jsx("div", {
+		...c,
+		className: t,
+		"data-cell": !0,
+		"data-testid": u,
+		id: u,
+		ref: m,
+		style: {
+			overflow: "auto",
+			...a,
+			minHeight: 0,
+			minWidth: 0,
+			gridColumn: ht(n, o, d.column),
+			gridRow: ht(s, l, d.row)
+		},
+		children: e
+	});
+}
+xn.displayName = "Cell";
+var We;
+function wn() {
+	return We === void 0 && (typeof matchMedia == "function" ? We = !!matchMedia("(pointer:coarse)").matches : We = !1), We;
+}
+function ot({ expandHitTargets: e, axis: t, rect: n }) {
+	const o = e ? wn() ? t.resizeTargetMinimumSize.coarse : t.resizeTargetMinimumSize.fine : 0;
+	if (n.width < o) {
+		const r = o - n.width;
+		n = new DOMRect(n.x - r / 2, n.y, n.width + r, n.height);
+	}
+	if (n.height < o) {
+		const r = o - n.height;
+		n = new DOMRect(n.x, n.y - r / 2, n.width, n.height + r);
+	}
+	return n;
+}
+function gt({ axis: e, cells: t, index: n, rect: o }) {
+	let r = [o];
+	for (const i of t) {
+		const s = e === "column" ? i.column : i.row;
+		const l = e === "column" ? i.columnSpan : i.rowSpan;
+		if (s >= n || s + l <= n) continue;
+		const a = i.element.getBoundingClientRect();
+		const c = e === "column" ? a.top : a.left;
+		const u = e === "column" ? a.bottom : a.right;
+		u <= c || (r = r.flatMap((d) => {
+			const p = e === "column" ? d.top : d.left;
+			const y = e === "column" ? d.bottom : d.right;
+			if (c >= y || u <= p) return [d];
+			const m = [];
+			const f = (S, h) => {
+				m.push(e === "column" ? new DOMRect(d.x, S, d.width, h - S) : new DOMRect(S, d.y, h - S, d.height));
+			};
+			return p < c && f(p, c), y > u && f(u, y), m;
+		}));
+	}
+	return r;
+}
+function zn({ axis: e, cells: t, crossTrackCount: n, expandHitTargets: o, resizeAxis: r, axisSize: i, includeDisabled: s, separatorPlacements: l }) {
+	const { items: a, separators: c } = r, u = a.length;
+	let d = -1;
+	let p = -1;
+	let y = 0;
+	if (a.forEach((b, w) => {
+		b.constraintProps.disabled || (y++, d === -1 && (d = w), p = w);
+	}), !s && y < 2) return [];
+	const m = (b) => s || b > d && b <= p;
+	const f = [];
+	const S = (b, w, v) => ({
+		axis: r,
+		axisSize: i,
+		items: [a[b - 1], a[b]],
+		rect: w,
+		separator: v
+	});
+	const h = (b, w) => {
+		let v;
+		for (const T of t) {
+			const O = e === "column" ? T.row : T.column;
+			const R = e === "column" ? T.rowSpan : T.columnSpan;
+			if (w === "start" ? O === b : O + R - 1 === b) {
+				const E = T.element.getBoundingClientRect();
+				if (w === "start") {
+					const P = e === "column" ? E.top : E.left;
+					v = v === void 0 ? P : Math.min(v, P);
+				} else {
+					const P = e === "column" ? E.bottom : E.right;
+					v = v === void 0 ? P : Math.max(v, P);
+				}
+			}
+		}
+		return v;
+	};
+	const g = /* @__PURE__ */ new Set();
+	for (const b of c) {
+		const w = l.get(b);
+		if (!w || w.index < 1 || w.index >= u || (g.add(w.index), !s && (b.disabled || b.element.hasAttribute("aria-disabled"))) || !m(w.index)) continue;
+		let v = b.element.getBoundingClientRect();
+		const { crossSpan: T, crossStart: O } = w, R = T === void 0 ? n : O + T;
+		let E = e === "column" ? v.top : v.left;
+		let P = e === "column" ? v.bottom : v.right;
+		if (O > 0) {
+			const z = h(O - 1, "end");
+			z !== void 0 && z < E && (E = z);
+		}
+		if (R < n) {
+			const z = h(R, "start");
+			z !== void 0 && z > P && (P = z);
+		}
+		v = e === "column" ? new DOMRect(v.x, E, v.width, P - E) : new DOMRect(E, v.y, P - E, v.height), v = ot({
+			expandHitTargets: o,
+			axis: r,
+			rect: v
+		}), s ? f.push(S(w.index, v, b)) : gt({
+			axis: e,
+			cells: t,
+			index: w.index,
+			rect: v
+		}).forEach((z) => {
+			f.push(S(w.index, z, b));
+		});
+	}
+	const I = (b, w) => {
+		gt({
+			axis: e,
+			cells: t,
+			index: b,
+			rect: ot({
+				expandHitTargets: o,
+				axis: r,
+				rect: w
+			})
+		}).forEach((v) => {
+			f.push(S(b, v));
+		});
+	};
+	const x = Array.from({ length: n }, () => new Array(u));
+	for (const b of t) {
+		const [w, v, T, O] = e === "column" ? [
+			b.column,
+			b.columnSpan,
+			b.row,
+			b.rowSpan
+		] : [
+			b.row,
+			b.rowSpan,
+			b.column,
+			b.columnSpan
+		];
+		for (let R = Math.max(0, T); R < Math.min(n, T + O); R++) for (let E = Math.max(0, w); E < Math.min(u, w + v); E++) x[R][E] ??= b;
+	}
+	const C = /* @__PURE__ */ new Map();
+	const A = (b) => {
+		let w = C.get(b);
+		if (!w) {
+			const v = b.element.getBoundingClientRect();
+			w = e === "column" ? {
+				crossEnd: v.bottom,
+				crossStart: v.top,
+				end: v.right,
+				start: v.left
+			} : {
+				crossEnd: v.right,
+				crossStart: v.left,
+				end: v.bottom,
+				start: v.top
+			}, C.set(b, w);
+		}
+		return w;
+	};
+	const N = ({ crossEnd: b, crossStart: w, end: v, start: T }) => e === "column" ? new DOMRect(T, w, v - T, b - w) : new DOMRect(w, T, b - w, v - T);
+	for (let b = 1; b < u; b++) {
+		if (g.has(b) || !m(b)) continue;
+		let w;
+		for (let v = 0; v < n; v++) {
+			const T = x[v][b - 1];
+			const O = x[v][b];
+			let R;
+			if ((T || O) && T !== O) {
+				const E = T ? A(T) : void 0;
+				const P = O ? A(O) : void 0;
+				const z = E?.end ?? P.start;
+				const M = P?.start ?? E.end;
+				const q = Math.max(E?.crossStart ?? -1 / 0, P?.crossStart ?? -1 / 0);
+				const J = Math.min(E?.crossEnd ?? 1 / 0, P?.crossEnd ?? 1 / 0);
+				R = {
+					crossEnd: Math.max(q, J),
+					crossStart: q,
+					end: Math.max(z, M),
+					start: Math.min(z, M)
+				};
+			}
+			R ? w = w ? {
+				crossEnd: Math.max(w.crossEnd, R.crossEnd),
+				crossStart: Math.min(w.crossStart, R.crossStart),
+				end: Math.max(w.end, R.end),
+				start: Math.min(w.start, R.start)
+			} : R : w && (I(b, N(w)), w = void 0);
+		}
+		w && I(b, N(w));
+	}
+	return f;
+}
+function le(e) {
+	const t = parseFloat(e ?? "");
+	return Number.isFinite(t) ? t : 0;
+}
+function In({ axis: e, element: t, gutterSizes: n, hasGutters: o, layout: r, trackIds: i }) {
+	const s = i.length;
+	const l = o ? s * 2 - 1 : s;
+	const a = t.ownerDocument.defaultView?.getComputedStyle(t);
+	const c = e === "column" ? a?.gridTemplateColumns : a?.gridTemplateRows;
+	if (c) {
+		const f = c.trim().split(/\s+/);
+		if (f.length === l && f.every((S) => /^-?[\d.]+px$/.test(S))) {
+			const S = i.map((h, g) => le(f[o ? g * 2 : g]));
+			return {
+				availableSize: S.reduce((h, g) => h + g, 0),
+				trackSizes: S
+			};
+		}
+	}
+	const u = e === "column" ? t.offsetWidth : t.offsetHeight;
+	const d = e === "column" ? le(a?.paddingLeft) + le(a?.paddingRight) + le(a?.borderLeftWidth) + le(a?.borderRightWidth) : le(a?.paddingTop) + le(a?.paddingBottom) + le(a?.borderTopWidth) + le(a?.borderBottomWidth);
+	const p = le(e === "column" ? a?.columnGap : a?.rowGap);
+	const y = n.reduce((f, S) => f + S, 0);
+	const m = Math.max(0, u - d - p * Math.max(0, l - 1) - y);
+	return {
+		availableSize: m,
+		trackSizes: i.map((f) => r && r[f] !== void 0 ? r[f] / 100 * m : m / s)
+	};
+}
+function Wt(e) {
+	switch (typeof e) {
+		case "number": return [e, "px"];
+		case "string": {
+			const t = parseFloat(e);
+			return e.endsWith("%") ? [t, "%"] : e.endsWith("px") ? [t, "px"] : e.endsWith("rem") ? [t, "rem"] : e.endsWith("em") ? [t, "em"] : e.endsWith("vh") ? [t, "vh"] : e.endsWith("vw") ? [t, "vw"] : [t, "%"];
+		}
+	}
+}
+var Yt = class {
+	#e = {};
+	addListener(t, n) {
+		const o = this.#e[t];
+		return o === void 0 ? this.#e[t] = [n] : o.includes(n) || o.push(n), () => {
+			this.removeListener(t, n);
+		};
+	}
+	emit(t, n) {
+		const o = this.#e[t];
+		if (o !== void 0) if (o.length === 1) o[0].call(null, n);
+		else {
+			let r = !1;
+			let i = null;
+			const s = Array.from(o);
+			for (let l = 0; l < s.length; l++) {
+				const a = s[l];
+				try {
+					a.call(null, n);
+				} catch (c) {
+					i === null && (r = !0, i = c);
+				}
+			}
+			if (r) throw i;
+		}
+	}
+	removeAllListeners() {
+		this.#e = {};
+	}
+	removeListener(t, n) {
+		const o = this.#e[t];
+		if (o !== void 0) {
+			const r = o.indexOf(n);
+			r >= 0 && o.splice(r, 1);
+		}
+	}
+};
+var V = {
+	cursorFlags: 0,
+	state: "inactive"
+};
+var lt = new Yt();
+function se() {
+	return V;
+}
+function Kt(e) {
+	return lt.addListener("change", e);
+}
+function Ln(e, t = [], n, o = !1) {
+	const r = V;
+	const i = { ...V };
+	i.cursorFlags = e, i.state === "active" && (i.didPointerMove ||= o, i.previews = t, n && (i.previewLayoutMap = n)), V = i, lt.emit("change", {
+		prev: r,
+		next: i
+	});
+}
+function de(e) {
+	const t = V;
+	V = e, t.state === "active" && e.state !== "active" && t.didPointerMove && t.hitRegions.forEach(({ separator: n }) => {
+		n && n.element.ownerDocument.activeElement === n.element && n.element.blur();
+	}), lt.emit("change", {
+		prev: t,
+		next: e
+	});
+}
+function Cn(e) {
+	V.state !== "active" || !V.previews.some((t) => t.separator === e) || de({
+		...V,
+		previews: V.previews.map((t) => t.separator === e ? { ...t } : t)
+	});
+}
+function Rn(e) {
+	if (V.state === "inactive") return !1;
+	const t = V.hitRegions.filter((o) => o.axis !== e);
+	const n = V.state === "active" && V.previews.some((o) => o.axis === e);
+	if (t.length === V.hitRegions.length && !n) return !1;
+	if (t.length === 0) de({
+		cursorFlags: 0,
+		state: "inactive"
+	});
+	else if (V.state === "active") {
+		const o = new Map(V.initialLayoutMap);
+		const r = new Map(V.previewLayoutMap);
+		o.delete(e), r.delete(e), de({
+			...V,
+			cursorFlags: 0,
+			hitRegions: t,
+			initialLayoutMap: o,
+			previewLayoutMap: r,
+			previews: V.previews.filter((i) => i.axis !== e)
+		});
+	} else de({
+		...V,
+		hitRegions: t
+	});
+	return !0;
+}
+var Mn = (e) => e;
+var tt = () => {};
+var Xt = 1;
+var Jt = 2;
+var Zt = 4;
+var Qt = 8;
+var yt = 3;
+var St = 12;
+var Ye;
+function vt() {
+	return Ye === void 0 && (Ye = !1, typeof window < "u" && (window.navigator.userAgent.includes("Chrome") || window.navigator.userAgent.includes("Firefox")) && (Ye = !0)), Ye;
+}
+function En({ cursorFlags: e, axes: t, state: n }) {
+	let o = 0;
+	let r = 0;
+	switch (n) {
+		case "active":
+		case "hover": t.forEach((i) => {
+			if (!i.mutableState.disableCursor) switch (i.orientation) {
+				case "horizontal":
+					o++;
+					break;
+				case "vertical": r++;
+			}
+		});
+	}
+	if (!(o === 0 && r === 0)) {
+		switch (n) {
+			case "active": if (e && vt()) {
+				const i = (e & Xt) !== 0;
+				const s = (e & Jt) !== 0;
+				const l = (e & Zt) !== 0;
+				const a = (e & Qt) !== 0;
+				if (i) return l ? "se-resize" : a ? "ne-resize" : "e-resize";
+				if (s) return l ? "sw-resize" : a ? "nw-resize" : "w-resize";
+				if (l) return "s-resize";
+				if (a) return "n-resize";
+			}
+		}
+		return vt() ? o > 0 && r > 0 ? "move" : o > 0 ? "ew-resize" : "ns-resize" : o > 0 && r > 0 ? "grab" : o > 0 ? "col-resize" : "row-resize";
+	}
+}
+var bt = /* @__PURE__ */ new WeakMap();
+function Ve(e) {
+	if (!e.defaultView || !e.adoptedStyleSheets) return;
+	let { prevStyle: t, styleSheet: n } = bt.get(e) ?? {};
+	n === void 0 && (n = new e.defaultView.CSSStyleSheet(), e.adoptedStyleSheets && (Object.isExtensible(e.adoptedStyleSheets) ? e.adoptedStyleSheets.push(n) : e.adoptedStyleSheets = [...e.adoptedStyleSheets, n]));
+	const o = se();
+	switch (o.state) {
+		case "active":
+		case "hover": {
+			const r = En({
+				cursorFlags: o.cursorFlags,
+				axes: o.hitRegions.map((s) => s.axis),
+				state: o.state
+			});
+			const i = `*, *:hover {cursor: ${r} !important; }`;
+			if (t === i) return;
+			t = i, r ? n.cssRules.length === 0 ? n.insertRule(i) : n.replaceSync(i) : n.cssRules.length === 1 && n.deleteRule(0);
+			break;
+		}
+		case "inactive": t = void 0, n.cssRules.length === 1 && n.deleteRule(0);
+	}
+	bt.set(e, {
+		prevStyle: t,
+		styleSheet: n
+	});
+}
+function ke({ axis: e }) {
+	const { layoutStrategy: t, orientation: n, items: o } = e;
+	return t ? t.calculateAvailableSize() : o.reduce((r, i) => (r += n === "horizontal" ? i.element.offsetWidth : i.element.offsetHeight, r), 0);
+}
+function ct(e, t) {
+	const n = e.compareDocumentPosition(t);
+	return n & Node.DOCUMENT_POSITION_DISCONNECTED ? 0 : n & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : n & Node.DOCUMENT_POSITION_PRECEDING ? 1 : 0;
+}
+function Ne(e, t) {
+	return Array.from(t).sort((n, o) => {
+		const r = e === "horizontal" ? Pn(n, o) : kn(n, o);
+		return r !== 0 ? r : ct(n.element, o.element);
+	});
+}
+function Pn(e, t) {
+	const n = e.element.offsetLeft - t.element.offsetLeft;
+	return n !== 0 ? n : e.element.offsetWidth - t.element.offsetWidth;
+}
+function kn(e, t) {
+	const n = e.element.offsetTop - t.element.offsetTop;
+	return n !== 0 ? n : e.element.offsetHeight - t.element.offsetHeight;
+}
+function rt(e) {
+	return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.ELEMENT_NODE;
+}
+function en(e, t) {
+	return {
+		x: e.x >= t.left && e.x <= t.right ? 0 : Math.min(Math.abs(e.x - t.left), Math.abs(e.x - t.right)),
+		y: e.y >= t.top && e.y <= t.bottom ? 0 : Math.min(Math.abs(e.y - t.top), Math.abs(e.y - t.bottom))
+	};
+}
+function Tn({ orientation: e, rects: t, targetRect: n }) {
+	const o = {
+		x: n.x + n.width / 2,
+		y: n.y + n.height / 2
+	};
+	let r;
+	let i = Number.MAX_VALUE;
+	for (const s of t) {
+		const { x: l, y: a } = en(o, s), c = e === "horizontal" ? l : a;
+		c < i && (i = c, r = s);
+	}
+	return D(r, "No rect found"), r;
+}
+function ut({ expandHitTargets: e = !0, axis: t, includeDisabled: n = !1 }) {
+	if (t.layoutStrategy) return t.layoutStrategy.calculateHitRegions({
+		expandHitTargets: e,
+		axis: t,
+		includeDisabled: n
+	});
+	const { element: o, orientation: r, items: i, separators: s } = t, l = Ne(r, Array.from(o.children).filter(rt).filter((h) => !h.hasAttribute("data-resize-preview")).map((h) => ({ element: h }))).map(({ element: h }) => h), a = [];
+	let c = !1;
+	let u = !1;
+	let d = -1;
+	let p;
+	let y = -1;
+	let m = 0;
+	let f;
+	let S = [];
+	{
+		let h = -1;
+		for (const g of l) g.hasAttribute("data-panel") && (h++, g.hasAttribute("data-disabled") || (m++, d === -1 && (d = h), y = h));
+	}
+	if (n || m > 1) {
+		let h = -1;
+		for (const g of l) if (g.hasAttribute("data-panel")) {
+			h++;
+			const I = i.find((x) => x.element === g);
+			if (I) {
+				if (f) {
+					const x = f.element.getBoundingClientRect();
+					const C = g.getBoundingClientRect();
+					let A;
+					if (u) {
+						const N = r === "horizontal" ? new DOMRect(x.right, x.top, 0, x.height) : new DOMRect(x.left, x.bottom, x.width, 0);
+						const b = r === "horizontal" ? new DOMRect(C.left, C.top, 0, C.height) : new DOMRect(C.left, C.top, C.width, 0);
+						switch (S.length) {
+							case 0:
+								A = [N, b];
+								break;
+							case 1: {
+								const w = S[0];
+								A = [w, Tn({
+									orientation: r,
+									rects: [x, C],
+									targetRect: w.element.getBoundingClientRect()
+								}) === x ? b : N];
+								break;
+							}
+							default: A = S;
+						}
+					} else S.length ? A = S : A = [r === "horizontal" ? new DOMRect(x.right, C.top, C.left - x.right, C.height) : new DOMRect(C.left, x.bottom, C.width, C.top - x.bottom)];
+					for (const N of A) {
+						const b = ot({
+							expandHitTargets: e,
+							axis: t,
+							rect: "width" in N ? N : N.element.getBoundingClientRect()
+						});
+						(n || !c && !(h <= d || h > y)) && (p ??= ke({ axis: t }), a.push({
+							axis: t,
+							axisSize: p,
+							items: [f, I],
+							separator: "width" in N ? void 0 : N,
+							rect: b
+						})), c = !1;
+					}
+				}
+				u = !1, f = I, S = [];
+			}
+		} else if (g.hasAttribute("data-separator")) {
+			g.ariaDisabled !== null && (c = !0);
+			const I = s.find((x) => x.element === g);
+			I ? S.push(I) : (f = void 0, S = []);
+		} else u = !0;
+	}
+	return a;
+}
+function $n(e, t) {
+	const n = getComputedStyle(e);
+	return t * parseFloat(n.fontSize);
+}
+function An(e, t) {
+	const n = getComputedStyle(e.ownerDocument.documentElement);
+	return t * parseFloat(n.fontSize);
+}
+function Dn(e) {
+	return e / 100 * window.innerHeight;
+}
+function On(e) {
+	return e / 100 * window.innerWidth;
+}
+function Ce({ axisSize: e, itemElement: t, styleProp: n }) {
+	let o;
+	const [r, i] = Wt(n);
+	switch (i) {
+		case "%":
+			o = r / 100 * e;
+			break;
+		case "px":
+			o = r;
+			break;
+		case "rem":
+			o = An(t, r);
+			break;
+		case "em":
+			o = $n(t, r);
+			break;
+		case "vh":
+			o = Dn(r);
+			break;
+		case "vw": o = On(r);
+	}
+	return o;
+}
+function X(e) {
+	return parseFloat(e.toFixed(3));
+}
+function it(e) {
+	const { items: t } = e, n = ke({ axis: e });
+	return n === 0 ? t.map((o) => ({
+		groupResizeBehavior: o.constraintProps.groupResizeBehavior,
+		collapsedSize: 0,
+		collapsible: o.constraintProps.collapsible === !0,
+		defaultSize: void 0,
+		disabled: o.constraintProps.disabled,
+		minSize: 0,
+		maxSize: 100,
+		itemId: o.id
+	})) : t.map((o) => {
+		const { element: r, constraintProps: i } = o;
+		let s = 0;
+		if (i.collapsedSize !== void 0) s = X(Ce({
+			axisSize: n,
+			itemElement: r,
+			styleProp: i.collapsedSize
+		}) / n * 100);
+		let l;
+		if (i.collapsedThreshold !== void 0) l = X(Ce({
+			axisSize: n,
+			itemElement: r,
+			styleProp: i.collapsedThreshold
+		}) / n * 100);
+		let a;
+		if (i.defaultSize !== void 0) a = X(Ce({
+			axisSize: n,
+			itemElement: r,
+			styleProp: i.defaultSize
+		}) / n * 100);
+		let c = 0;
+		if (i.minSize !== void 0) c = X(Ce({
+			axisSize: n,
+			itemElement: r,
+			styleProp: i.minSize
+		}) / n * 100);
+		let u = 100;
+		if (i.maxSize !== void 0) u = X(Ce({
+			axisSize: n,
+			itemElement: r,
+			styleProp: i.maxSize
+		}) / n * 100);
+		return {
+			groupResizeBehavior: i.groupResizeBehavior,
+			collapsedSize: s,
+			collapsedThreshold: l,
+			collapsible: i.collapsible === !0,
+			defaultSize: a,
+			disabled: i.disabled,
+			minSize: c,
+			maxSize: u,
+			itemId: o.id
+		};
+	});
+}
+var ue = /* @__PURE__ */ new Map();
+var tn = new Yt();
+function Nn(e) {
+	ue = new Map(ue), ue.delete(e);
+}
+function Me(e, t) {
+	for (const [n] of ue) if (n.id === e) return n;
+}
+function ae(e, t) {
+	for (const [n, o] of ue) if (n.id === e) return o;
+	if (t) throw Error(`Could not find data for Group with id ${e}`);
+}
+function he() {
+	return ue;
+}
+function _e(e, t) {
+	return tn.addListener("axisChange", (n) => {
+		n.axis.id === e && t(n);
+	});
+}
+function fe(e, t, n) {
+	const o = ue.get(e);
+	ue = new Map(ue), ue.set(e, t), tn.emit("axisChange", {
+		axis: e,
+		isUserInteraction: n?.isUserInteraction === !0,
+		prev: o,
+		next: t
+	});
+}
+function Gn(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] != t[n]) return !1;
+	return !0;
+}
+function Y(e, t, n = 0) {
+	return Math.abs(X(e) - X(t)) <= n;
+}
+function ce(e, t) {
+	return Y(e, t) ? 0 : e > t ? 1 : -1;
+}
+function Ee({ overrideDisabledItems: e, itemConstraints: t, prevSize: n, size: o }) {
+	const { collapsedSize: r = 0, collapsedThreshold: i, collapsible: s, disabled: l, maxSize: a = 100, minSize: c = 0 } = t;
+	if (l && !e) return n;
+	if (ce(o, c) < 0) if (s) {
+		const u = i ?? (c - r) / 2;
+		const d = ce(n, r) <= 0;
+		const p = d ? r + u : c - u;
+		const y = ce(o, p);
+		ce(o, r) <= 0 || y < 0 || i !== void 0 && d && y === 0 ? o = r : o = c;
+	} else o = c;
+	return o = Math.min(a, o), o = X(o), o;
+}
+function Fe({ delta: e, initialLayout: t, itemConstraints: n, pivotIndices: o, prevLayout: r, trigger: i }) {
+	if (Y(e, 0)) return t;
+	const s = i === "imperative-api", l = n.map(({ itemId: m }) => t[m]), a = n.map(({ itemId: m }) => r[m]), c = [...l], [u, d] = o;
+	D(u != null, "Invalid first pivot index"), D(d != null, "Invalid second pivot index");
+	let p = 0;
+	switch (i) {
+		case "keyboard":
+			{
+				const m = e < 0 ? d : u;
+				const f = n[m];
+				D(f, `Panel constraints not found for index ${m}`);
+				const { collapsedSize: S = 0, collapsible: h, minSize: g = 0 } = f;
+				if (h) {
+					const I = l[m];
+					if (D(I != null, `Previous layout not found for panel index ${m}`), Y(I, S)) {
+						const x = g - I;
+						ce(x, Math.abs(e)) > 0 && (e = e < 0 ? 0 - x : x);
+					}
+				}
+			}
+			{
+				const m = e < 0 ? u : d;
+				const f = n[m];
+				D(f, `No panel constraints found for index ${m}`);
+				const { collapsedSize: S = 0, collapsible: h, minSize: g = 0 } = f;
+				if (h) {
+					const I = l[m];
+					if (D(I != null, `Previous layout not found for panel index ${m}`), Y(I, g)) {
+						const x = I - S;
+						ce(x, Math.abs(e)) > 0 && (e = e < 0 ? 0 - x : x);
+					}
+				}
+			}
+			break;
+		default: {
+			const m = e < 0 ? d : u;
+			const f = n[m];
+			D(f, `Panel constraints not found for index ${m}`);
+			const S = l[m], { collapsedSize: h, collapsedThreshold: g, collapsible: I, minSize: x } = f;
+			if (I && ce(S, x) < 0) {
+				const C = x - h;
+				const A = g ?? C / 2;
+				if (ce(S + Math.abs(e), x) < 0) {
+					const b = ce(Math.abs(e), A);
+					b > 0 || b === 0 && g === void 0 && e < 0 ? e = e < 0 ? -C : C : e = 0;
+				}
+			}
+			break;
+		}
+	}
+	{
+		const m = e < 0 ? 1 : -1;
+		let f = e < 0 ? d : u;
+		let S = 0;
+		for (;;) {
+			const g = l[f];
+			D(g != null, `Previous layout not found for panel index ${f}`);
+			const x = Ee({
+				overrideDisabledItems: s,
+				itemConstraints: n[f],
+				prevSize: g,
+				size: 100
+			}) - g;
+			if (S += x, f += m, f < 0 || f >= n.length) break;
+		}
+		const h = Math.min(Math.abs(e), Math.abs(S));
+		e = e < 0 ? 0 - h : h;
+	}
+	{
+		let f = e < 0 ? u : d;
+		for (; f >= 0 && f < n.length;) {
+			const S = Math.abs(e) - Math.abs(p);
+			const h = l[f];
+			D(h != null, `Previous layout not found for panel index ${f}`);
+			const g = h - S;
+			const I = Ee({
+				overrideDisabledItems: s,
+				itemConstraints: n[f],
+				prevSize: h,
+				size: g
+			});
+			if (!Y(h, I) && (p += h - I, c[f] = I, p.toFixed(3).localeCompare(Math.abs(e).toFixed(3), void 0, { numeric: !0 }) >= 0)) break;
+			e < 0 ? f-- : f++;
+		}
+	}
+	if (Gn(a, c)) return r;
+	{
+		const m = e < 0 ? d : u;
+		const f = l[m];
+		D(f != null, `Previous layout not found for panel index ${m}`);
+		const S = f + p;
+		const h = Ee({
+			overrideDisabledItems: s,
+			itemConstraints: n[m],
+			prevSize: f,
+			size: S
+		});
+		if (c[m] = h, !Y(h, S)) {
+			let g = S - h;
+			let x = e < 0 ? d : u;
+			for (; x >= 0 && x < n.length;) {
+				const C = c[x];
+				D(C != null, `Previous layout not found for panel index ${x}`);
+				const A = C + g;
+				const N = Ee({
+					overrideDisabledItems: s,
+					itemConstraints: n[x],
+					prevSize: C,
+					size: A
+				});
+				if (Y(C, N) || (g -= N - C, c[x] = N), Y(g, 0)) break;
+				e > 0 ? x-- : x++;
+			}
+		}
+	}
+	return Y(Object.values(c).reduce((m, f) => f + m, 0), 100, .1) ? c.reduce((m, f, S) => (m[n[S].itemId] = f, m), {}) : r;
+}
+function ie(e, t) {
+	if (Object.keys(e).length !== Object.keys(t).length) return !1;
+	for (const n in e) if (t[n] === void 0 || ce(e[n], t[n]) !== 0) return !1;
+	return !0;
+}
+function dt({ commit: e, document: t, event: n, hitRegions: o, initialLayoutMap: r, mountedAxes: i, pointerDownAtPoint: s, prevCursorFlags: l }) {
+	let a = 0;
+	const c = se();
+	let u = c.state === "active" ? c.previews : [];
+	const d = new Map(c.state === "active" ? c.previewLayoutMap : void 0);
+	o.forEach((m) => {
+		const { axis: f, axisSize: S } = m, { orientation: h, items: g } = f;
+		if (e && f.resizePreviewMode !== "separator") return;
+		const { disableCursor: I } = f.mutableState;
+		let x = 0;
+		s ? h === "horizontal" ? x = (n.clientX - s.x) / S * 100 : x = (n.clientY - s.y) / S * 100 : h === "horizontal" ? x = n.clientX < 0 ? -100 : 100 : x = n.clientY < 0 ? -100 : 100;
+		const C = r.get(f);
+		const A = i.get(f);
+		if (!C || !A) return;
+		const { defaultLayoutDeferred: N, derivedItemConstraints: b, axisSize: w, layout: v, separatorToItems: T } = A;
+		if (b && v && T) {
+			const O = f.resizePreviewMode === "separator" ? d.get(f) ?? v : v;
+			const R = Fe({
+				delta: x,
+				initialLayout: C,
+				itemConstraints: b,
+				pivotIndices: m.items.map((E) => g.indexOf(E)),
+				prevLayout: O,
+				trigger: "mouse-or-touch"
+			});
+			if (f.resizePreviewMode === "separator" && !e && !ie(R, O)) {
+				d.set(f, R);
+				let E = 0;
+				const P = g.map((z) => (E += R[z.id] - C[z.id], E * (S / 100)));
+				u = u.map((z) => {
+					if (z.axis !== f) return z;
+					const M = P[z.itemIndex];
+					return M === z.offset ? z : {
+						...z,
+						offset: M
+					};
+				});
+			}
+			if (ie(R, O) && x !== 0 && !I) switch (h) {
+				case "horizontal":
+					a |= x < 0 ? Xt : Jt;
+					break;
+				case "vertical": a |= x < 0 ? Zt : Qt;
+			}
+			(f.resizePreviewMode !== "separator" || e) && !ie(R, v) && fe(m.axis, {
+				defaultLayoutDeferred: N,
+				derivedItemConstraints: b,
+				axisSize: w,
+				layout: R,
+				requestedAxisSize: w,
+				requestedLayout: R,
+				separatorToItems: T
+			});
+		}
+	});
+	let p = 0;
+	n.movementX === 0 ? p |= l & yt : p |= a & yt, n.movementY === 0 ? p |= l & St : p |= a & St;
+	const y = c.state === "active" && (n.clientX !== c.pointerDownAtPoint.x || n.clientY !== c.pointerDownAtPoint.y);
+	Ln(p, u, d, y), Ve(t);
+}
+function nn(e, t) {
+	const n = se();
+	const o = he();
+	let r = !1;
+	switch (n.state) {
+		case "active": dt({
+			commit: !0,
+			document: e,
+			event: t,
+			hitRegions: n.hitRegions,
+			initialLayoutMap: n.initialLayoutMap,
+			mountedAxes: o,
+			pointerDownAtPoint: n.pointerDownAtPoint,
+			prevCursorFlags: n.cursorFlags
+		}), de({
+			cursorFlags: 0,
+			state: "inactive"
+		}), n.hitRegions.length > 0 && (Ve(e), r = !0, n.hitRegions.forEach((i) => {
+			if (!o.has(i.axis)) return;
+			const s = ae(i.axis.id, !0);
+			fe(i.axis, s, { isUserInteraction: !0 });
+		}));
+	}
+	return r;
+}
+function xt(e) {
+	e.defaultPrevented || nn(e.currentTarget, e);
+}
+function _n(e, t, n) {
+	let o;
+	let r = {
+		x: 1 / 0,
+		y: 1 / 0
+	};
+	for (const i of t) {
+		const s = en(n, i.rect);
+		switch (e) {
+			case "horizontal":
+				(s.x < r.x || s.x === r.x && s.y <= r.y) && (o = i, r = s);
+				break;
+			case "vertical": (s.y < r.y || s.y === r.y && s.x <= r.x) && (o = i, r = s);
+		}
+	}
+	return o ? {
+		distance: r,
+		hitRegion: o
+	} : void 0;
+}
+function Fn(e) {
+	return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+}
+function Bn(e, t) {
+	if (e === t) throw new Error("Cannot compare node with itself");
+	const n = {
+		a: It(e),
+		b: It(t)
+	};
+	let o;
+	for (; n.a.at(-1) === n.b.at(-1);) o = n.a.pop(), n.b.pop();
+	D(o, "Stacking order can only be calculated for elements with a common ancestor");
+	const r = {
+		a: zt(wt(n.a)),
+		b: zt(wt(n.b))
+	};
+	if (r.a === r.b) {
+		const i = o.childNodes;
+		const s = {
+			a: n.a.at(-1),
+			b: n.b.at(-1)
+		};
+		let l = i.length;
+		for (; l--;) {
+			const a = i[l];
+			if (a === s.a) return 1;
+			if (a === s.b) return -1;
+		}
+	}
+	return Math.sign(r.a - r.b);
+}
+var qn = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function Vn(e) {
+	const t = getComputedStyle(on(e) ?? e).display;
+	return t === "flex" || t === "inline-flex";
+}
+function Hn(e) {
+	const t = getComputedStyle(e);
+	return !!(t.position === "fixed" || t.zIndex !== "auto" && (t.position !== "static" || Vn(e)) || +t.opacity < 1 || "transform" in t && t.transform !== "none" || "webkitTransform" in t && t.webkitTransform !== "none" || "mixBlendMode" in t && t.mixBlendMode !== "normal" || "filter" in t && t.filter !== "none" || "webkitFilter" in t && t.webkitFilter !== "none" || "isolation" in t && t.isolation === "isolate" || qn.test(t.willChange) || t.webkitOverflowScrolling === "touch");
+}
+function wt(e) {
+	let t = e.length;
+	for (; t--;) {
+		const n = e[t];
+		if (D(n, "Missing node"), Hn(n)) return n;
+	}
+	return null;
+}
+function zt(e) {
+	return e && Number(getComputedStyle(e).zIndex) || 0;
+}
+function It(e) {
+	const t = [];
+	for (; e;) t.push(e), e = on(e);
+	return t;
+}
+function on(e) {
+	const { parentNode: t } = e;
+	return Fn(t) ? t.host : t;
+}
+function jn(e, t) {
+	return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+}
+function Un(e) {
+	try {
+		return e.matches(":modal");
+	} catch {
+		return !1;
+	}
+}
+function Wn({ axisElement: e, hitRegion: t, pointerEventTarget: n }) {
+	if (rt(n)) {
+		const o = n.closest("dialog");
+		if (o && !o.contains(e) && Un(o)) return !1;
+	}
+	if (!rt(n) || n.contains(e) || e.contains(n)) return !0;
+	if (Bn(n, e) > 0) {
+		let o = n;
+		for (; o;) {
+			if (o.contains(e)) return !0;
+			if (jn(o.getBoundingClientRect(), t)) return !1;
+			o = o.parentElement;
+		}
+	}
+	return !0;
+}
+function ft(e, t) {
+	const n = [];
+	return t.forEach((o, r) => {
+		if (r.disabled) return;
+		const i = ut({ axis: r });
+		const s = _n(r.orientation, i, {
+			x: e.clientX,
+			y: e.clientY
+		});
+		s && s.distance.x <= 0 && s.distance.y <= 0 && Wn({
+			axisElement: r.element,
+			hitRegion: s.hitRegion.rect,
+			pointerEventTarget: e.target
+		}) && n.push(s.hitRegion);
+	}), n;
+}
+function ye({ layout: e, itemConstraints: t }) {
+	const n = t.map(({ itemId: s }) => e[s]);
+	const o = [...n];
+	const r = o.reduce((s, l) => s + l, 0);
+	if (Object.keys(e).length !== t.length) throw Error(`Invalid ${t.length} panel layout: ${Object.values(e).map((s) => `${s}%`).join(", ")}`);
+	if (!Y(r, 100) && o.length > 0) for (let s = 0; s < t.length; s++) {
+		const l = o[s];
+		D(l != null, `No layout data found for index ${s}`);
+		const a = 100 / r * l;
+		o[s] = a;
+	}
+	let i = 0;
+	for (let s = 0; s < t.length; s++) {
+		const l = n[s];
+		D(l != null, `No layout data found for index ${s}`);
+		const a = o[s];
+		D(a != null, `No layout data found for index ${s}`);
+		const c = Ee({
+			overrideDisabledItems: !0,
+			itemConstraints: t[s],
+			prevSize: l,
+			size: a
+		});
+		a != c && (i += a - c, o[s] = c);
+	}
+	if (!Y(i, 0)) for (let s = 0; s < t.length; s++) {
+		const l = o[s];
+		D(l != null, `No layout data found for index ${s}`);
+		const a = l + i;
+		const c = Ee({
+			overrideDisabledItems: !0,
+			itemConstraints: t[s],
+			prevSize: l,
+			size: a
+		});
+		if (l !== c && (i -= c - l, o[s] = c, Y(i, 0))) break;
+	}
+	return o.reduce((s, l, a) => (s[t[a].itemId] = l, s), {});
+}
+function mt({ axisId: e, itemId: t }) {
+	const n = () => {
+		const a = he();
+		for (const [c, { defaultLayoutDeferred: u, derivedItemConstraints: d, layout: p, axisSize: y, separatorToItems: m }] of a) if (c.id === e) return {
+			defaultLayoutDeferred: u,
+			derivedItemConstraints: d,
+			axis: c,
+			axisSize: y,
+			layout: p,
+			separatorToItems: m
+		};
+		throw Error(`Group ${e} not found`);
+	};
+	const o = () => {
+		const a = n().derivedItemConstraints.find((c) => c.itemId === t);
+		if (a !== void 0) return a;
+		throw Error(`Panel constraints not found for Panel ${t}`);
+	};
+	const r = () => {
+		const a = n().axis.items.find((c) => c.id === t);
+		if (a !== void 0) return a;
+		throw Error(`Layout not found for Panel ${t}`);
+	};
+	const i = () => {
+		const a = n().layout[t];
+		if (a !== void 0) return a;
+		throw Error(`Layout not found for Panel ${t}`);
+	};
+	const s = ({ nextSize: a, items: c, prevLayout: u, derivedItemConstraints: d }) => {
+		const p = i();
+		const y = c.findIndex((h) => h.id === t);
+		const m = y === 0;
+		const f = y === c.length - 1;
+		if (f && a < p && (m || c.slice(0, y).every((h, g) => {
+			const I = d[g];
+			return I?.collapsible && Y(I.collapsedSize, u[I.itemId]);
+		}))) {
+			const h = c.slice(0, y).reduce((g, I) => g + u[I.id], 0);
+			return {
+				...u,
+				[t]: X(100 - h)
+			};
+		}
+		return Fe({
+			delta: f ? p - a : a - p,
+			initialLayout: u,
+			itemConstraints: d,
+			pivotIndices: f ? [y - 1, y] : [y, y + 1],
+			prevLayout: u,
+			trigger: "imperative-api"
+		});
+	};
+	const l = (a) => {
+		if (a === i()) return;
+		const { defaultLayoutDeferred: u, derivedItemConstraints: d, axis: p, axisSize: y, layout: m, separatorToItems: f } = n(), h = ye({
+			layout: s({
+				nextSize: a,
+				items: p.items,
+				prevLayout: m,
+				derivedItemConstraints: d
+			}),
+			itemConstraints: d
+		});
+		ie(m, h) || fe(p, {
+			defaultLayoutDeferred: u,
+			derivedItemConstraints: d,
+			axisSize: y,
+			layout: h,
+			requestedAxisSize: y,
+			requestedLayout: h,
+			separatorToItems: f
+		});
+	};
+	return {
+		collapse: () => {
+			const { collapsible: a, collapsedSize: c } = o(), { mutableValues: u } = r(), d = i();
+			a && d !== c && (u.expandToSize = d, l(c));
+		},
+		expand: () => {
+			const { collapsible: a, collapsedSize: c, minSize: u } = o(), { mutableValues: d } = r(), p = i();
+			if (a && p === c) {
+				let y = d.expandToSize ?? u;
+				y === 0 && (y = 1), l(y);
+			}
+		},
+		getSize: () => {
+			const { axis: a } = n(), c = i(), { element: u } = r();
+			return {
+				asPercentage: c,
+				inPixels: a.layoutStrategy ? a.layoutStrategy.getItemSizeInPixels(t) : a.orientation === "horizontal" ? u.offsetWidth : u.offsetHeight
+			};
+		},
+		isCollapsed: () => {
+			const { collapsible: a, collapsedSize: c } = o(), u = i();
+			return a && Y(c, u);
+		},
+		resize: (a) => {
+			const { axis: c } = n(), { element: u } = r(), d = ke({ axis: c }), y = X(Ce({
+				axisSize: d,
+				itemElement: u,
+				styleProp: a
+			}) / d * 100);
+			l(y);
+		}
+	};
+}
+function Lt(e) {
+	if (e.defaultPrevented) return;
+	ft(e, he()).forEach((o) => {
+		if (o.separator && !o.separator.disableDoubleClick) {
+			const r = o.items.find((i) => i.constraintProps.defaultSize !== void 0);
+			if (r) {
+				const i = r.constraintProps.defaultSize;
+				const s = mt({
+					axisId: o.axis.id,
+					itemId: r.id
+				});
+				s && i !== void 0 && (s.resize(i), e.preventDefault());
+			}
+		}
+	});
+}
+function rn(e) {
+	const t = he();
+	for (const [n] of t) if (n.separators.some((o) => o.element === e)) return n;
+	throw Error("Could not find parent Group for separator element");
+}
+function Ge({ axisId: e }) {
+	const t = () => {
+		const n = he();
+		for (const [o, r] of n) if (o.id === e) return {
+			axis: o,
+			...r
+		};
+		throw Error(`Could not find Group with id "${e}"`);
+	};
+	return {
+		getLayout() {
+			const { defaultLayoutDeferred: n, layout: o } = t();
+			return n ? {} : o;
+		},
+		setLayout(n) {
+			const { defaultLayoutDeferred: o, derivedItemConstraints: r, axis: i, axisSize: s, layout: l, separatorToItems: a } = t(), c = ye({
+				layout: n,
+				itemConstraints: r
+			});
+			return o ? l : (ie(l, c) || fe(i, {
+				defaultLayoutDeferred: o,
+				derivedItemConstraints: r,
+				axisSize: s,
+				layout: c,
+				requestedAxisSize: s,
+				requestedLayout: c,
+				separatorToItems: a
+			}), c);
+		}
+	};
+}
+function we(e, t) {
+	const n = rn(e);
+	const o = ae(n.id, !0);
+	const r = n.separators.find((d) => d.element === e);
+	D(r, "Matching separator not found");
+	const i = o.separatorToItems.get(r);
+	D(i, "Matching panels not found");
+	const s = i.map((d) => n.items.indexOf(d));
+	const a = Ge({ axisId: n.id }).getLayout();
+	const u = ye({
+		layout: Fe({
+			delta: t,
+			initialLayout: a,
+			itemConstraints: o.derivedItemConstraints,
+			pivotIndices: s,
+			prevLayout: a,
+			trigger: "keyboard"
+		}),
+		itemConstraints: o.derivedItemConstraints
+	});
+	ie(a, u) || fe(n, {
+		defaultLayoutDeferred: o.defaultLayoutDeferred,
+		derivedItemConstraints: o.derivedItemConstraints,
+		axisSize: o.axisSize,
+		layout: u,
+		requestedAxisSize: o.axisSize,
+		requestedLayout: u,
+		separatorToItems: o.separatorToItems
+	}, { isUserInteraction: !0 });
+}
+function Ct(e) {
+	if (e.defaultPrevented) return;
+	const t = e.currentTarget;
+	const n = rn(t);
+	if (!(n.disabled || n.separators.find((r) => r.element === t)?.disabled)) switch (e.key) {
+		case "ArrowDown":
+			e.preventDefault(), n.orientation === "vertical" && we(t, 5);
+			break;
+		case "ArrowLeft":
+			e.preventDefault(), n.orientation === "horizontal" && we(t, -5);
+			break;
+		case "ArrowRight":
+			e.preventDefault(), n.orientation === "horizontal" && we(t, 5);
+			break;
+		case "ArrowUp":
+			e.preventDefault(), n.orientation === "vertical" && we(t, -5);
+			break;
+		case "End":
+			e.preventDefault(), we(t, 100);
+			break;
+		case "Enter": {
+			e.preventDefault();
+			const { derivedItemConstraints: i, layout: s, separatorToItems: l } = ae(n.id, !0), a = n.separators.find((p) => p.element === t);
+			D(a, "Matching separator not found");
+			const c = l.get(a);
+			D(c, "Matching panels not found");
+			const u = c[0];
+			const d = i.find((p) => p.itemId === u.id);
+			if (D(d, "Panel metadata not found"), d.collapsible) {
+				const p = s[u.id];
+				we(t, (d.collapsedSize === p ? n.mutableState.expandedItemSizes[u.id] ?? d.minSize : d.collapsedSize) - p);
+			}
+			break;
+		}
+		case "F6": {
+			e.preventDefault();
+			const r = n.separators.map((a) => a.element);
+			const i = Array.from(r).findIndex((a) => a === e.currentTarget);
+			D(i !== null, "Index not found");
+			r[e.shiftKey ? i > 0 ? i - 1 : r.length - 1 : i + 1 < r.length ? i + 1 : 0].focus({ preventScroll: !0 });
+			break;
+		}
+		case "Home": e.preventDefault(), we(t, -100);
+	}
+}
+function Je(e) {
+	const t = se();
+	if (t.state !== "active") return !1;
+	const n = he();
+	return t.previewLayoutMap.forEach((o, r) => {
+		const i = n.get(r);
+		r.resizePreviewMode === "separator" && i && !ie(o, i.layout) && fe(r, {
+			...i,
+			layout: o,
+			requestedAxisSize: i.axisSize,
+			requestedLayout: o
+		});
+	}), de({
+		cursorFlags: 0,
+		state: "inactive"
+	}), t.hitRegions.forEach((o) => {
+		if (!n.has(o.axis)) return;
+		const r = ae(o.axis.id, !0);
+		fe(o.axis, r, { isUserInteraction: !0 });
+	}), Ve(e), !0;
+}
+function Rt(e) {
+	const t = se();
+	if (t.state !== "active") return;
+	const n = t.hitRegions.flatMap(({ separator: o }) => o ? [o.element] : []);
+	!n.some((o) => o === e.target) || n.some((o) => o.hasPointerCapture?.(e.pointerId)) || Je(e.currentTarget);
+}
+function Mt(e) {
+	Je(e.currentTarget);
+}
+function Yn(e, t) {
+	const { element: n, orientation: o, items: r } = e, i = n.getBoundingClientRect(), s = o === "horizontal";
+	return ut({
+		expandHitTargets: !1,
+		axis: e,
+		includeDisabled: !0
+	}).map(({ items: a, rect: c, separator: u }, d) => {
+		const p = r.indexOf(a[0]);
+		const y = s ? c.left + c.width / 2 : c.top + c.height / 2;
+		return {
+			active: t.some((f) => {
+				if (f.axis !== e || f.items[0] !== a[0]) return !1;
+				if (u || f.separator) return f.separator === u;
+				const S = s ? f.rect.left + f.rect.width / 2 : f.rect.top + f.rect.height / 2;
+				return Y(y, S);
+			}),
+			axis: e,
+			key: u ? `separator-${u.id}` : `panel-${a[0].id}-${d}`,
+			offset: 0,
+			itemIndex: p,
+			rect: new DOMRect((s && !u ? y : c.left) - i.left - n.clientLeft + n.scrollLeft, (!s && !u ? y : c.top) - i.top - n.clientTop + n.scrollTop, s && !u ? 0 : c.width, !s && !u ? 0 : c.height),
+			separator: u
+		};
+	});
+}
+function Et(e) {
+	if (e.defaultPrevented) return;
+	if (e.pointerType === "mouse" && e.button > 0) return;
+	const t = he();
+	const n = ft(e, t);
+	if (n.length === 0) return;
+	const o = /* @__PURE__ */ new Map();
+	let r = !1;
+	n.forEach((s) => {
+		s.separator && (r || (r = !0, s.separator.element.focus({
+			focusVisible: !1,
+			preventScroll: !0
+		})));
+		const l = t.get(s.axis);
+		l && o.set(s.axis, l.layout);
+	});
+	const i = Array.from(o.keys()).flatMap((s) => s.resizePreviewMode === "separator" ? Yn(s, n) : []);
+	de({
+		cursorFlags: 0,
+		didPointerMove: !1,
+		hitRegions: n,
+		initialLayoutMap: o,
+		pointerDownAtPoint: {
+			x: e.clientX,
+			y: e.clientY
+		},
+		previewLayoutMap: new Map(o),
+		previews: i,
+		state: "active"
+	}), e.preventDefault();
+}
+function Pt(e) {
+	const t = he();
+	const n = se();
+	switch (n.state) {
+		case "active": dt({
+			commit: !1,
+			document: e.currentTarget,
+			event: e,
+			hitRegions: n.hitRegions,
+			initialLayoutMap: n.initialLayoutMap,
+			mountedAxes: t,
+			prevCursorFlags: n.cursorFlags
+		});
+	}
+}
+function kt(e) {
+	if (e.defaultPrevented) return;
+	const t = se();
+	const n = he();
+	switch (t.state) {
+		case "active":
+			if (e.buttons === 0) {
+				Je(e.currentTarget);
+				return;
+			}
+			for (const o of t.hitRegions) if (o.separator) {
+				const { element: r } = o.separator;
+				r.isConnected && !r.hasPointerCapture?.(e.pointerId) && r.setPointerCapture?.(e.pointerId);
+			}
+			dt({
+				commit: !1,
+				document: e.currentTarget,
+				event: e,
+				hitRegions: t.hitRegions,
+				initialLayoutMap: t.initialLayoutMap,
+				mountedAxes: n,
+				pointerDownAtPoint: t.pointerDownAtPoint,
+				prevCursorFlags: t.cursorFlags
+			});
+			break;
+		default: {
+			const o = ft(e, n);
+			o.length === 0 ? t.state !== "inactive" && de({
+				cursorFlags: 0,
+				state: "inactive"
+			}) : de({
+				cursorFlags: 0,
+				hitRegions: o,
+				state: "hover"
+			}), Ve(e.currentTarget);
+			break;
+		}
+	}
+}
+function Tt(e) {
+	if (e.relatedTarget instanceof HTMLIFrameElement) switch (se().state) {
+		case "hover": de({
+			cursorFlags: 0,
+			state: "inactive"
+		});
+	}
+}
+function $t(e) {
+	if (e.defaultPrevented) return;
+	if (e.pointerType === "mouse" && e.button > 0) return;
+	nn(e.currentTarget, e) && e.preventDefault();
+}
+function At(e) {
+	e.target === e.currentTarget && Je(e.currentTarget.document);
+}
+function Kn(e) {
+	let t = 0;
+	let n = 0;
+	const o = {};
+	for (const i of e) if (i.defaultSize !== void 0) {
+		t++;
+		const s = X(i.defaultSize);
+		n += s, o[i.itemId] = s;
+	} else o[i.itemId] = void 0;
+	const r = e.length - t;
+	if (r !== 0) {
+		const i = X((100 - n) / r);
+		for (const s of e) s.defaultSize === void 0 && (o[s.itemId] = i);
+	}
+	return o;
+}
+function Xn(e, t) {
+	const n = e.map((r) => r.id);
+	const o = Object.keys(t);
+	if (n.length !== o.length) return !1;
+	for (const r of n) if (!o.includes(r)) return !1;
+	return !0;
+}
+function Dt({ axis: e, itemConstraints: t }) {
+	const n = e.items.map(({ id: r }) => r).join(",");
+	const o = e.mutableState.defaultLayout;
+	return e.mutableState.layouts[n] ?? (o && Xn(e.items, o) ? o : Kn(t));
+}
+function Ot({ itemIds: e, layout: t }) {
+	return ye({
+		layout: t,
+		itemConstraints: e.map((n) => ({
+			collapsedSize: 0,
+			collapsible: !1,
+			defaultSize: void 0,
+			disabled: void 0,
+			itemId: n,
+			maxSize: 100,
+			minSize: 0
+		}))
+	});
+}
+function Jn(e, t, n) {
+	if (!n[0]) return;
+	const r = e.items.find((c) => c.element === t);
+	if (!r || !r.onResize) return;
+	const i = ke({ axis: e });
+	const s = e.orientation === "horizontal" ? r.element.offsetWidth : r.element.offsetHeight;
+	const l = r.mutableValues.prevSize;
+	const a = {
+		asPercentage: X(s / i * 100),
+		inPixels: s
+	};
+	r.mutableValues.prevSize = a, r.onResize(a, r.id, l);
+}
+function sn(e, t) {
+	if (Object.keys(e).length !== Object.keys(t).length) return !1;
+	for (const o in e) if (e[o] !== t[o]) return !1;
+	return !0;
+}
+function Zn(e, t) {
+	return e.length !== t.length ? !1 : e.every((n, o) => sn(n, t[o]));
+}
+function Qn({ axis: e, nextAxisSize: t, prevAxisSize: n, prevLayout: o }) {
+	if (n <= 0 || t <= 0 || n === t) return o;
+	let r = 0;
+	let i = 0;
+	let s = !1;
+	const l = /* @__PURE__ */ new Map();
+	const a = [];
+	for (const d of e.items) {
+		const p = o[d.id] ?? 0;
+		switch (d.constraintProps.groupResizeBehavior) {
+			case "preserve-pixel-size": {
+				s = !0;
+				const m = X(p / 100 * n / t * 100);
+				l.set(d.id, m), r += m;
+				break;
+			}
+			default: a.push(d.id), i += p;
+		}
+	}
+	if (!s || a.length === 0) return o;
+	const c = 100 - r;
+	const u = { ...o };
+	if (l.forEach((d, p) => {
+		u[p] = d;
+	}), i > 0) for (const d of a) u[d] = X((o[d] ?? 0) / i * c);
+	else {
+		const d = X(c / a.length);
+		for (const p of a) u[p] = d;
+	}
+	return u;
+}
+var Le = /* @__PURE__ */ new Map();
+function an(e) {
+	let t = !0;
+	D(e.element.ownerDocument.defaultView, "Cannot register an unmounted Group");
+	const n = e.element.ownerDocument.defaultView.ResizeObserver;
+	const o = /* @__PURE__ */ new Set();
+	const r = /* @__PURE__ */ new Set();
+	const i = new n((m) => {
+		for (const f of m) {
+			const { borderBoxSize: S, target: h } = f;
+			if (h === e.element) {
+				if (t) {
+					const g = ke({ axis: e });
+					if (g === 0) return;
+					const I = ae(e.id);
+					if (!I) return;
+					const x = it(e);
+					let C = I.requestedAxisSize;
+					let A = I.requestedLayout;
+					I.defaultLayoutDeferred && (C = g, A = Ot({
+						itemIds: e.items.map(({ id: w }) => w),
+						layout: Dt({
+							axis: e,
+							itemConstraints: x
+						})
+					}));
+					const b = ye({
+						layout: Qn({
+							axis: e,
+							nextAxisSize: g,
+							prevAxisSize: C,
+							prevLayout: A
+						}),
+						itemConstraints: x
+					});
+					if (!I.defaultLayoutDeferred && ie(I.layout, b) && Zn(I.derivedItemConstraints, x) && I.axisSize === g) continue;
+					fe(e, {
+						defaultLayoutDeferred: !1,
+						derivedItemConstraints: x,
+						axisSize: g,
+						layout: b,
+						requestedAxisSize: C,
+						requestedLayout: A,
+						separatorToItems: I.separatorToItems
+					});
+				}
+			} else Jn(e, h, S);
+		}
+	});
+	i.observe(e.element), e.items.forEach((m) => {
+		D(!o.has(m.id), `Panel ids must be unique; id "${m.id}" was used more than once`), o.add(m.id), m.onResize && i.observe(m.element);
+	});
+	const s = ke({ axis: e });
+	const l = it(e);
+	const a = Dt({
+		axis: e,
+		itemConstraints: l
+	});
+	const c = ye({
+		layout: a,
+		itemConstraints: l
+	});
+	const u = e.element.ownerDocument;
+	const d = u.defaultView;
+	Le.set(u, (Le.get(u) ?? 0) + 1);
+	const p = /* @__PURE__ */ new Map();
+	return ut({
+		axis: e,
+		includeDisabled: !0
+	}).forEach((m) => {
+		m.separator && p.set(m.separator, m.items);
+	}), fe(e, {
+		defaultLayoutDeferred: s === 0,
+		derivedItemConstraints: l,
+		axisSize: s,
+		layout: c,
+		requestedAxisSize: s,
+		requestedLayout: Ot({
+			itemIds: e.items.map(({ id: m }) => m),
+			layout: a
+		}),
+		separatorToItems: p
+	}), e.separators.forEach((m) => {
+		D(!r.has(m.id), `Separator ids must be unique; id "${m.id}" was used more than once`), r.add(m.id), m.element.addEventListener("keydown", Ct);
+	}), Le.get(u) === 1 && (u.addEventListener("contextmenu", xt, !0), u.addEventListener("dblclick", Lt, !0), u.addEventListener("lostpointercapture", Rt, !0), u.addEventListener("pointercancel", Mt, !0), u.addEventListener("pointerdown", Et, !0), u.addEventListener("pointerleave", Pt), u.addEventListener("pointermove", kt), u.addEventListener("pointerout", Tt), u.addEventListener("pointerup", $t, !0), d?.addEventListener("blur", At)), function() {
+		t = !1, Le.set(u, Math.max(0, (Le.get(u) ?? 0) - 1)), Nn(e), Rn(e) && Ve(u), e.separators.forEach((f) => {
+			f.element.removeEventListener("keydown", Ct);
+		}), Le.get(u) || (u.removeEventListener("contextmenu", xt, !0), u.removeEventListener("dblclick", Lt, !0), u.removeEventListener("lostpointercapture", Rt, !0), u.removeEventListener("pointercancel", Mt, !0), u.removeEventListener("pointerdown", Et, !0), u.removeEventListener("pointerleave", Pt), u.removeEventListener("pointermove", kt), u.removeEventListener("pointerout", Tt), u.removeEventListener("pointerup", $t, !0), d?.removeEventListener("blur", At)), i.disconnect();
+	};
+}
+function ln({ derivedItemConstraints: e, axis: t, layout: n, prevLayout: o, requestedLayout: r }) {
+	const i = t.items.map(({ id: s }) => s).join(",");
+	t.mutableState.layouts[i] = r, o && e.forEach((s) => {
+		if (s.collapsible) {
+			const l = Y(s.collapsedSize, n[s.itemId]);
+			const a = Y(s.collapsedSize, o[s.itemId]);
+			l && !a && (t.mutableState.expandedItemSizes[s.itemId] = o[s.itemId]);
+		}
+	});
+}
+function cn() {
+	const [e, t] = useState({});
+	return [e, useCallback(() => t({}), [])];
+}
+function Ze(e) {
+	const t = useRef({ ...e });
+	return ne(() => {
+		for (const n in e) t.current[n] = e[n];
+	}, [e]), t.current;
+}
+var pt = createContext(null);
+function eo({ layout: e, itemConstraints: t, itemId: n, itemIndex: o }) {
+	let r;
+	let i;
+	const s = e[n];
+	const l = t.find((a) => a.itemId === n);
+	if (l) {
+		const a = l.maxSize;
+		const c = l.collapsible ? l.collapsedSize : l.minSize;
+		const u = [o, o + 1];
+		i = ye({
+			layout: Fe({
+				delta: c - s,
+				initialLayout: e,
+				itemConstraints: t,
+				pivotIndices: u,
+				prevLayout: e
+			}),
+			itemConstraints: t
+		})[n], r = ye({
+			layout: Fe({
+				delta: a - s,
+				initialLayout: e,
+				itemConstraints: t,
+				pivotIndices: u,
+				prevLayout: e
+			}),
+			itemConstraints: t
+		})[n];
+	}
+	return {
+		valueControls: n,
+		valueMax: r,
+		valueMin: i,
+		valueNow: s
+	};
+}
+function un({ attributes: e, axisId: t, axisOrientation: n, children: o, className: r, disableCursor: i, disabled: s, disableDoubleClick: l, elementRef: a, id: c, isSharedHitRegion: u, preview: d, registerSeparator: p, requiredStyle: y, style: m, styleDefaults: f, tabIndex: S = 0, updateSeparatorProps: h }) {
+	const g = Ze({
+		disabled: s,
+		disableDoubleClick: l,
+		children: o,
+		className: r,
+		preview: d,
+		style: m
+	}), [I, x] = useState({}), [C, A] = useState("inactive"), [N, b] = useState(!1), w = useRef(null), v = useRef(null), T = qe(w, a), O = n === "horizontal" ? "vertical" : "horizontal";
+	ne(() => {
+		const P = w.current;
+		if (P !== null) {
+			const z = {
+				disabled: g.disabled,
+				disableDoubleClick: g.disableDoubleClick,
+				element: P,
+				id: c,
+				get children() {
+					return g.children;
+				},
+				get className() {
+					return g.className;
+				},
+				get preview() {
+					return g.preview;
+				},
+				get style() {
+					return g.style;
+				}
+			};
+			v.current = z;
+			const M = p(z);
+			const q = Kt((H) => {
+				A(H.next.state !== "inactive" && H.next.hitRegions.some((Z) => Z.separator === z || (u?.(Z) ?? !1)) ? H.next.state : "inactive");
+			});
+			const J = _e(t, (H) => {
+				const { derivedItemConstraints: Z, layout: Se, separatorToItems: ze } = H.next, Ie = ze.get(z);
+				if (Ie) {
+					const ve = Ie[0], L = Z.findIndex((_) => _.itemId === ve.id), { layoutStrategy: k } = H.axis;
+					x({
+						...eo({
+							layout: Se,
+							itemConstraints: Z,
+							itemId: ve.id,
+							itemIndex: L
+						}),
+						...k?.getItemAriaControls && { valueControls: k.getItemAriaControls(ve.id) }
+					});
+				}
+			});
+			return () => {
+				v.current = null, q(), J(), M();
+			};
+		}
+	}, [
+		t,
+		c,
+		u,
+		p,
+		g
+	]), ne(() => {
+		const P = v.current;
+		P && Cn(P);
+	}, [d]), useEffect(() => {
+		h(c, {
+			disabled: s,
+			disableDoubleClick: l
+		});
+	}, [
+		s,
+		l,
+		c,
+		h
+	]);
+	let R;
+	s && !i && (R = "not-allowed");
+	let E;
+	if (s) E = "disabled";
+	else switch (C) {
+		case "active":
+			E = "active";
+			break;
+		default: N ? E = "focus" : E = C;
+	}
+	return /* @__PURE__ */ jsx("div", {
+		...e,
+		"aria-controls": I.valueControls,
+		"aria-disabled": s || void 0,
+		"aria-orientation": O,
+		"aria-valuemax": I.valueMax,
+		"aria-valuemin": I.valueMin,
+		"aria-valuenow": I.valueNow,
+		children: o,
+		className: r,
+		"data-separator": E,
+		"data-testid": c,
+		id: c,
+		onBlur: () => b(!1),
+		onFocus: () => b(!0),
+		ref: T,
+		role: "separator",
+		style: {
+			...f,
+			cursor: R,
+			...m,
+			...y,
+			touchAction: "none"
+		},
+		tabIndex: s ? void 0 : S
+	});
+}
+function Nt({ axis: e, children: t, className: n, crossSpan: o, crossStart: r, disabled: i, elementRef: s, index: l, style: a }) {
+	const c = Te(void 0), { getDisableCursor: u, getResizeAxisId: d, gutters: p, registerSeparator: y, separatorPlacements: m, trackCounts: f, updateSeparatorProps: S } = Ut(), h = d(e), g = e === "column" ? "row" : "column", I = f[g], x = !!i || !at(l, f[e]);
+	let C = !0;
+	for (const v of m.values()) if (v.axis === e && v.index === l && !v.disabled && v.crossStart < r) {
+		C = !1;
+		break;
+	}
+	const A = useCallback((v) => v.axis.id === h && v.axis.items.indexOf(v.items[1]) === l, [h, l]);
+	const N = useCallback((v) => y({
+		axis: e,
+		crossSpan: o,
+		crossStart: r,
+		disabled: !!i,
+		index: l
+	}, v), [
+		e,
+		o,
+		r,
+		i,
+		l,
+		y
+	]);
+	const b = vn(l);
+	const w = bn({
+		crossCount: I,
+		crossSpan: o,
+		crossStart: r,
+		hasGutters: p[g]
+	});
+	return /* @__PURE__ */ jsx(un, {
+		axisId: h,
+		axisOrientation: e === "column" ? "horizontal" : "vertical",
+		className: n,
+		disableCursor: u(),
+		disabled: x,
+		disableDoubleClick: void 0,
+		elementRef: s,
+		id: c,
+		isSharedHitRegion: A,
+		registerSeparator: N,
+		requiredStyle: {
+			gridColumn: e === "column" ? b : w,
+			gridRow: e === "row" ? b : w
+		},
+		style: a,
+		tabIndex: C ? 0 : -1,
+		updateSeparatorProps: S,
+		children: t
+	});
+}
+function dn(e) {
+	const { children: t, className: n, disabled: o, elementRef: r, style: i } = e;
+	return e.type === "column" ? /* @__PURE__ */ jsx(Nt, {
+		axis: "column",
+		className: n,
+		crossSpan: e.rowSpan,
+		crossStart: e.row ?? 0,
+		disabled: o,
+		elementRef: r,
+		index: e.column,
+		style: i,
+		children: t
+	}) : /* @__PURE__ */ jsx(Nt, {
+		axis: "row",
+		className: n,
+		crossSpan: e.columnSpan,
+		crossStart: e.column ?? 0,
+		disabled: o,
+		elementRef: r,
+		index: e.row,
+		style: i,
+		children: t
+	});
+}
+dn.displayName = "Gridline";
+var Re = ["column", "row"];
+var Gt = {
+	columns: {},
+	rows: {}
+};
+function to({ children: e, className: t, columns: n, defaultLayout: o, disableCursor: r, disabled: i, elementRef: s, gridRef: l, id: a, onLayoutChange: c, onLayoutChanged: u, resizeTargetMinimumSize: d = {
+	coarse: 20,
+	fine: 10
+}, rows: p, style: y, ...m }) {
+	const f = Te(a), S = useCallback((L) => L === "column" ? `${f}:columns` : `${f}:rows`, [f]), h = _t(n, "columns"), g = _t(p, "rows"), I = (L) => L === "column" ? h : g, x = useRef({
+		onLayoutChange: Gt,
+		onLayoutChanged: Gt
+	}), C = ge((L) => {
+		Ft(x.current.onLayoutChange, L) || (x.current.onLayoutChange = L, c?.(L));
+	}), A = ge((L, k, _) => {
+		Ft(x.current.onLayoutChanged, L) || (x.current.onLayoutChanged = L, u?.(L, {
+			isUserInteraction: k,
+			requestedLayout: _
+		}));
+	}), N = useRef(null), b = qe(N, s), [w, v] = cn(), T = useRef({
+		cells: [],
+		column: {
+			expandedItemSizes: {},
+			layouts: {}
+		},
+		loggedErrors: /* @__PURE__ */ new Set(),
+		row: {
+			expandedItemSizes: {},
+			layouts: {}
+		},
+		separators: /* @__PURE__ */ new Map()
+	}), O = {
+		column: !1,
+		row: !1
+	};
+	for (const L of T.current.separators.values()) O[L.axis] = !0;
+	fn(e, O);
+	const R = Ze({
+		defaultLayout: o,
+		disableCursor: r,
+		resizeTargetMinimumSize: d
+	});
+	const E = ge(() => !!R.disableCursor);
+	const P = useCallback((L) => {
+		const k = T.current;
+		return k.cells = [...k.cells, L], v(), () => {
+			k.cells = k.cells.filter((_) => _ !== L), v();
+		};
+	}, [v]);
+	const z = useCallback((L, k) => {
+		const _ = T.current;
+		return _.separators = new Map(_.separators), _.separators.set(k, L), v(), () => {
+			_.separators = new Map(_.separators), _.separators.delete(k), v();
+		};
+	}, [v]);
+	const M = useCallback((L, { disabled: k, disableDoubleClick: _ }) => {
+		for (const G of T.current.separators.keys()) G.id === L && (G.disabled = k, G.disableDoubleClick = _);
+	}, []);
+	const q = T.current.separators;
+	const J = useMemo(() => ({
+		getDisableCursor: E,
+		getResizeAxisId: S,
+		gutters: {
+			column: O.column,
+			row: O.row
+		},
+		id: f,
+		registerCell: P,
+		registerSeparator: z,
+		separatorPlacements: q,
+		trackCounts: {
+			column: h.length,
+			row: g.length
+		},
+		updateSeparatorProps: M
+	}), [
+		h.length,
+		E,
+		S,
+		O.column,
+		O.row,
+		f,
+		P,
+		z,
+		g.length,
+		q,
+		M
+	]);
+	const H = useRef([]);
+	ne(() => {
+		const L = N.current;
+		if (L === null) return;
+		const k = T.current;
+		const _ = oo({
+			cells: k.cells,
+			separatorPlacements: k.separators,
+			trackCounts: {
+				column: h.length,
+				row: g.length
+			}
+		});
+		_.forEach(($) => {
+			k.loggedErrors.has($) || console.error($);
+		}), k.loggedErrors = new Set(_);
+		const G = ($) => Array.from(k.separators.entries()).filter(([, W]) => W.axis === $).sort(([, W], [, be]) => W.index - be.index).map(([W]) => W);
+		const F = ($) => {
+			const W = $ === "column" ? h : g;
+			const be = $ === "column" ? g : h;
+			const me = W.map((Q) => Q.id);
+			const He = S($);
+			const je = G($);
+			const xe = je.length > 0;
+			const Ue = W.map(({ id: Q, ...oe }, ee) => ({
+				element: L,
+				id: me[ee],
+				idIsStable: !0,
+				mutableValues: {
+					expandToSize: void 0,
+					prevSize: void 0
+				},
+				onResize: void 0,
+				constraintProps: oe
+			}));
+			const Ae = () => {
+				const Q = [];
+				if (xe) {
+					for (const [oe, ee] of k.separators) if (ee.axis === $ && at(ee.index, W.length)) {
+						const Oe = oe.element.getBoundingClientRect();
+						Q[ee.index] = Math.max(Q[ee.index] ?? 0, $ === "column" ? Oe.width : Oe.height);
+					}
+				}
+				return In({
+					axis: $,
+					element: L,
+					gutterSizes: Q.filter((oe) => oe !== void 0),
+					hasGutters: xe,
+					layout: ae(He)?.layout,
+					trackIds: me
+				});
+			};
+			let De;
+			const et = R.defaultLayout?.[$ === "column" ? "columns" : "rows"];
+			if (et !== void 0 && Object.keys(et).length === me.length) {
+				De = {};
+				for (const Q of me) {
+					const oe = et[Q];
+					oe !== void 0 && (De[Q] = oe);
+				}
+			}
+			return {
+				disabled: !!i,
+				element: L,
+				id: He,
+				layoutStrategy: {
+					getItemAriaControls: (Q) => {
+						const oe = me.indexOf(Q);
+						return k.cells.filter((ee) => {
+							const Oe = $ === "column" ? ee.column : ee.row;
+							const pn = $ === "column" ? ee.columnSpan : ee.rowSpan;
+							return Oe <= oe && oe < Oe + pn;
+						}).map((ee) => ee.element.id).filter(Boolean).join(" ") || void 0;
+					},
+					calculateAvailableSize: () => Ae().availableSize,
+					calculateHitRegions: ({ expandHitTargets: Q, axis: oe, includeDisabled: ee }) => zn({
+						axis: $,
+						cells: k.cells,
+						crossTrackCount: be.length,
+						expandHitTargets: Q,
+						resizeAxis: oe,
+						axisSize: Ae().availableSize,
+						includeDisabled: ee,
+						separatorPlacements: k.separators
+					}),
+					getItemSizeInPixels: (Q) => Ae().trackSizes[me.indexOf(Q)] ?? 0
+				},
+				mutableState: {
+					defaultLayout: De,
+					disableCursor: !!R.disableCursor,
+					expandedItemSizes: k[$].expandedItemSizes,
+					layouts: k[$].layouts
+				},
+				orientation: $ === "column" ? "horizontal" : "vertical",
+				items: Ue,
+				resizePreviewMode: "panel",
+				get resizeTargetMinimumSize() {
+					return R.resizeTargetMinimumSize;
+				},
+				separators: je
+			};
+		};
+		const j = Re.map(F);
+		H.current = j;
+		const U = j.map(($) => an($));
+		const te = () => {
+			const [$, W] = j.map((be) => ae(be.id));
+			if (!(!$ || !W || $.defaultLayoutDeferred || W.defaultLayoutDeferred)) return {
+				layout: {
+					columns: $.layout,
+					rows: W.layout
+				},
+				requestedLayout: {
+					columns: $.requestedLayout,
+					rows: W.requestedLayout
+				}
+			};
+		};
+		{
+			const $ = te();
+			$ && (C($.layout), A($.layout, !1, $.requestedLayout));
+		}
+		const $e = j.map(($) => _e($.id, (W) => {
+			const { defaultLayoutDeferred: be, derivedItemConstraints: me, layout: He, requestedLayout: je } = W.next;
+			if (be || me.length === 0) return;
+			ln({
+				derivedItemConstraints: me,
+				axis: $,
+				layout: He,
+				prevLayout: W.prev?.layout,
+				requestedLayout: je
+			});
+			const xe = te();
+			if (xe) {
+				const Ue = se();
+				const Ae = Ue.state !== "active" || !Ue.hitRegions.some((De) => j.includes(De.axis));
+				C(xe.layout), Ae && A(xe.layout, W.isUserInteraction, xe.requestedLayout);
+			}
+		}));
+		return () => {
+			H.current = [], U.forEach(($) => $()), $e.forEach(($) => $());
+		};
+	}, [
+		h,
+		i,
+		S,
+		f,
+		A,
+		C,
+		g,
+		w,
+		R
+	]), useEffect(() => {
+		H.current.forEach((L) => {
+			L.mutableState.defaultLayout = o?.[L.orientation === "horizontal" ? "columns" : "rows"], L.mutableState.disableCursor = !!r;
+		});
+	}), useImperativeHandle(l, () => {
+		const L = () => {
+			const [G, F] = Re.map(S);
+			return !Me(G) || !Me(F) ? {
+				columns: {},
+				rows: {}
+			} : {
+				columns: Ge({ axisId: G }).getLayout(),
+				rows: Ge({ axisId: F }).getLayout()
+			};
+		};
+		const k = (G) => G.map((F) => `"${F}"`).join(", ");
+		const _ = (G, F) => {
+			const j = S(G);
+			const U = () => {
+				const te = Me(j);
+				return D(te, `Grid "${f}" has not been mounted`), D(te.items.some(($e) => $e.id === F), `Grid "${f}" no longer contains a ${G} with id "${F}"; ${G} ids are ${k(te.items.map(($e) => $e.id))}`), mt({
+					axisId: j,
+					itemId: F
+				});
+			};
+			return {
+				collapse: () => U().collapse(),
+				expand: () => U().expand(),
+				getSize: () => U().getSize(),
+				isCollapsed: () => U().isCollapsed(),
+				resize: (te) => U().resize(te)
+			};
+		};
+		return {
+			getLayout: L,
+			getTrackById: (G, F) => {
+				const j = G === "column" ? h : g;
+				const U = `${F}`;
+				return D(j.some((te) => te.id === U), `Grid "${f}" does not contain a ${G} with id "${U}"; ${G} ids are ${k(j.map((te) => te.id))}`), _(G, U);
+			},
+			getTrackByIndex: (G, F) => {
+				const j = G === "column" ? h : g;
+				const U = Number.isInteger(F) ? j[F] : void 0;
+				return D(U, `Grid "${f}" does not contain a ${G} at index ${F}; it has ${j.length} ${G}s`), _(G, U.id);
+			},
+			setLayout: (G) => (Re.forEach((F) => {
+				const j = G[F === "column" ? "columns" : "rows"];
+				const U = S(F);
+				j && Me(U) && Ge({ axisId: U }).setLayout(j);
+			}), L())
+		};
+	}, [
+		h,
+		S,
+		f,
+		g
+	]);
+	const Z = () => Re.map((L) => {
+		const k = ae(S(L));
+		const _ = I(L);
+		return (k && !k.defaultLayoutDeferred ? _.map((F) => `minmax(0, ${k.layout[F.id] ?? 1}fr)`) : no(_, o?.[L === "column" ? "columns" : "rows"])).join(O[L] ? " auto " : " ");
+	}).join("|"), Se = useCallback((L) => {
+		const k = Re.map((_) => _e(S(_), L));
+		return () => k.forEach((_) => _());
+	}, [S]), [Ie, ve] = useSyncExternalStore(Se, Z, Z).split("|");
+	return /* @__PURE__ */ jsx(jt.Provider, {
+		value: J,
+		children: /* @__PURE__ */ jsx("div", {
+			...m,
+			className: t,
+			"data-grid": !0,
+			"data-testid": f,
+			id: f,
+			ref: b,
+			style: {
+				height: "100%",
+				width: "100%",
+				overflow: "hidden",
+				...y,
+				display: "grid",
+				gridTemplateColumns: Ie,
+				gridTemplateRows: ve,
+				touchAction: "none"
+			},
+			children: /* @__PURE__ */ jsx(pt.Provider, {
+				value: null,
+				children: e
+			})
+		})
+	});
+}
+to.displayName = "Grid";
+function _t(e, t) {
+	const n = JSON.stringify(e);
+	return useMemo(() => {
+		const o = typeof e == "number" ? Array.from({ length: e }, (r, i) => ({ id: `${i}` })) : e.map((r, i) => ({
+			...r,
+			id: `${r.id ?? i}`
+		}));
+		return D(o.length > 0, `Grid must have at least one track; "${t}" is ${n}`), o;
+	}, [n]);
+}
+function fn(e, t) {
+	Children.forEach(e, (n) => {
+		if (isValidElement(n)) if (n.type === dn) {
+			const { type: o } = n.props;
+			o === "column" ? t.column = !0 : o === "row" && (t.row = !0);
+		} else typeof n.type == "symbol" && n.props !== null && typeof n.props == "object" && "children" in n.props && fn(n.props.children, t);
+	});
+}
+function no(e, t) {
+	if (t) return e.map((i) => `minmax(0, ${t[i.id] ?? 1}fr)`);
+	const n = e.map((i) => i.defaultSize === void 0 ? void 0 : Wt(i.defaultSize));
+	let o = 100;
+	let r = 0;
+	return n.forEach((i) => {
+		i === void 0 ? r++ : i[1] === "%" && (o -= i[0]);
+	}), n.map((i) => {
+		if (i === void 0) return `minmax(0, ${Math.max(0, o) / Math.max(1, r)}fr)`;
+		const [s, l] = i;
+		return l === "%" ? `minmax(0, ${s}fr)` : `${s}${l}`;
+	});
+}
+function oo({ cells: e, separatorPlacements: t, trackCounts: n }) {
+	const o = [];
+	for (const l of e) Re.forEach((a) => {
+		const [c, u] = a === "column" ? [l.column, l.columnSpan] : [l.row, l.rowSpan], d = n[a];
+		(!Number.isInteger(c) || !Number.isInteger(u) || c < 0 || u < 1 || c + u > d) && o.push(`Invalid Cell ${a} placement (${a}: ${c}, ${a}Span: ${u}); Grid has ${d} ${a}s`);
+	});
+	const r = ({ axis: l, crossSpan: a, crossStart: c, disabled: u, index: d }) => {
+		const p = l === "column" ? "row" : "column";
+		let y = `type="${l}" ${l}={${d}}`;
+		return (c !== 0 || a !== void 0) && (y += ` ${p}={${c}}`), a !== void 0 && (y += ` ${p}Span={${a}}`), u && (y += " disabled"), `<Gridline ${y} />`;
+	};
+	const i = Array.from(t.values()).filter((l) => {
+		const { axis: a, crossSpan: c, crossStart: u, index: d } = l, p = a === "column" ? "row" : "column", y = n[a], m = n[p];
+		let f = !0;
+		return at(d, y) || (o.push(`Invalid ${a} Gridline ${a} (${d}); must be between 1 and ${y - 1}`), f = !1), !Number.isInteger(u) || u < 0 || u >= m ? (o.push(`Invalid ${a} Gridline ${p} (${u}); must be between 0 and ${m - 1}`), f = !1) : c !== void 0 && (!Number.isInteger(c) || c < 1 || u + c > m) && (o.push(`Invalid ${a} Gridline ${p}Span (${c}); Grid has ${m} ${p}s`), f = !1), f;
+	});
+	const s = (l) => {
+		const a = n[l.axis === "column" ? "row" : "column"];
+		return [l.crossStart, l.crossSpan === void 0 ? a : l.crossStart + l.crossSpan];
+	};
+	return i.forEach((l, a) => {
+		const { axis: c, index: u } = l, [d, p] = s(l);
+		for (const y of e) {
+			const [m, f, S, h] = c === "column" ? [
+				y.column,
+				y.columnSpan,
+				y.row,
+				y.rowSpan
+			] : [
+				y.row,
+				y.rowSpan,
+				y.column,
+				y.columnSpan
+			];
+			if (m < u && u < m + f && S < p && d < S + h) {
+				const g = c === "column" ? "row" : "column";
+				o.push(`${r(l)} overlaps a Cell that spans across it (${c}: ${m}, ${c}Span: ${f}, ${g}: ${S}, ${g}Span: ${h}); use the ${g} and ${g}Span props to render gridlines beside the Cell instead`);
+			}
+		}
+		for (const y of i.slice(a + 1)) if (y.axis === c && y.index === u) {
+			const [m, f] = s(y);
+			m < p && d < f && o.push(`${r(l)} overlaps ${r(y)}`);
+		}
+	}), o;
+}
+function Ft(e, t) {
+	return ie(e.columns, t.columns) && ie(e.rows, t.rows);
+}
+function io(e) {
+	for (let t = 1; t < e.length; t++) if (ct(e[t - 1], e[t]) > 0) return !1;
+	return !0;
+}
+function so({ separator: e }) {
+	const { element: t } = e, n = useRef(null);
+	return ne(() => {
+		const o = t.cloneNode(!0);
+		const r = [t, ...t.querySelectorAll("*")];
+		const i = [o, ...o.querySelectorAll("*")];
+		const s = t.ownerDocument.defaultView;
+		return r.forEach((l, a) => {
+			const c = i[a];
+			if (c instanceof s.HTMLElement || c instanceof s.SVGElement) {
+				const u = s.getComputedStyle(l);
+				for (let d = 0; d < u.length; d++) {
+					const p = u.item(d);
+					c.style.setProperty(p, u.getPropertyValue(p));
+				}
+			}
+			c.removeAttribute("data-testid"), c.removeAttribute("id");
+		}), Object.assign(o.style, {
+			boxSizing: "border-box",
+			height: "100%",
+			margin: "0",
+			position: "static",
+			transform: "none",
+			width: "100%"
+		}), n.current.appendChild(o), () => o.remove();
+	}, [t]), /* @__PURE__ */ jsx("div", {
+		ref: n,
+		style: {
+			height: "100%",
+			opacity: .65,
+			pointerEvents: "none",
+			width: "100%"
+		}
+	});
+}
+function Qe() {
+	const e = useContext(pt);
+	return D(e, "Group Context not found; did you render a Panel or Separator outside of a Group?"), e;
+}
+function mn(e) {
+	const { registerOverlay: t } = Qe(), n = useRef(e);
+	sn(n.current, e) || (n.current = e);
+	const o = n.current;
+	return ne(() => t(o), [t, o]), null;
+}
+mn.displayName = "SeparatorOverlay";
+function ao({ active: e, orientation: t, style: n, ...o }) {
+	let r;
+	switch (t) {
+		case "horizontal":
+			r = {
+				height: "100%",
+				minWidth: "1px"
+			};
+			break;
+		case "vertical": r = {
+			minHeight: "1px",
+			width: "100%"
+		};
+	}
+	return /* @__PURE__ */ jsx("div", {
+		...o,
+		"data-separator-overlay": e ? "active" : "inactive",
+		style: {
+			...r,
+			...n,
+			flexShrink: 0,
+			pointerEvents: "none"
+		}
+	});
+}
+function lo({ overlay: e, preview: t }) {
+	const { axis: n, offset: o, rect: r, separator: i } = t, s = n.orientation === "horizontal";
+	let l = i?.preview;
+	let a = e;
+	return isValidElement(l) && l.type === mn && (a = l.props, l = void 0), l ?? (a ? l = /* @__PURE__ */ jsx(ao, {
+		...a,
+		active: t.active,
+		orientation: n.orientation
+	}) : i && (l = /* @__PURE__ */ jsx(so, { separator: i }))), /* @__PURE__ */ jsx("div", {
+		"aria-hidden": "true",
+		"data-resize-preview": !0,
+		inert: !0,
+		style: {
+			height: r.height,
+			left: r.left,
+			pointerEvents: "none",
+			position: "absolute",
+			top: r.top,
+			transform: s ? `translateX(${o}px)` : `translateY(${o}px)`,
+			width: r.width
+		},
+		children: l
+	});
+}
+function co(e) {
+	return Array.from(e).sort(ct);
+}
+function uo(e, t) {
+	const n = useRef({
+		getLayout: () => ({}),
+		setLayout: Mn
+	});
+	useImperativeHandle(t, () => n.current, []), ne(() => {
+		Object.assign(n.current, Ge({ axisId: e }));
+	});
+}
+function fo({ groupId: e, resizePreviewMode: t }) {
+	const [n, o] = useState([]), r = useRef(n);
+	return ne(() => {
+		const i = (l) => {
+			const a = Me(e);
+			const c = t === "separator" && l.state === "active" ? l.previews.filter((d) => d.axis === a && (d.active || !Y(d.offset, 0))) : [];
+			const u = r.current;
+			u.length === c.length && c.every((d, p) => d === u[p]) || (r.current = c, o(c));
+		};
+		if (t !== "separator") {
+			i(se());
+			return;
+		}
+		const s = Kt(({ next: l }) => i(l));
+		return i(se()), s;
+	}, [e, t]), n;
+}
+function mo({ children: e, className: t, defaultLayout: n, disableCursor: o, disabled: r, elementRef: i, groupRef: s, id: l, onLayoutChange: a, onLayoutChanged: c, orientation: u = "horizontal", resizePreviewMode: d = "panel", resizeTargetMinimumSize: p = {
+	coarse: 20,
+	fine: 10
+}, style: y, ...m }) {
+	const f = useRef({
+		onLayoutChange: {},
+		onLayoutChanged: {}
+	}), S = ge((z) => {
+		ie(f.current.onLayoutChange, z) || (f.current.onLayoutChange = z, a?.(z));
+	}), h = ge((z, M, q) => {
+		ie(f.current.onLayoutChanged, z) || (f.current.onLayoutChanged = z, c?.(z, {
+			isUserInteraction: M,
+			requestedLayout: q
+		}));
+	}), g = Te(l), [I, x] = useState(), C = fo({
+		groupId: g,
+		resizePreviewMode: d
+	}), A = useRef(null), [N, b] = cn(), w = useRef([]), v = useRef({
+		lastExpandedPanelSizes: {},
+		layouts: {},
+		panels: [],
+		separators: []
+	}), T = qe(A, i);
+	uo(g, s);
+	const O = ge((z, M) => {
+		const q = ae(z);
+		if (q) return { flexGrow: q.layout[M] ?? 1 };
+		if (n?.[M]) return { flexGrow: n?.[M] };
+	});
+	const R = Ze({
+		defaultLayout: n,
+		disableCursor: o,
+		resizeTargetMinimumSize: p
+	});
+	const E = useMemo(() => ({
+		get disableCursor() {
+			return !!R.disableCursor;
+		},
+		getPanelStyles: O,
+		id: g,
+		orientation: u,
+		registerPanel: (z) => {
+			const M = v.current;
+			return M.panels = Ne(u, [...M.panels, z]), b(), () => {
+				M.panels = M.panels.filter((q) => q !== z), b();
+			};
+		},
+		registerOverlay: (z) => (x(z), () => {
+			x(void 0);
+		}),
+		registerSeparator: (z) => {
+			const M = v.current;
+			return M.separators = Ne(u, [...M.separators, z]), b(), () => {
+				M.separators = M.separators.filter((q) => q !== z), b();
+			};
+		},
+		updatePanelProps: (z, { disabled: M }) => {
+			const J = v.current.panels.find((Se) => Se.id === z);
+			J && (J.constraintProps.disabled = M);
+			const H = Me(g);
+			const Z = ae(g);
+			H && Z && fe(H, {
+				...Z,
+				derivedItemConstraints: it(H)
+			});
+		},
+		updateSeparatorProps: (z, { disabled: M, disableDoubleClick: q }) => {
+			const H = v.current.separators.find((Z) => Z.id === z);
+			H && (H.disabled = M, H.disableDoubleClick = q);
+		}
+	}), [
+		O,
+		g,
+		b,
+		u,
+		R
+	]);
+	const P = useRef(null);
+	return ne(() => {
+		const z = A.current;
+		if (z === null) return;
+		const M = v.current;
+		M.panels = Ne(u, M.panels), M.separators = Ne(u, M.separators), w.current = co([...M.panels.map(({ element: L }) => L), ...M.separators.map(({ element: L }) => L)]);
+		let q;
+		if (R.defaultLayout !== void 0 && Object.keys(R.defaultLayout).length === M.panels.length) {
+			q = {};
+			for (const L of M.panels) {
+				const k = R.defaultLayout[L.id];
+				k !== void 0 && (q[L.id] = k);
+			}
+		}
+		const J = {
+			disabled: !!r,
+			element: z,
+			id: g,
+			mutableState: {
+				defaultLayout: q,
+				disableCursor: !!R.disableCursor,
+				expandedItemSizes: v.current.lastExpandedPanelSizes,
+				layouts: v.current.layouts
+			},
+			orientation: u,
+			items: M.panels,
+			resizePreviewMode: d,
+			get resizeTargetMinimumSize() {
+				return R.resizeTargetMinimumSize;
+			},
+			separators: M.separators
+		};
+		P.current = J;
+		const H = an(J), { defaultLayoutDeferred: Z, derivedItemConstraints: Se, layout: ze, requestedLayout: Ie } = ae(J.id, !0);
+		!Z && Se.length > 0 && (S(ze), h(ze, !1, Ie));
+		const ve = _e(g, (L) => {
+			const { defaultLayoutDeferred: k, derivedItemConstraints: _, layout: G, requestedLayout: F } = L.next;
+			if (k || _.length === 0) return;
+			ln({
+				derivedItemConstraints: _,
+				axis: J,
+				layout: G,
+				prevLayout: L.prev?.layout,
+				requestedLayout: F
+			});
+			const j = se();
+			const U = j.state !== "active" || !j.hitRegions.some((te) => te.axis === J);
+			S(G), U && h(G, L.isUserInteraction, F);
+		});
+		return () => {
+			P.current = null, H(), ve();
+		};
+	}, [
+		r,
+		g,
+		h,
+		S,
+		u,
+		N,
+		d,
+		R
+	]), ne(() => {
+		io(w.current) || b();
+	}), useEffect(() => {
+		const z = P.current;
+		z && (z.mutableState.defaultLayout = n, z.mutableState.disableCursor = !!o);
+	}), /* @__PURE__ */ jsx(pt.Provider, {
+		value: E,
+		children: /* @__PURE__ */ jsxs("div", {
+			...m,
+			className: t,
+			"data-group": !0,
+			"data-testid": g,
+			id: g,
+			ref: T,
+			style: {
+				height: "100%",
+				width: "100%",
+				overflow: "hidden",
+				position: d === "separator" ? "relative" : void 0,
+				...y,
+				display: "flex",
+				flexDirection: u === "horizontal" ? "row" : "column",
+				flexWrap: "nowrap",
+				touchAction: u === "horizontal" ? "pan-y" : "pan-x"
+			},
+			children: [e, C.map((z) => /* @__PURE__ */ jsx(lo, {
+				overlay: I,
+				preview: z
+			}, z.key))]
+		})
+	});
+}
+mo.displayName = "Group";
+function go(e, t) {
+	const { id: n } = Qe(), o = useRef({
+		collapse: tt,
+		expand: tt,
+		getSize: () => ({
+			asPercentage: 0,
+			inPixels: 0
+		}),
+		isCollapsed: () => !1,
+		resize: tt
+	});
+	useImperativeHandle(t, () => o.current, []), ne(() => {
+		Object.assign(o.current, mt({
+			axisId: n,
+			itemId: e
+		}));
+	});
+}
+function yo({ children: e, className: t, collapsedSize: n = "0%", collapsedThreshold: o, collapsible: r = !1, defaultSize: i, disabled: s, elementRef: l, groupResizeBehavior: a = "preserve-relative-size", id: c, maxSize: u = "100%", minSize: d = "0%", onResize: p, panelRef: y, style: m, ...f }) {
+	const S = !!c, h = Te(c), g = Ze({ disabled: s }), I = useRef(null), x = qe(I, l), { getPanelStyles: C, id: A, orientation: N, registerPanel: b, updatePanelProps: w } = Qe(), v = p !== null, T = ge((P, z, M) => {
+		p?.(P, c, M);
+	});
+	ne(() => {
+		const P = I.current;
+		if (P !== null) {
+			const z = {
+				element: P,
+				id: h,
+				idIsStable: S,
+				mutableValues: {
+					expandToSize: void 0,
+					prevSize: void 0
+				},
+				onResize: v ? T : void 0,
+				constraintProps: {
+					groupResizeBehavior: a,
+					collapsedSize: n,
+					collapsedThreshold: o,
+					collapsible: r,
+					defaultSize: i,
+					disabled: g.disabled,
+					maxSize: u,
+					minSize: d
+				}
+			};
+			return b(z);
+		}
+	}, [
+		a,
+		n,
+		o,
+		r,
+		i,
+		v,
+		h,
+		S,
+		u,
+		d,
+		T,
+		b,
+		g
+	]), useEffect(() => {
+		w(h, { disabled: s });
+	}, [
+		s,
+		h,
+		w
+	]), go(h, y);
+	const O = () => {
+		const P = C(A, h);
+		if (P) return JSON.stringify(P);
+	};
+	const R = useSyncExternalStore((P) => _e(A, P), O, O);
+	let E;
+	return R ? E = JSON.parse(R) : i !== void 0 ? E = {
+		flexGrow: void 0,
+		flexShrink: void 0,
+		flexBasis: i
+	} : E = { flexGrow: 1 }, /* @__PURE__ */ jsx("div", {
+		...f,
+		"data-disabled": s || void 0,
+		"data-panel": !0,
+		"data-testid": h,
+		id: h,
+		ref: x,
+		style: {
+			...So,
+			display: "flex",
+			flexBasis: 0,
+			flexShrink: 1,
+			overflow: "visible",
+			...E
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			className: t,
+			style: {
+				maxHeight: "100%",
+				maxWidth: "100%",
+				flexGrow: 1,
+				overflow: "auto",
+				...m,
+				touchAction: N === "horizontal" ? "pan-y" : "pan-x"
+			},
+			children: e
+		})
+	});
+}
+yo.displayName = "Panel";
+var So = {
+	minHeight: 0,
+	maxHeight: "100%",
+	height: "auto",
+	minWidth: 0,
+	maxWidth: "100%",
+	width: "auto",
+	border: "none",
+	borderWidth: 0,
+	padding: 0,
+	margin: 0
+};
+var vo = { flexBasis: "auto" };
+var bo = {
+	flexGrow: 0,
+	flexShrink: 0
+};
+function xo({ children: e, className: t, disabled: n, disableDoubleClick: o, elementRef: r, id: i, preview: s, style: l, ...a }) {
+	const c = Te(i), { disableCursor: u, id: d, orientation: p, registerSeparator: y, updateSeparatorProps: m } = Qe();
+	return /* @__PURE__ */ jsx(un, {
+		attributes: a,
+		axisId: d,
+		axisOrientation: p,
+		className: t,
+		disableCursor: u,
+		disabled: n,
+		disableDoubleClick: o,
+		elementRef: r,
+		id: c,
+		preview: s,
+		registerSeparator: y,
+		requiredStyle: bo,
+		style: l,
+		styleDefaults: vo,
+		updateSeparatorProps: m,
+		children: e
+	});
+}
+xo.displayName = "Separator";
+export { xo as n, yo as r, mo as t };