@sheetxl/studio-vanilla 0.8.0-beta.10 → 0.8.0-beta.11

package/cdn/assets/CF6YxjWkuaqaHcCi.js

@@ -0,0 +1,2230 @@
+/**
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.11
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { n as e } from "./C7fZFw4yQ9VNHtnV.js";
+import { t } from "./Cf0bbHHOW6iwvyXg.js";
+import { t as n } from "./t8Ps76FWzb3VX_wg.js";
+import { t as r } from "./8CW-puLLSNyeaGce.js";
+import { t as i } from "./DbewMnLKZoGLGFNh.js";
+import { t as a } from "./DxI14nqCsNi-yexx.js";
+var o = e(t(), 1), s = r(), c = e(n(), 1), l = typeof window < "u" && window.document !== void 0 && window.document.createElement !== void 0;
+function u(e) {
+	let t = Object.prototype.toString.call(e);
+	return t === "[object Window]" || t === "[object global]";
+}
+function d(e) {
+	return "nodeType" in e;
+}
+function f(e) {
+	var t;
+	return e ? u(e) ? e : d(e) && (t = e.ownerDocument?.defaultView) != null ? t : window : window;
+}
+function p(e) {
+	let { Document: t } = f(e);
+	return e instanceof t;
+}
+function m(e) {
+	return !u(e) && e instanceof f(e).HTMLElement;
+}
+function h(e) {
+	return e instanceof f(e).SVGElement;
+}
+function g(e) {
+	return e ? u(e) ? e.document : d(e) ? p(e) ? e : m(e) || h(e) ? e.ownerDocument : document : document : document;
+}
+var _ = l ? o.useLayoutEffect : o.useEffect;
+function v(e) {
+	let t = (0, o.useRef)(e);
+	return _(() => {
+		t.current = e;
+	}), (0, o.useCallback)(function() {
+		var e = [...arguments];
+		return t.current == null ? void 0 : t.current(...e);
+	}, []);
+}
+function y(e, t) {
+	t === void 0 && (t = [e]);
+	let n = (0, o.useRef)(e);
+	return _(() => {
+		n.current !== e && (n.current = e);
+	}, t), n;
+}
+function b(e, t) {
+	let n = (0, o.useRef)();
+	return (0, o.useMemo)(() => {
+		let t = e(n.current);
+		return n.current = t, t;
+	}, [...t]);
+}
+function x(e) {
+	let t = v(e), n = (0, o.useRef)(null);
+	return [n, (0, o.useCallback)((e) => {
+		e !== n.current && t?.(e, n.current), n.current = e;
+	}, [])];
+}
+function S(e) {
+	let t = (0, o.useRef)();
+	return (0, o.useEffect)(() => {
+		t.current = e;
+	}, [e]), t.current;
+}
+var C = {};
+function w(e, t) {
+	return (0, o.useMemo)(() => {
+		if (t) return t;
+		let n = C[e] == null ? 0 : C[e] + 1;
+		return C[e] = n, e + "-" + n;
+	}, [e, t]);
+}
+function T(e) {
+	return function(t) {
+		return [...arguments].slice(1).reduce((t, n) => {
+			let r = Object.entries(n);
+			for (let [n, i] of r) {
+				let r = t[n];
+				r != null && (t[n] = r + e * i);
+			}
+			return t;
+		}, { ...t });
+	};
+}
+var E = T(1), D = T(-1);
+function O(e) {
+	if (!e) return !1;
+	let { KeyboardEvent: t } = f(e.target);
+	return t && e instanceof t;
+}
+function ee(e) {
+	if (function(e) {
+		if (!e) return !1;
+		let { TouchEvent: t } = f(e.target);
+		return t && e instanceof t;
+	}(e)) {
+		if (e.touches && e.touches.length) {
+			let { clientX: t, clientY: n } = e.touches[0];
+			return {
+				x: t,
+				y: n
+			};
+		}
+		if (e.changedTouches && e.changedTouches.length) {
+			let { clientX: t, clientY: n } = e.changedTouches[0];
+			return {
+				x: t,
+				y: n
+			};
+		}
+	}
+	return function(e) {
+		return "clientX" in e && "clientY" in e;
+	}(e) ? {
+		x: e.clientX,
+		y: e.clientY
+	} : null;
+}
+var k = Object.freeze({
+	Translate: { toString(e) {
+		if (!e) return;
+		let { x: t, y: n } = e;
+		return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (n ? Math.round(n) : 0) + "px, 0)";
+	} },
+	Scale: { toString(e) {
+		if (!e) return;
+		let { scaleX: t, scaleY: n } = e;
+		return "scaleX(" + t + ") scaleY(" + n + ")";
+	} },
+	Transform: { toString(e) {
+		if (e) return [k.Translate.toString(e), k.Scale.toString(e)].join(" ");
+	} },
+	Transition: { toString(e) {
+		let { property: t, duration: n, easing: r } = e;
+		return t + " " + n + "ms " + r;
+	} }
+}), te = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function ne(e) {
+	return e.matches(te) ? e : e.querySelector(te);
+}
+var A = { display: "none" };
+function j(e) {
+	let { id: t, value: n } = e;
+	return o.createElement("div", {
+		id: t,
+		style: A
+	}, n);
+}
+function re(e) {
+	let { id: t, announcement: n, ariaLiveType: r = "assertive" } = e;
+	return o.createElement("div", {
+		id: t,
+		style: {
+			position: "fixed",
+			top: 0,
+			left: 0,
+			width: 1,
+			height: 1,
+			margin: -1,
+			border: 0,
+			padding: 0,
+			overflow: "hidden",
+			clip: "rect(0 0 0 0)",
+			clipPath: "inset(100%)",
+			whiteSpace: "nowrap"
+		},
+		role: "status",
+		"aria-live": r,
+		"aria-atomic": !0
+	}, n);
+}
+var M, N, ie = (0, o.createContext)(null), P = { draggable: "\n    To pick up a draggable item, press the space bar.\n    While dragging, use the arrow keys to move the item.\n    Press space again to drop the item in its new position, or press escape to cancel.\n  " }, ae = {
+	onDragStart(e) {
+		let { active: t } = e;
+		return "Picked up draggable item " + t.id + ".";
+	},
+	onDragOver(e) {
+		let { active: t, over: n } = e;
+		return n ? "Draggable item " + t.id + " was moved over droppable area " + n.id + "." : "Draggable item " + t.id + " is no longer over a droppable area.";
+	},
+	onDragEnd(e) {
+		let { active: t, over: n } = e;
+		return n ? "Draggable item " + t.id + " was dropped over droppable area " + n.id : "Draggable item " + t.id + " was dropped.";
+	},
+	onDragCancel(e) {
+		let { active: t } = e;
+		return "Dragging was cancelled. Draggable item " + t.id + " was dropped.";
+	}
+};
+function oe(e) {
+	let { announcements: t = ae, container: n, hiddenTextDescribedById: r, screenReaderInstructions: i = P } = e, { announce: a, announcement: s } = function() {
+		let [e, t] = (0, o.useState)("");
+		return {
+			announce: (0, o.useCallback)((e) => {
+				e != null && t(e);
+			}, []),
+			announcement: e
+		};
+	}(), l = w("DndLiveRegion"), [u, d] = (0, o.useState)(!1);
+	if ((0, o.useEffect)(() => {
+		d(!0);
+	}, []), function(e) {
+		let t = (0, o.useContext)(ie);
+		(0, o.useEffect)(() => {
+			if (!t) throw Error("useDndMonitor must be used within a children of <DndContext>");
+			return t(e);
+		}, [e, t]);
+	}((0, o.useMemo)(() => ({
+		onDragStart(e) {
+			let { active: n } = e;
+			a(t.onDragStart({ active: n }));
+		},
+		onDragMove(e) {
+			let { active: n, over: r } = e;
+			t.onDragMove && a(t.onDragMove({
+				active: n,
+				over: r
+			}));
+		},
+		onDragOver(e) {
+			let { active: n, over: r } = e;
+			a(t.onDragOver({
+				active: n,
+				over: r
+			}));
+		},
+		onDragEnd(e) {
+			let { active: n, over: r } = e;
+			a(t.onDragEnd({
+				active: n,
+				over: r
+			}));
+		},
+		onDragCancel(e) {
+			let { active: n, over: r } = e;
+			a(t.onDragCancel({
+				active: n,
+				over: r
+			}));
+		}
+	}), [a, t])), !u) return null;
+	let f = o.createElement(o.Fragment, null, o.createElement(j, {
+		id: r,
+		value: i.draggable
+	}), o.createElement(re, {
+		id: l,
+		announcement: s
+	}));
+	return n ? (0, c.createPortal)(f, n) : f;
+}
+function F() {}
+function se(e, t) {
+	return (0, o.useMemo)(() => ({
+		sensor: e,
+		options: t ?? {}
+	}), [e, t]);
+}
+(N = M ||= {}).DragStart = "dragStart", N.DragMove = "dragMove", N.DragEnd = "dragEnd", N.DragCancel = "dragCancel", N.DragOver = "dragOver", N.RegisterDroppable = "registerDroppable", N.SetDroppableDisabled = "setDroppableDisabled", N.UnregisterDroppable = "unregisterDroppable";
+var I = Object.freeze({
+	x: 0,
+	y: 0
+});
+function ce(e, t) {
+	return Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
+}
+function L(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return n - r;
+}
+function R(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return r - n;
+}
+function z(e, t, n) {
+	return t === void 0 && (t = e.left), n === void 0 && (n = e.top), {
+		x: t + .5 * e.width,
+		y: n + .5 * e.height
+	};
+}
+var le = (e) => {
+	let { collisionRect: t, droppableRects: n, droppableContainers: r } = e, i = z(t, t.left, t.top), a = [];
+	for (let e of r) {
+		let { id: t } = e, r = n.get(t);
+		if (r) {
+			let n = ce(z(r), i);
+			a.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return a.sort(L);
+};
+function B(e, t) {
+	let n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), i = Math.min(t.left + t.width, e.left + e.width), a = Math.min(t.top + t.height, e.top + e.height), o = i - r, s = a - n;
+	if (r < i && n < a) {
+		let n = t.width * t.height, r = e.width * e.height, i = o * s;
+		return Number((i / (n + r - i)).toFixed(4));
+	}
+	return 0;
+}
+var V = (e) => {
+	let { collisionRect: t, droppableRects: n, droppableContainers: r } = e, i = [];
+	for (let e of r) {
+		let { id: r } = e, a = n.get(r);
+		if (a) {
+			let n = B(a, t);
+			n > 0 && i.push({
+				id: r,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return i.sort(R);
+};
+function H(e, t) {
+	return e && t ? {
+		x: e.left - t.left,
+		y: e.top - t.top
+	} : I;
+}
+var U, ue = function(e) {
+	return function(t) {
+		return [...arguments].slice(1).reduce((t, n) => ({
+			...t,
+			top: t.top + e * n.y,
+			bottom: t.bottom + e * n.y,
+			left: t.left + e * n.x,
+			right: t.right + e * n.x
+		}), { ...t });
+	};
+}(1), de = { ignoreTransform: !1 };
+function fe(e, t) {
+	t === void 0 && (t = de);
+	let n = e.getBoundingClientRect();
+	if (t.ignoreTransform) {
+		let { transform: t, transformOrigin: r } = f(e).getComputedStyle(e);
+		t && (n = function(e, t, n) {
+			let r = function(e) {
+				if (e.startsWith("matrix3d(")) {
+					let t = e.slice(9, -1).split(/, /);
+					return {
+						x: +t[12],
+						y: +t[13],
+						scaleX: +t[0],
+						scaleY: +t[5]
+					};
+				}
+				if (e.startsWith("matrix(")) {
+					let t = e.slice(7, -1).split(/, /);
+					return {
+						x: +t[4],
+						y: +t[5],
+						scaleX: +t[0],
+						scaleY: +t[3]
+					};
+				}
+				return null;
+			}(t);
+			if (!r) return e;
+			let { scaleX: i, scaleY: a, x: o, y: s } = r, c = e.left - o - (1 - i) * parseFloat(n), l = e.top - s - (1 - a) * parseFloat(n.slice(n.indexOf(" ") + 1)), u = i ? e.width / i : e.width, d = a ? e.height / a : e.height;
+			return {
+				width: u,
+				height: d,
+				top: l,
+				right: c + u,
+				bottom: l + d,
+				left: c
+			};
+		}(n, t, r));
+	}
+	let { top: r, left: i, width: a, height: o, bottom: s, right: c } = n;
+	return {
+		top: r,
+		left: i,
+		width: a,
+		height: o,
+		bottom: s,
+		right: c
+	};
+}
+function pe(e) {
+	return fe(e, { ignoreTransform: !0 });
+}
+function me(e, t) {
+	let n = [];
+	return e ? function r(i) {
+		if (t != null && n.length >= t || !i) return n;
+		if (p(i) && i.scrollingElement != null && !n.includes(i.scrollingElement)) return n.push(i.scrollingElement), n;
+		if (!m(i) || h(i) || n.includes(i)) return n;
+		let a = f(e).getComputedStyle(i);
+		return i !== e && function(e, t) {
+			t === void 0 && (t = f(e).getComputedStyle(e));
+			let n = /(auto|scroll|overlay)/;
+			return [
+				"overflow",
+				"overflowX",
+				"overflowY"
+			].some((e) => {
+				let r = t[e];
+				return typeof r == "string" && n.test(r);
+			});
+		}(i, a) && n.push(i), function(e, t) {
+			return t === void 0 && (t = f(e).getComputedStyle(e)), t.position === "fixed";
+		}(i, a) ? n : r(i.parentNode);
+	}(e) : n;
+}
+function he(e) {
+	let [t] = me(e, 1);
+	return t ?? null;
+}
+function ge(e) {
+	return l && e ? u(e) ? e : d(e) ? p(e) || e === g(e).scrollingElement ? window : m(e) ? e : null : null : null;
+}
+function _e(e) {
+	return u(e) ? e.scrollX : e.scrollLeft;
+}
+function W(e) {
+	return u(e) ? e.scrollY : e.scrollTop;
+}
+function ve(e) {
+	return {
+		x: _e(e),
+		y: W(e)
+	};
+}
+function ye(e) {
+	return !(!l || !e) && e === document.scrollingElement;
+}
+function be(e) {
+	let t = {
+		x: 0,
+		y: 0
+	}, n = ye(e) ? {
+		height: window.innerHeight,
+		width: window.innerWidth
+	} : {
+		height: e.clientHeight,
+		width: e.clientWidth
+	}, r = {
+		x: e.scrollWidth - n.width,
+		y: e.scrollHeight - n.height
+	};
+	return {
+		isTop: e.scrollTop <= t.y,
+		isLeft: e.scrollLeft <= t.x,
+		isBottom: e.scrollTop >= r.y,
+		isRight: e.scrollLeft >= r.x,
+		maxScroll: r,
+		minScroll: t
+	};
+}
+(function(e) {
+	e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(U ||= {});
+var G, K, q = {
+	x: .2,
+	y: .2
+};
+function xe(e, t, n, r, i) {
+	let { top: a, left: o, right: s, bottom: c } = n;
+	r === void 0 && (r = 10), i === void 0 && (i = q);
+	let { isTop: l, isBottom: u, isLeft: d, isRight: f } = be(e), p = {
+		x: 0,
+		y: 0
+	}, m = {
+		x: 0,
+		y: 0
+	}, h = t.height * i.y, g = t.width * i.x;
+	return !l && a <= t.top + h ? (p.y = U.Backward, m.y = r * Math.abs((t.top + h - a) / h)) : !u && c >= t.bottom - h && (p.y = U.Forward, m.y = r * Math.abs((t.bottom - h - c) / h)), !f && s >= t.right - g ? (p.x = U.Forward, m.x = r * Math.abs((t.right - g - s) / g)) : !d && o <= t.left + g && (p.x = U.Backward, m.x = r * Math.abs((t.left + g - o) / g)), {
+		direction: p,
+		speed: m
+	};
+}
+function J(e) {
+	if (e === document.scrollingElement) {
+		let { innerWidth: e, innerHeight: t } = window;
+		return {
+			top: 0,
+			left: 0,
+			right: e,
+			bottom: t,
+			width: e,
+			height: t
+		};
+	}
+	let { top: t, left: n, right: r, bottom: i } = e.getBoundingClientRect();
+	return {
+		top: t,
+		left: n,
+		right: r,
+		bottom: i,
+		width: e.clientWidth,
+		height: e.clientHeight
+	};
+}
+function Se(e) {
+	return e.reduce((e, t) => E(e, ve(t)), I);
+}
+var Ce = [[
+	"x",
+	["left", "right"],
+	function(e) {
+		return e.reduce((e, t) => e + _e(t), 0);
+	}
+], [
+	"y",
+	["top", "bottom"],
+	function(e) {
+		return e.reduce((e, t) => e + W(t), 0);
+	}
+]], we = class {
+	constructor(e, t) {
+		this.rect = void 0, this.width = void 0, this.height = void 0, this.top = void 0, this.bottom = void 0, this.right = void 0, this.left = void 0;
+		let n = me(t), r = Se(n);
+		this.rect = { ...e }, this.width = e.width, this.height = e.height;
+		for (let [e, t, i] of Ce) for (let a of t) Object.defineProperty(this, a, {
+			get: () => {
+				let t = i(n), o = r[e] - t;
+				return this.rect[a] + o;
+			},
+			enumerable: !0
+		});
+		Object.defineProperty(this, "rect", { enumerable: !1 });
+	}
+}, Y = class {
+	constructor(e) {
+		this.target = void 0, this.listeners = [], this.removeAll = () => {
+			this.listeners.forEach((e) => this.target?.removeEventListener(...e));
+		}, this.target = e;
+	}
+	add(e, t, n) {
+		var r;
+		(r = this.target) == null || r.addEventListener(e, t, n), this.listeners.push([
+			e,
+			t,
+			n
+		]);
+	}
+};
+function Te(e, t) {
+	let n = Math.abs(e.x), r = Math.abs(e.y);
+	return typeof t == "number" ? Math.sqrt(n ** 2 + r ** 2) > t : "x" in t && "y" in t ? n > t.x && r > t.y : "x" in t ? n > t.x : "y" in t && r > t.y;
+}
+function Ee(e) {
+	e.preventDefault();
+}
+function X(e) {
+	e.stopPropagation();
+}
+(function(e) {
+	e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(G ||= {}), function(e) {
+	e.Space = "Space", e.Down = "ArrowDown", e.Right = "ArrowRight", e.Left = "ArrowLeft", e.Up = "ArrowUp", e.Esc = "Escape", e.Enter = "Enter", e.Tab = "Tab";
+}(K ||= {});
+var De = {
+	start: [K.Space, K.Enter],
+	cancel: [K.Esc],
+	end: [
+		K.Space,
+		K.Enter,
+		K.Tab
+	]
+}, Oe = (e, t) => {
+	let { currentCoordinates: n } = t;
+	switch (e.code) {
+		case K.Right: return {
+			...n,
+			x: n.x + 25
+		};
+		case K.Left: return {
+			...n,
+			x: n.x - 25
+		};
+		case K.Down: return {
+			...n,
+			y: n.y + 25
+		};
+		case K.Up: return {
+			...n,
+			y: n.y - 25
+		};
+	}
+}, ke = class {
+	constructor(e) {
+		this.props = void 0, this.autoScrollEnabled = !1, this.referenceCoordinates = void 0, this.listeners = void 0, this.windowListeners = void 0, this.props = e;
+		let { event: { target: t } } = e;
+		this.props = e, this.listeners = new Y(g(t)), this.windowListeners = new Y(f(t)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+	}
+	attach() {
+		this.handleStart(), this.windowListeners.add(G.Resize, this.handleCancel), this.windowListeners.add(G.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(G.Keydown, this.handleKeyDown));
+	}
+	handleStart() {
+		let { activeNode: e, onStart: t } = this.props, n = e.node.current;
+		n && function(e, t) {
+			if (t === void 0 && (t = fe), !e) return;
+			let { top: n, left: r, bottom: i, right: a } = t(e);
+			he(e) && (i <= 0 || a <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+				block: "center",
+				inline: "center"
+			});
+		}(n), t(I);
+	}
+	handleKeyDown(e) {
+		if (O(e)) {
+			let { active: t, context: n, options: r } = this.props, { keyboardCodes: i = De, coordinateGetter: a = Oe, scrollBehavior: o = "smooth" } = r, { code: s } = e;
+			if (i.end.includes(s)) return void this.handleEnd(e);
+			if (i.cancel.includes(s)) return void this.handleCancel(e);
+			let { collisionRect: c } = n.current, l = c ? {
+				x: c.left,
+				y: c.top
+			} : I;
+			this.referenceCoordinates ||= l;
+			let u = a(e, {
+				active: t,
+				context: n.current,
+				currentCoordinates: l
+			});
+			if (u) {
+				let t = D(u, l), r = {
+					x: 0,
+					y: 0
+				}, { scrollableAncestors: i } = n.current;
+				for (let n of i) {
+					let i = e.code, { isTop: a, isRight: s, isLeft: c, isBottom: l, maxScroll: d, minScroll: f } = be(n), p = J(n), m = {
+						x: Math.min(i === K.Right ? p.right - p.width / 2 : p.right, Math.max(i === K.Right ? p.left : p.left + p.width / 2, u.x)),
+						y: Math.min(i === K.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(i === K.Down ? p.top : p.top + p.height / 2, u.y))
+					}, h = i === K.Right && !s || i === K.Left && !c, g = i === K.Down && !l || i === K.Up && !a;
+					if (h && m.x !== u.x) {
+						let e = n.scrollLeft + t.x, a = i === K.Right && e <= d.x || i === K.Left && e >= f.x;
+						if (a && !t.y) return void n.scrollTo({
+							left: e,
+							behavior: o
+						});
+						r.x = a ? n.scrollLeft - e : i === K.Right ? n.scrollLeft - d.x : n.scrollLeft - f.x, r.x && n.scrollBy({
+							left: -r.x,
+							behavior: o
+						});
+						break;
+					}
+					if (g && m.y !== u.y) {
+						let e = n.scrollTop + t.y, a = i === K.Down && e <= d.y || i === K.Up && e >= f.y;
+						if (a && !t.x) return void n.scrollTo({
+							top: e,
+							behavior: o
+						});
+						r.y = a ? n.scrollTop - e : i === K.Down ? n.scrollTop - d.y : n.scrollTop - f.y, r.y && n.scrollBy({
+							top: -r.y,
+							behavior: o
+						});
+						break;
+					}
+				}
+				this.handleMove(e, E(D(u, this.referenceCoordinates), r));
+			}
+		}
+	}
+	handleMove(e, t) {
+		let { onMove: n } = this.props;
+		e.preventDefault(), n(t);
+	}
+	handleEnd(e) {
+		let { onEnd: t } = this.props;
+		e.preventDefault(), this.detach(), t();
+	}
+	handleCancel(e) {
+		let { onCancel: t } = this.props;
+		e.preventDefault(), this.detach(), t();
+	}
+	detach() {
+		this.listeners.removeAll(), this.windowListeners.removeAll();
+	}
+};
+function Ae(e) {
+	return !(!e || !("distance" in e));
+}
+function je(e) {
+	return !(!e || !("delay" in e));
+}
+ke.activators = [{
+	eventName: "onKeyDown",
+	handler: (e, t, n) => {
+		let { keyboardCodes: r = De, onActivation: i } = t, { active: a } = n, { code: o } = e.nativeEvent;
+		if (r.start.includes(o)) {
+			let t = a.activatorNode.current;
+			return !(t && e.target !== t || (e.preventDefault(), i?.({ event: e.nativeEvent }), 0));
+		}
+		return !1;
+	}
+}];
+var Me, Z = class {
+	constructor(e, t, n) {
+		n === void 0 && (n = function(e) {
+			let { EventTarget: t } = f(e);
+			return e instanceof t ? e : g(e);
+		}(e.event.target)), this.props = void 0, this.events = void 0, this.autoScrollEnabled = !0, this.document = void 0, this.activated = !1, this.initialCoordinates = void 0, this.timeoutId = null, this.listeners = void 0, this.documentListeners = void 0, this.windowListeners = void 0, this.props = e, this.events = t;
+		let { event: r } = e, { target: i } = r;
+		this.props = e, this.events = t, this.document = g(i), this.documentListeners = new Y(this.document), this.listeners = new Y(n), this.windowListeners = new Y(f(i)), this.initialCoordinates = ee(r) ?? I, this.handleStart = this.handleStart.bind(this), this.handleMove = this.handleMove.bind(this), this.handleEnd = this.handleEnd.bind(this), this.handleCancel = this.handleCancel.bind(this), this.handleKeydown = this.handleKeydown.bind(this), this.removeTextSelection = this.removeTextSelection.bind(this), this.attach();
+	}
+	attach() {
+		let { events: e, props: { options: { activationConstraint: t, bypassActivationConstraint: n } } } = this;
+		if (this.listeners.add(e.move.name, this.handleMove, { passive: !1 }), this.listeners.add(e.end.name, this.handleEnd), e.cancel && this.listeners.add(e.cancel.name, this.handleCancel), this.windowListeners.add(G.Resize, this.handleCancel), this.windowListeners.add(G.DragStart, Ee), this.windowListeners.add(G.VisibilityChange, this.handleCancel), this.windowListeners.add(G.ContextMenu, Ee), this.documentListeners.add(G.Keydown, this.handleKeydown), t) {
+			if (n != null && n({
+				event: this.props.event,
+				activeNode: this.props.activeNode,
+				options: this.props.options
+			})) return this.handleStart();
+			if (je(t)) return this.timeoutId = setTimeout(this.handleStart, t.delay), void this.handlePending(t);
+			if (Ae(t)) return void this.handlePending(t);
+		}
+		this.handleStart();
+	}
+	detach() {
+		this.listeners.removeAll(), this.windowListeners.removeAll(), setTimeout(this.documentListeners.removeAll, 50), this.timeoutId !== null && (clearTimeout(this.timeoutId), this.timeoutId = null);
+	}
+	handlePending(e, t) {
+		let { active: n, onPending: r } = this.props;
+		r(n, e, this.initialCoordinates, t);
+	}
+	handleStart() {
+		let { initialCoordinates: e } = this, { onStart: t } = this.props;
+		e && (this.activated = !0, this.documentListeners.add(G.Click, X, { capture: !0 }), this.removeTextSelection(), this.documentListeners.add(G.SelectionChange, this.removeTextSelection), t(e));
+	}
+	handleMove(e) {
+		let { activated: t, initialCoordinates: n, props: r } = this, { onMove: i, options: { activationConstraint: a } } = r;
+		if (!n) return;
+		let o = ee(e) ?? I, s = D(n, o);
+		if (!t && a) {
+			if (Ae(a)) {
+				if (a.tolerance != null && Te(s, a.tolerance)) return this.handleCancel();
+				if (Te(s, a.distance)) return this.handleStart();
+			}
+			return je(a) && Te(s, a.tolerance) ? this.handleCancel() : void this.handlePending(a, s);
+		}
+		e.cancelable && e.preventDefault(), i(o);
+	}
+	handleEnd() {
+		let { onAbort: e, onEnd: t } = this.props;
+		this.detach(), this.activated || e(this.props.active), t();
+	}
+	handleCancel() {
+		let { onAbort: e, onCancel: t } = this.props;
+		this.detach(), this.activated || e(this.props.active), t();
+	}
+	handleKeydown(e) {
+		e.code === K.Esc && this.handleCancel();
+	}
+	removeTextSelection() {
+		var e;
+		(e = this.document.getSelection()) == null || e.removeAllRanges();
+	}
+}, Q = {
+	cancel: { name: "pointercancel" },
+	move: { name: "pointermove" },
+	end: { name: "pointerup" }
+}, Ne = class extends Z {
+	constructor(e) {
+		let { event: t } = e, n = g(t.target);
+		super(e, Q, n);
+	}
+};
+Ne.activators = [{
+	eventName: "onPointerDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return !(!n.isPrimary || n.button !== 0 || (r?.({ event: n }), 0));
+	}
+}];
+var Pe = {
+	move: { name: "mousemove" },
+	end: { name: "mouseup" }
+};
+(function(e) {
+	e[e.RightClick = 2] = "RightClick";
+})(Me ||= {});
+var $, Fe, Ie = class extends Z {
+	constructor(e) {
+		super(e, Pe, g(e.event.target));
+	}
+};
+Ie.activators = [{
+	eventName: "onMouseDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return n.button !== Me.RightClick && (r?.({ event: n }), !0);
+	}
+}];
+var Le, Re, ze = {
+	cancel: { name: "touchcancel" },
+	move: { name: "touchmove" },
+	end: { name: "touchend" }
+}, Be = class extends Z {
+	constructor(e) {
+		super(e, ze);
+	}
+	static setup() {
+		return window.addEventListener(ze.move.name, e, {
+			capture: !1,
+			passive: !1
+		}), function() {
+			window.removeEventListener(ze.move.name, e);
+		};
+		function e() {}
+	}
+};
+function Ve(e) {
+	let { acceleration: t, activator: n = $.Pointer, canScroll: r, draggingRect: i, enabled: a, interval: s = 5, order: c = Fe.TreeOrder, pointerCoordinates: l, scrollableAncestors: u, scrollableAncestorRects: d, delta: f, threshold: p } = e, m = function(e) {
+		let { delta: t, disabled: n } = e, r = S(t);
+		return b((e) => {
+			if (n || !r || !e) return He;
+			let i = Math.sign(t.x - r.x), a = Math.sign(t.y - r.y);
+			return {
+				x: {
+					[U.Backward]: e.x[U.Backward] || i === -1,
+					[U.Forward]: e.x[U.Forward] || i === 1
+				},
+				y: {
+					[U.Backward]: e.y[U.Backward] || a === -1,
+					[U.Forward]: e.y[U.Forward] || a === 1
+				}
+			};
+		}, [
+			n,
+			t,
+			r
+		]);
+	}({
+		delta: f,
+		disabled: !a
+	}), [h, g] = function() {
+		let e = (0, o.useRef)(null);
+		return [(0, o.useCallback)((t, n) => {
+			e.current = setInterval(t, n);
+		}, []), (0, o.useCallback)(() => {
+			e.current !== null && (clearInterval(e.current), e.current = null);
+		}, [])];
+	}(), _ = (0, o.useRef)({
+		x: 0,
+		y: 0
+	}), v = (0, o.useRef)({
+		x: 0,
+		y: 0
+	}), y = (0, o.useMemo)(() => {
+		switch (n) {
+			case $.Pointer: return l ? {
+				top: l.y,
+				bottom: l.y,
+				left: l.x,
+				right: l.x
+			} : null;
+			case $.DraggableRect: return i;
+		}
+	}, [
+		n,
+		i,
+		l
+	]), x = (0, o.useRef)(null), C = (0, o.useCallback)(() => {
+		let e = x.current;
+		if (!e) return;
+		let t = _.current.x * v.current.x, n = _.current.y * v.current.y;
+		e.scrollBy(t, n);
+	}, []), w = (0, o.useMemo)(() => c === Fe.TreeOrder ? [...u].reverse() : u, [c, u]);
+	(0, o.useEffect)(() => {
+		if (a && u.length && y) {
+			for (let e of w) {
+				if (!1 === r?.(e)) continue;
+				let n = u.indexOf(e), i = d[n];
+				if (!i) continue;
+				let { direction: a, speed: o } = xe(e, i, y, t, p);
+				for (let e of ["x", "y"]) m[e][a[e]] || (o[e] = 0, a[e] = 0);
+				if (o.x > 0 || o.y > 0) return g(), x.current = e, h(C, s), _.current = o, void (v.current = a);
+			}
+			_.current = {
+				x: 0,
+				y: 0
+			}, v.current = {
+				x: 0,
+				y: 0
+			}, g();
+		} else g();
+	}, [
+		t,
+		C,
+		r,
+		g,
+		a,
+		s,
+		JSON.stringify(y),
+		JSON.stringify(m),
+		h,
+		u,
+		w,
+		d,
+		JSON.stringify(p)
+	]);
+}
+Be.activators = [{
+	eventName: "onTouchStart",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t, { touches: i } = n;
+		return !(i.length > 1 || (r?.({ event: n }), 0));
+	}
+}], function(e) {
+	e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+}($ ||= {}), function(e) {
+	e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+}(Fe ||= {});
+var He = {
+	x: {
+		[U.Backward]: !1,
+		[U.Forward]: !1
+	},
+	y: {
+		[U.Backward]: !1,
+		[U.Forward]: !1
+	}
+};
+(function(e) {
+	e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Le ||= {}), (Re ||= {}).Optimized = "optimized";
+var Ue = /* @__PURE__ */ new Map();
+function We(e, t) {
+	return b((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Ge(e) {
+	let { callback: t, disabled: n } = e, r = v(t), i = (0, o.useMemo)(() => {
+		if (n || typeof window > "u" || window.ResizeObserver === void 0) return;
+		let { ResizeObserver: e } = window;
+		return new e(r);
+	}, [n]);
+	return (0, o.useEffect)(() => () => i?.disconnect(), [i]), i;
+}
+function Ke(e) {
+	return new we(fe(e), e);
+}
+function qe(e, t, n) {
+	t === void 0 && (t = Ke);
+	let [r, i] = (0, o.useState)(null);
+	function a() {
+		i((r) => {
+			if (!e) return null;
+			if (!1 === e.isConnected) return r ?? n ?? null;
+			let i = t(e);
+			return JSON.stringify(r) === JSON.stringify(i) ? r : i;
+		});
+	}
+	let s = function(e) {
+		let { callback: t, disabled: n } = e, r = v(t), i = (0, o.useMemo)(() => {
+			if (n || typeof window > "u" || window.MutationObserver === void 0) return;
+			let { MutationObserver: e } = window;
+			return new e(r);
+		}, [r, n]);
+		return (0, o.useEffect)(() => () => i?.disconnect(), [i]), i;
+	}({ callback(t) {
+		if (e) for (let n of t) {
+			let { type: t, target: r } = n;
+			if (t === "childList" && r instanceof HTMLElement && r.contains(e)) {
+				a();
+				break;
+			}
+		}
+	} }), c = Ge({ callback: a });
+	return _(() => {
+		a(), e ? (c?.observe(e), s?.observe(document.body, {
+			childList: !0,
+			subtree: !0
+		})) : (c?.disconnect(), s?.disconnect());
+	}, [e]), r;
+}
+var Je = [];
+function Ye(e, t) {
+	t === void 0 && (t = []);
+	let n = (0, o.useRef)(null);
+	return (0, o.useEffect)(() => {
+		n.current = null;
+	}, t), (0, o.useEffect)(() => {
+		let t = e !== I;
+		t && !n.current && (n.current = e), !t && n.current && (n.current = null);
+	}, [e]), n.current ? D(e, n.current) : I;
+}
+function Xe(e) {
+	return (0, o.useMemo)(() => e ? function(e) {
+		let t = e.innerWidth, n = e.innerHeight;
+		return {
+			top: 0,
+			left: 0,
+			right: t,
+			bottom: n,
+			width: t,
+			height: n
+		};
+	}(e) : null, [e]);
+}
+var Ze = [];
+function Qe(e) {
+	let { measure: t } = e, [n, r] = (0, o.useState)(null), i = Ge({ callback: (0, o.useCallback)((e) => {
+		for (let { target: n } of e) if (m(n)) {
+			r((e) => {
+				let r = t(n);
+				return e ? {
+					...e,
+					width: r.width,
+					height: r.height
+				} : r;
+			});
+			break;
+		}
+	}, [t]) }), [a, s] = x((0, o.useCallback)((e) => {
+		let n = function(e) {
+			if (!e) return null;
+			if (e.children.length > 1) return e;
+			let t = e.children[0];
+			return m(t) ? t : e;
+		}(e);
+		i?.disconnect(), n && i?.observe(n), r(n ? t(n) : null);
+	}, [t, i]));
+	return (0, o.useMemo)(() => ({
+		nodeRef: a,
+		rect: n,
+		setRef: s
+	}), [
+		n,
+		a,
+		s
+	]);
+}
+var $e, et = [{
+	sensor: Ne,
+	options: {}
+}, {
+	sensor: ke,
+	options: {}
+}], tt = { current: {} }, nt = {
+	draggable: { measure: pe },
+	droppable: {
+		measure: pe,
+		strategy: Le.WhileDragging,
+		frequency: Re.Optimized
+	},
+	dragOverlay: { measure: fe }
+}, rt = class extends Map {
+	get(e) {
+		var t;
+		return e != null && (t = super.get(e)) != null ? t : void 0;
+	}
+	toArray() {
+		return Array.from(this.values());
+	}
+	getEnabled() {
+		return this.toArray().filter((e) => {
+			let { disabled: t } = e;
+			return !t;
+		});
+	}
+	getNodeFor(e) {
+		return this.get(e)?.node.current ?? void 0;
+	}
+}, it = {
+	activatorEvent: null,
+	active: null,
+	activeNode: null,
+	activeNodeRect: null,
+	collisions: null,
+	containerNodeRect: null,
+	draggableNodes: /* @__PURE__ */ new Map(),
+	droppableRects: /* @__PURE__ */ new Map(),
+	droppableContainers: new rt(),
+	over: null,
+	dragOverlay: {
+		nodeRef: { current: null },
+		rect: null,
+		setRef: F
+	},
+	scrollableAncestors: [],
+	scrollableAncestorRects: [],
+	measuringConfiguration: nt,
+	measureDroppableContainers: F,
+	windowRect: null,
+	measuringScheduled: !1
+}, at = (0, o.createContext)({
+	activatorEvent: null,
+	activators: [],
+	active: null,
+	activeNodeRect: null,
+	ariaDescribedById: { draggable: "" },
+	dispatch: F,
+	draggableNodes: /* @__PURE__ */ new Map(),
+	over: null,
+	measureDroppableContainers: F
+}), ot = (0, o.createContext)(it);
+function st() {
+	return {
+		draggable: {
+			active: null,
+			initialCoordinates: {
+				x: 0,
+				y: 0
+			},
+			nodes: /* @__PURE__ */ new Map(),
+			translate: {
+				x: 0,
+				y: 0
+			}
+		},
+		droppable: { containers: new rt() }
+	};
+}
+function ct(e, t) {
+	switch (t.type) {
+		case M.DragStart: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				initialCoordinates: t.initialCoordinates,
+				active: t.active
+			}
+		};
+		case M.DragMove: return e.draggable.active == null ? e : {
+			...e,
+			draggable: {
+				...e.draggable,
+				translate: {
+					x: t.coordinates.x - e.draggable.initialCoordinates.x,
+					y: t.coordinates.y - e.draggable.initialCoordinates.y
+				}
+			}
+		};
+		case M.DragEnd:
+		case M.DragCancel: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				active: null,
+				initialCoordinates: {
+					x: 0,
+					y: 0
+				},
+				translate: {
+					x: 0,
+					y: 0
+				}
+			}
+		};
+		case M.RegisterDroppable: {
+			let { element: n } = t, { id: r } = n, i = new rt(e.droppable.containers);
+			return i.set(r, n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: i
+				}
+			};
+		}
+		case M.SetDroppableDisabled: {
+			let { id: n, key: r, disabled: i } = t, a = e.droppable.containers.get(n);
+			if (!a || r !== a.key) return e;
+			let o = new rt(e.droppable.containers);
+			return o.set(n, {
+				...a,
+				disabled: i
+			}), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: o
+				}
+			};
+		}
+		case M.UnregisterDroppable: {
+			let { id: n, key: r } = t, i = e.droppable.containers.get(n);
+			if (!i || r !== i.key) return e;
+			let a = new rt(e.droppable.containers);
+			return a.delete(n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: a
+				}
+			};
+		}
+		default: return e;
+	}
+}
+function lt(e) {
+	let { disabled: t } = e, { active: n, activatorEvent: r, draggableNodes: i } = (0, o.useContext)(at), a = S(r), s = S(n?.id);
+	return (0, o.useEffect)(() => {
+		if (!t && !r && a && s != null) {
+			if (!O(a) || document.activeElement === a.target) return;
+			let e = i.get(s);
+			if (!e) return;
+			let { activatorNode: t, node: n } = e;
+			if (!t.current && !n.current) return;
+			requestAnimationFrame(() => {
+				for (let e of [t.current, n.current]) {
+					if (!e) continue;
+					let t = ne(e);
+					if (t) {
+						t.focus();
+						break;
+					}
+				}
+			});
+		}
+	}, [
+		r,
+		t,
+		i,
+		s,
+		a
+	]), null;
+}
+var ut = (0, o.createContext)({
+	...I,
+	scaleX: 1,
+	scaleY: 1
+});
+(function(e) {
+	e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})($e ||= {});
+var dt = (0, o.memo)(function(e) {
+	let { id: t, accessibility: n, autoScroll: r = !0, children: i, sensors: a = et, collisionDetection: s = V, measuring: u, modifiers: d, ...p } = e, [m, h] = (0, o.useReducer)(ct, void 0, st), [g, v] = function() {
+		let [e] = (0, o.useState)(() => /* @__PURE__ */ new Set()), t = (0, o.useCallback)((t) => (e.add(t), () => e.delete(t)), [e]);
+		return [(0, o.useCallback)((t) => {
+			let { type: n, event: r } = t;
+			e.forEach((e) => e[n]?.call(e, r));
+		}, [e]), t];
+	}(), [x, S] = (0, o.useState)($e.Uninitialized), C = x === $e.Initialized, { draggable: { active: T, nodes: D, translate: O }, droppable: { containers: k } } = m, te = T == null ? null : D.get(T), ne = (0, o.useRef)({
+		initial: null,
+		translated: null
+	}), A = (0, o.useMemo)(() => T == null ? null : {
+		id: T,
+		data: te?.data ?? tt,
+		rect: ne
+	}, [T, te]), j = (0, o.useRef)(null), [re, N] = (0, o.useState)(null), [P, ae] = (0, o.useState)(null), F = y(p, Object.values(p)), se = w("DndDescribedBy", t), ce = (0, o.useMemo)(() => k.getEnabled(), [k]), L = (0, o.useMemo)(() => ({
+		draggable: {
+			...nt.draggable,
+			...R?.draggable
+		},
+		droppable: {
+			...nt.droppable,
+			...R?.droppable
+		},
+		dragOverlay: {
+			...nt.dragOverlay,
+			...R?.dragOverlay
+		}
+	}), [
+		(R = u)?.draggable,
+		R?.droppable,
+		R?.dragOverlay
+	]);
+	var R;
+	let { droppableRects: z, measureDroppableContainers: le, measuringScheduled: B } = function(e, t) {
+		let { dragging: n, dependencies: r, config: i } = t, [a, s] = (0, o.useState)(null), { frequency: c, measure: l, strategy: u } = i, d = (0, o.useRef)(e), f = function() {
+			switch (u) {
+				case Le.Always: return !1;
+				case Le.BeforeDragging: return n;
+				default: return !n;
+			}
+		}(), p = y(f), m = (0, o.useCallback)(function(e) {
+			e === void 0 && (e = []), p.current || s((t) => t === null ? e : t.concat(e.filter((e) => !t.includes(e))));
+		}, [p]), h = (0, o.useRef)(null), g = b((t) => {
+			if (f && !n) return Ue;
+			if (!t || t === Ue || d.current !== e || a != null) {
+				let t = /* @__PURE__ */ new Map();
+				for (let n of e) {
+					if (!n) continue;
+					if (a && a.length > 0 && !a.includes(n.id) && n.rect.current) {
+						t.set(n.id, n.rect.current);
+						continue;
+					}
+					let e = n.node.current, r = e ? new we(l(e), e) : null;
+					n.rect.current = r, r && t.set(n.id, r);
+				}
+				return t;
+			}
+			return t;
+		}, [
+			e,
+			a,
+			n,
+			f,
+			l
+		]);
+		return (0, o.useEffect)(() => {
+			d.current = e;
+		}, [e]), (0, o.useEffect)(() => {
+			f || m();
+		}, [n, f]), (0, o.useEffect)(() => {
+			a && a.length > 0 && s(null);
+		}, [JSON.stringify(a)]), (0, o.useEffect)(() => {
+			f || typeof c != "number" || h.current !== null || (h.current = setTimeout(() => {
+				m(), h.current = null;
+			}, c));
+		}, [
+			c,
+			f,
+			m,
+			...r
+		]), {
+			droppableRects: g,
+			measureDroppableContainers: m,
+			measuringScheduled: a != null
+		};
+	}(ce, {
+		dragging: C,
+		dependencies: [O.x, O.y],
+		config: L.droppable
+	}), U = function(e, t) {
+		let n = t == null ? void 0 : e.get(t), r = n ? n.node.current : null;
+		return b((e) => t == null ? null : r ?? e ?? null, [r, t]);
+	}(D, T), de = (0, o.useMemo)(() => P ? ee(P) : null, [P]), pe = function() {
+		let e = !1 === re?.autoScrollEnabled, t = typeof r == "object" ? !1 === r.enabled : !1 === r, n = C && !e && !t;
+		return typeof r == "object" ? {
+			...r,
+			enabled: n
+		} : { enabled: n };
+	}(), _e = function(e, t) {
+		return We(e, t);
+	}(U, L.draggable.measure);
+	(function(e) {
+		let { activeNode: t, measure: n, initialRect: r, config: i = !0 } = e, a = (0, o.useRef)(!1), { x: s, y: c } = typeof i == "boolean" ? {
+			x: i,
+			y: i
+		} : i;
+		_(() => {
+			if (!s && !c || !t) return void (a.current = !1);
+			if (a.current || !r) return;
+			let e = t?.node.current;
+			if (!e || !1 === e.isConnected) return;
+			let i = H(n(e), r);
+			if (s || (i.x = 0), c || (i.y = 0), a.current = !0, Math.abs(i.x) > 0 || Math.abs(i.y) > 0) {
+				let t = he(e);
+				t && t.scrollBy({
+					top: i.y,
+					left: i.x
+				});
+			}
+		}, [
+			t,
+			s,
+			c,
+			r,
+			n
+		]);
+	})({
+		activeNode: T == null ? null : D.get(T),
+		config: pe.layoutShiftCompensation,
+		initialRect: _e,
+		measure: L.draggable.measure
+	});
+	let W = qe(U, L.draggable.measure, _e), be = qe(U ? U.parentElement : null), G = (0, o.useRef)({
+		activatorEvent: null,
+		active: null,
+		activeNode: U,
+		collisionRect: null,
+		collisions: null,
+		droppableRects: z,
+		draggableNodes: D,
+		draggingNode: null,
+		draggingNodeRect: null,
+		droppableContainers: k,
+		over: null,
+		scrollableAncestors: [],
+		scrollAdjustedTranslate: null
+	}), K = k.getNodeFor(G.current.over?.id), q = Qe({ measure: L.dragOverlay.measure }), xe = q.nodeRef.current ?? U, J = C ? q.rect ?? W : null, Ce = !(!q.nodeRef.current || !q.rect), Y = H(Te = Ce ? null : W, We(Te));
+	var Te;
+	let Ee = Xe(xe ? f(xe) : null), X = function(e) {
+		let t = (0, o.useRef)(e), n = b((n) => e ? n && n !== Je && e && t.current && e.parentNode === t.current.parentNode ? n : me(e) : Je, [e]);
+		return (0, o.useEffect)(() => {
+			t.current = e;
+		}, [e]), n;
+	}(C ? K ?? U : null), De = function(e, t) {
+		t === void 0 && (t = fe);
+		let [n] = e, r = Xe(n ? f(n) : null), [i, a] = (0, o.useState)(Ze);
+		function s() {
+			a(() => e.length ? e.map((e) => ye(e) ? r : new we(t(e), e)) : Ze);
+		}
+		let c = Ge({ callback: s });
+		return _(() => {
+			c?.disconnect(), s(), e.forEach((e) => c?.observe(e));
+		}, [e]), i;
+	}(X), Oe = function(e, t) {
+		let { transform: n, ...r } = t;
+		return e != null && e.length ? e.reduce((e, t) => t({
+			transform: e,
+			...r
+		}), n) : n;
+	}(d, {
+		transform: {
+			x: O.x - Y.x,
+			y: O.y - Y.y,
+			scaleX: 1,
+			scaleY: 1
+		},
+		activatorEvent: P,
+		active: A,
+		activeNodeRect: W,
+		containerNodeRect: be,
+		draggingNodeRect: J,
+		over: G.current.over,
+		overlayNodeRect: q.rect,
+		scrollableAncestors: X,
+		scrollableAncestorRects: De,
+		windowRect: Ee
+	}), ke = de ? E(de, O) : null, Ae = function(e) {
+		let [t, n] = (0, o.useState)(null), r = (0, o.useRef)(e), i = (0, o.useCallback)((e) => {
+			let t = ge(e.target);
+			t && n((e) => e ? (e.set(t, ve(t)), new Map(e)) : null);
+		}, []);
+		return (0, o.useEffect)(() => {
+			let t = r.current;
+			if (e !== t) {
+				a(t);
+				let o = e.map((e) => {
+					let t = ge(e);
+					return t ? (t.addEventListener("scroll", i, { passive: !0 }), [t, ve(t)]) : null;
+				}).filter((e) => e != null);
+				n(o.length ? new Map(o) : null), r.current = e;
+			}
+			return () => {
+				a(e), a(t);
+			};
+			function a(e) {
+				e.forEach((e) => {
+					ge(e)?.removeEventListener("scroll", i);
+				});
+			}
+		}, [i, e]), (0, o.useMemo)(() => e.length ? t ? Array.from(t.values()).reduce((e, t) => E(e, t), I) : Se(e) : I, [e, t]);
+	}(X), je = Ye(Ae), Me = Ye(Ae, [W]), Z = E(Oe, je), Q = J ? ue(J, Oe) : null, Ne = A && Q ? s({
+		active: A,
+		collisionRect: Q,
+		droppableRects: z,
+		droppableContainers: ce,
+		pointerCoordinates: ke
+	}) : null, Pe = function(e) {
+		if (!e || e.length === 0) return null;
+		let [t] = e;
+		return t.id;
+	}(Ne), [$, Fe] = (0, o.useState)(null), Ie = function(e, t, n) {
+		return {
+			...e,
+			scaleX: t && n ? t.width / n.width : 1,
+			scaleY: t && n ? t.height / n.height : 1
+		};
+	}(Ce ? Oe : E(Oe, Me), $?.rect ?? null, W), Re = (0, o.useRef)(null), ze = (0, o.useCallback)((e, t) => {
+		let { sensor: n, options: r } = t;
+		if (j.current == null) return;
+		let i = D.get(j.current);
+		if (!i) return;
+		let a = e.nativeEvent, o = new n({
+			active: j.current,
+			activeNode: i,
+			event: a,
+			options: r,
+			context: G,
+			onAbort(e) {
+				if (!D.get(e)) return;
+				let { onDragAbort: t } = F.current, n = { id: e };
+				t?.(n), g({
+					type: "onDragAbort",
+					event: n
+				});
+			},
+			onPending(e, t, n, r) {
+				if (!D.get(e)) return;
+				let { onDragPending: i } = F.current, a = {
+					id: e,
+					constraint: t,
+					initialCoordinates: n,
+					offset: r
+				};
+				i?.(a), g({
+					type: "onDragPending",
+					event: a
+				});
+			},
+			onStart(e) {
+				let t = j.current;
+				if (t == null) return;
+				let n = D.get(t);
+				if (!n) return;
+				let { onDragStart: r } = F.current, i = {
+					activatorEvent: a,
+					active: {
+						id: t,
+						data: n.data,
+						rect: ne
+					}
+				};
+				(0, c.unstable_batchedUpdates)(() => {
+					r?.(i), S($e.Initializing), h({
+						type: M.DragStart,
+						initialCoordinates: e,
+						active: t
+					}), g({
+						type: "onDragStart",
+						event: i
+					}), N(Re.current), ae(a);
+				});
+			},
+			onMove(e) {
+				h({
+					type: M.DragMove,
+					coordinates: e
+				});
+			},
+			onEnd: s(M.DragEnd),
+			onCancel: s(M.DragCancel)
+		});
+		function s(e) {
+			return async function() {
+				let { active: t, collisions: n, over: r, scrollAdjustedTranslate: i } = G.current, o = null;
+				if (t && i) {
+					let { cancelDrop: s } = F.current;
+					o = {
+						activatorEvent: a,
+						active: t,
+						collisions: n,
+						delta: i,
+						over: r
+					}, e === M.DragEnd && typeof s == "function" && await Promise.resolve(s(o)) && (e = M.DragCancel);
+				}
+				j.current = null, (0, c.unstable_batchedUpdates)(() => {
+					h({ type: e }), S($e.Uninitialized), Fe(null), N(null), ae(null), Re.current = null;
+					let t = e === M.DragEnd ? "onDragEnd" : "onDragCancel";
+					if (o) {
+						let e = F.current[t];
+						e?.(o), g({
+							type: t,
+							event: o
+						});
+					}
+				});
+			};
+		}
+		Re.current = o;
+	}, [D]), Be = function(e, t) {
+		return (0, o.useMemo)(() => e.reduce((e, n) => {
+			let { sensor: r } = n;
+			return [...e, ...r.activators.map((e) => ({
+				eventName: e.eventName,
+				handler: t(e.handler, n)
+			}))];
+		}, []), [e, t]);
+	}(a, (0, o.useCallback)((e, t) => (n, r) => {
+		let i = n.nativeEvent, a = D.get(r);
+		if (j.current !== null || !a || i.dndKit || i.defaultPrevented) return;
+		let o = { active: a };
+		!0 === e(n, t.options, o) && (i.dndKit = { capturedBy: t.sensor }, j.current = r, ze(n, t));
+	}, [D, ze]));
+	(function(e) {
+		(0, o.useEffect)(() => {
+			if (!l) return;
+			let t = e.map((e) => {
+				let { sensor: t } = e;
+				return t.setup == null ? void 0 : t.setup();
+			});
+			return () => {
+				for (let e of t) e?.();
+			};
+		}, e.map((e) => {
+			let { sensor: t } = e;
+			return t;
+		}));
+	})(a), _(() => {
+		W && x === $e.Initializing && S($e.Initialized);
+	}, [W, x]), (0, o.useEffect)(() => {
+		let { onDragMove: e } = F.current, { active: t, activatorEvent: n, collisions: r, over: i } = G.current;
+		if (!t || !n) return;
+		let a = {
+			active: t,
+			activatorEvent: n,
+			collisions: r,
+			delta: {
+				x: Z.x,
+				y: Z.y
+			},
+			over: i
+		};
+		(0, c.unstable_batchedUpdates)(() => {
+			e?.(a), g({
+				type: "onDragMove",
+				event: a
+			});
+		});
+	}, [Z.x, Z.y]), (0, o.useEffect)(() => {
+		let { active: e, activatorEvent: t, collisions: n, droppableContainers: r, scrollAdjustedTranslate: i } = G.current;
+		if (!e || j.current == null || !t || !i) return;
+		let { onDragOver: a } = F.current, o = r.get(Pe), s = o && o.rect.current ? {
+			id: o.id,
+			rect: o.rect.current,
+			data: o.data,
+			disabled: o.disabled
+		} : null, l = {
+			active: e,
+			activatorEvent: t,
+			collisions: n,
+			delta: {
+				x: i.x,
+				y: i.y
+			},
+			over: s
+		};
+		(0, c.unstable_batchedUpdates)(() => {
+			Fe(s), a?.(l), g({
+				type: "onDragOver",
+				event: l
+			});
+		});
+	}, [Pe]), _(() => {
+		G.current = {
+			activatorEvent: P,
+			active: A,
+			activeNode: U,
+			collisionRect: Q,
+			collisions: Ne,
+			droppableRects: z,
+			draggableNodes: D,
+			draggingNode: xe,
+			draggingNodeRect: J,
+			droppableContainers: k,
+			over: $,
+			scrollableAncestors: X,
+			scrollAdjustedTranslate: Z
+		}, ne.current = {
+			initial: J,
+			translated: Q
+		};
+	}, [
+		A,
+		U,
+		Ne,
+		Q,
+		D,
+		xe,
+		J,
+		z,
+		k,
+		$,
+		X,
+		Z
+	]), Ve({
+		...pe,
+		delta: O,
+		draggingRect: Q,
+		pointerCoordinates: ke,
+		scrollableAncestors: X,
+		scrollableAncestorRects: De
+	});
+	let He = (0, o.useMemo)(() => ({
+		active: A,
+		activeNode: U,
+		activeNodeRect: W,
+		activatorEvent: P,
+		collisions: Ne,
+		containerNodeRect: be,
+		dragOverlay: q,
+		draggableNodes: D,
+		droppableContainers: k,
+		droppableRects: z,
+		over: $,
+		measureDroppableContainers: le,
+		scrollableAncestors: X,
+		scrollableAncestorRects: De,
+		measuringConfiguration: L,
+		measuringScheduled: B,
+		windowRect: Ee
+	}), [
+		A,
+		U,
+		W,
+		P,
+		Ne,
+		be,
+		q,
+		D,
+		k,
+		z,
+		$,
+		le,
+		X,
+		De,
+		L,
+		B,
+		Ee
+	]), Ke = (0, o.useMemo)(() => ({
+		activatorEvent: P,
+		activators: Be,
+		active: A,
+		activeNodeRect: W,
+		ariaDescribedById: { draggable: se },
+		dispatch: h,
+		draggableNodes: D,
+		over: $,
+		measureDroppableContainers: le
+	}), [
+		P,
+		Be,
+		A,
+		W,
+		h,
+		se,
+		D,
+		$,
+		le
+	]);
+	return o.createElement(ie.Provider, { value: v }, o.createElement(at.Provider, { value: Ke }, o.createElement(ot.Provider, { value: He }, o.createElement(ut.Provider, { value: Ie }, i)), o.createElement(lt, { disabled: !1 === n?.restoreFocus })), o.createElement(oe, {
+		...n,
+		hiddenTextDescribedById: se
+	}));
+}), ft = (0, o.createContext)(null), pt = "button", mt = { timeout: 25 }, ht = (e) => {
+	let { transform: t } = e;
+	return {
+		...t,
+		x: 0
+	};
+};
+function gt(e, t, n) {
+	let r = e.slice();
+	return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function _t(e, t) {
+	return e.reduce((e, n, r) => {
+		let i = t.get(n);
+		return i && (e[r] = i), e;
+	}, Array(e.length));
+}
+function vt(e) {
+	return e !== null && e >= 0;
+}
+var yt = (e) => {
+	let { rects: t, activeIndex: n, overIndex: r, index: i } = e, a = gt(t, r, n), o = t[i], s = a[i];
+	return s && o ? {
+		x: s.left - o.left,
+		y: s.top - o.top,
+		scaleX: s.width / o.width,
+		scaleY: s.height / o.height
+	} : null;
+}, bt = {
+	scaleX: 1,
+	scaleY: 1
+}, xt = (e) => {
+	let { activeIndex: t, activeNodeRect: n, index: r, rects: i, overIndex: a } = e, o = i[t] ?? n;
+	if (!o) return null;
+	if (r === t) {
+		let e = i[a];
+		return e ? {
+			x: 0,
+			y: t < a ? e.top + e.height - (o.top + o.height) : e.top - o.top,
+			...bt
+		} : null;
+	}
+	let s = function(e, t, n) {
+		let r = e[t], i = e[t - 1], a = e[t + 1];
+		return r ? n < t ? i ? r.top - (i.top + i.height) : a ? a.top - (r.top + r.height) : 0 : a ? a.top - (r.top + r.height) : i ? r.top - (i.top + i.height) : 0 : 0;
+	}(i, r, t);
+	return r > t && r <= a ? {
+		x: 0,
+		y: -o.height - s,
+		...bt
+	} : r < t && r >= a ? {
+		x: 0,
+		y: o.height + s,
+		...bt
+	} : {
+		x: 0,
+		y: 0,
+		...bt
+	};
+}, St = "Sortable", Ct = o.createContext({
+	activeIndex: -1,
+	containerId: St,
+	disableTransforms: !1,
+	items: [],
+	overIndex: -1,
+	useDragOverlay: !1,
+	sortedRects: [],
+	strategy: yt,
+	disabled: {
+		draggable: !1,
+		droppable: !1
+	}
+});
+function wt(e) {
+	let { children: t, id: n, items: r, strategy: i = yt, disabled: a = !1 } = e, { active: s, dragOverlay: c, droppableRects: l, over: u, measureDroppableContainers: d } = (0, o.useContext)(ot), f = w(St, n), p = c.rect !== null, m = (0, o.useMemo)(() => r.map((e) => typeof e == "object" && "id" in e ? e.id : e), [r]), h = s != null, g = s ? m.indexOf(s.id) : -1, v = u ? m.indexOf(u.id) : -1, y = (0, o.useRef)(m), b = !function(e, t) {
+		if (e === t) return !0;
+		if (e.length !== t.length) return !1;
+		for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+		return !0;
+	}(m, y.current), x = v !== -1 && g === -1 || b, S = function(e) {
+		return typeof e == "boolean" ? {
+			draggable: e,
+			droppable: e
+		} : e;
+	}(a);
+	_(() => {
+		b && h && d(m);
+	}, [
+		b,
+		m,
+		h,
+		d
+	]), (0, o.useEffect)(() => {
+		y.current = m;
+	}, [m]);
+	let C = (0, o.useMemo)(() => ({
+		activeIndex: g,
+		containerId: f,
+		disabled: S,
+		disableTransforms: x,
+		items: m,
+		overIndex: v,
+		useDragOverlay: p,
+		sortedRects: _t(m, l),
+		strategy: i
+	}), [
+		g,
+		f,
+		S.draggable,
+		S.droppable,
+		x,
+		m,
+		v,
+		l,
+		p,
+		i
+	]);
+	return o.createElement(Ct.Provider, { value: C }, t);
+}
+var Tt = (e) => {
+	let { id: t, items: n, activeIndex: r, overIndex: i } = e;
+	return gt(n, r, i).indexOf(t);
+}, Et = (e) => {
+	let { containerId: t, isSorting: n, wasDragging: r, index: i, items: a, newIndex: o, previousItems: s, previousContainerId: c, transition: l } = e;
+	return !(!l || !r || s !== a && i === o || !n && (o === i || t !== c));
+}, Dt = {
+	duration: 200,
+	easing: "ease"
+}, Ot = "transform", kt = k.Transition.toString({
+	property: Ot,
+	duration: 0,
+	easing: "linear"
+}), At = { roleDescription: "sortable" };
+function jt(e) {
+	let { animateLayoutChanges: t = Et, attributes: n, disabled: r, data: i, getNewIndex: a = Tt, id: s, strategy: c, resizeObserverConfig: l, transition: u = Dt } = e, { items: d, containerId: f, activeIndex: p, disabled: m, disableTransforms: h, sortedRects: g, overIndex: v, useDragOverlay: b, strategy: S } = (0, o.useContext)(Ct), C = function(e, t) {
+		return typeof e == "boolean" ? {
+			draggable: e,
+			droppable: !1
+		} : {
+			draggable: e?.draggable ?? t.draggable,
+			droppable: e?.droppable ?? t.droppable
+		};
+	}(r, m), T = d.indexOf(s), E = (0, o.useMemo)(() => ({
+		sortable: {
+			containerId: f,
+			index: T,
+			items: d
+		},
+		...i
+	}), [
+		f,
+		i,
+		T,
+		d
+	]), D = (0, o.useMemo)(() => d.slice(d.indexOf(s)), [d, s]), { rect: ee, node: te, isOver: ne, setNodeRef: A } = function(e) {
+		let { data: t, disabled: n = !1, id: r, resizeObserverConfig: i } = e, a = w("Droppable"), { active: s, dispatch: c, over: l, measureDroppableContainers: u } = (0, o.useContext)(at), d = (0, o.useRef)({ disabled: n }), f = (0, o.useRef)(!1), p = (0, o.useRef)(null), m = (0, o.useRef)(null), { disabled: h, updateMeasurementsFor: g, timeout: _ } = {
+			...mt,
+			...i
+		}, v = y(g ?? r), b = Ge({
+			callback: (0, o.useCallback)(() => {
+				f.current ? (m.current != null && clearTimeout(m.current), m.current = setTimeout(() => {
+					u(Array.isArray(v.current) ? v.current : [v.current]), m.current = null;
+				}, _)) : f.current = !0;
+			}, [_]),
+			disabled: h || !s
+		}), [S, C] = x((0, o.useCallback)((e, t) => {
+			b && (t && (b.unobserve(t), f.current = !1), e && b.observe(e));
+		}, [b])), T = y(t);
+		return (0, o.useEffect)(() => {
+			b && S.current && (b.disconnect(), f.current = !1, b.observe(S.current));
+		}, [S, b]), (0, o.useEffect)(() => (c({
+			type: M.RegisterDroppable,
+			element: {
+				id: r,
+				key: a,
+				disabled: n,
+				node: S,
+				rect: p,
+				data: T
+			}
+		}), () => c({
+			type: M.UnregisterDroppable,
+			key: a,
+			id: r
+		})), [r]), (0, o.useEffect)(() => {
+			n !== d.current.disabled && (c({
+				type: M.SetDroppableDisabled,
+				id: r,
+				key: a,
+				disabled: n
+			}), d.current.disabled = n);
+		}, [
+			r,
+			a,
+			n,
+			c
+		]), {
+			active: s,
+			rect: p,
+			isOver: l?.id === r,
+			node: S,
+			over: l,
+			setNodeRef: C
+		};
+	}({
+		id: s,
+		data: E,
+		disabled: C.droppable,
+		resizeObserverConfig: {
+			updateMeasurementsFor: D,
+			...l
+		}
+	}), { active: j, activatorEvent: re, activeNodeRect: N, attributes: ie, setNodeRef: P, listeners: ae, isDragging: oe, over: F, setActivatorNodeRef: se, transform: I } = function(e) {
+		let { id: t, data: n, disabled: r = !1, attributes: i } = e, a = w("Draggable"), { activators: s, activatorEvent: c, active: l, activeNodeRect: u, ariaDescribedById: d, draggableNodes: f, over: p } = (0, o.useContext)(at), { role: m = pt, roleDescription: h = "draggable", tabIndex: g = 0 } = i ?? {}, v = l?.id === t, b = (0, o.useContext)(v ? ut : ft), [S, C] = x(), [T, E] = x(), D = function(e, t) {
+			return (0, o.useMemo)(() => e.reduce((e, n) => {
+				let { eventName: r, handler: i } = n;
+				return e[r] = (e) => {
+					i(e, t);
+				}, e;
+			}, {}), [e, t]);
+		}(s, t), O = y(n);
+		return _(() => (f.set(t, {
+			id: t,
+			key: a,
+			node: S,
+			activatorNode: T,
+			data: O
+		}), () => {
+			let e = f.get(t);
+			e && e.key === a && f.delete(t);
+		}), [f, t]), {
+			active: l,
+			activatorEvent: c,
+			activeNodeRect: u,
+			attributes: (0, o.useMemo)(() => ({
+				role: m,
+				tabIndex: g,
+				"aria-disabled": r,
+				"aria-pressed": !(!v || m !== pt) || void 0,
+				"aria-roledescription": h,
+				"aria-describedby": d.draggable
+			}), [
+				r,
+				m,
+				g,
+				v,
+				h,
+				d.draggable
+			]),
+			isDragging: v,
+			listeners: r ? void 0 : D,
+			node: S,
+			over: p,
+			setNodeRef: C,
+			setActivatorNodeRef: E,
+			transform: b
+		};
+	}({
+		id: s,
+		data: E,
+		attributes: {
+			...At,
+			...n
+		},
+		disabled: C.draggable
+	}), ce = function() {
+		var e = [...arguments];
+		return (0, o.useMemo)(() => (t) => {
+			e.forEach((e) => e(t));
+		}, e);
+	}(A, P), L = !!j, R = L && !h && vt(p) && vt(v), z = !b && oe, le = R ? (z && R ? I : null) ?? (c ?? S)({
+		rects: g,
+		activeNodeRect: N,
+		activeIndex: p,
+		overIndex: v,
+		index: T
+	}) : null, B = vt(p) && vt(v) ? a({
+		id: s,
+		items: d,
+		activeIndex: p,
+		overIndex: v
+	}) : T, V = j?.id, H = (0, o.useRef)({
+		activeId: V,
+		items: d,
+		newIndex: B,
+		containerId: f
+	}), U = d !== H.current.items, ue = t({
+		active: j,
+		containerId: f,
+		isDragging: oe,
+		isSorting: L,
+		id: s,
+		index: T,
+		items: d,
+		newIndex: H.current.newIndex,
+		previousItems: H.current.items,
+		previousContainerId: H.current.containerId,
+		transition: u,
+		wasDragging: H.current.activeId != null
+	}), de = function(e) {
+		let { disabled: t, index: n, node: r, rect: i } = e, [a, s] = (0, o.useState)(null), c = (0, o.useRef)(n);
+		return _(() => {
+			if (!t && n !== c.current && r.current) {
+				let e = i.current;
+				if (e) {
+					let t = fe(r.current, { ignoreTransform: !0 }), n = {
+						x: e.left - t.left,
+						y: e.top - t.top,
+						scaleX: e.width / t.width,
+						scaleY: e.height / t.height
+					};
+					(n.x || n.y) && s(n);
+				}
+			}
+			n !== c.current && (c.current = n);
+		}, [
+			t,
+			n,
+			r,
+			i
+		]), (0, o.useEffect)(() => {
+			a && s(null);
+		}, [a]), a;
+	}({
+		disabled: !ue,
+		index: T,
+		node: te,
+		rect: ee
+	});
+	return (0, o.useEffect)(() => {
+		L && H.current.newIndex !== B && (H.current.newIndex = B), f !== H.current.containerId && (H.current.containerId = f), d !== H.current.items && (H.current.items = d);
+	}, [
+		L,
+		B,
+		f,
+		d
+	]), (0, o.useEffect)(() => {
+		if (V === H.current.activeId) return;
+		if (V != null && H.current.activeId == null) return void (H.current.activeId = V);
+		let e = setTimeout(() => {
+			H.current.activeId = V;
+		}, 50);
+		return () => clearTimeout(e);
+	}, [V]), {
+		active: j,
+		activeIndex: p,
+		attributes: ie,
+		data: E,
+		rect: ee,
+		index: T,
+		newIndex: B,
+		items: d,
+		isOver: ne,
+		isSorting: L,
+		isDragging: oe,
+		listeners: ae,
+		node: te,
+		overIndex: v,
+		over: F,
+		setNodeRef: ce,
+		setActivatorNodeRef: se,
+		setDroppableNodeRef: A,
+		setDraggableNodeRef: P,
+		transform: de ?? le,
+		transition: de || U && H.current.newIndex === T ? kt : z && !O(re) || !u || !L && !ue ? void 0 : k.Transition.toString({
+			...u,
+			property: Ot
+		})
+	};
+}
+K.Down, K.Right, K.Up, K.Left;
+var Mt = "data-sxl-flip", Nt = (0, o.memo)((e) => {
+	let { ids: t, onMove: n, scrollRef: r, children: i } = e, a = function() {
+		var e = [...arguments];
+		return (0, o.useMemo)(() => [...e].filter((e) => e != null), [...e]);
+	}(se(Ie, { activationConstraint: { distance: 6 } }), se(Be, { activationConstraint: {
+		delay: 200,
+		tolerance: 6
+	} })), c = (0, o.useRef)(null), l = (0, o.useMemo)(() => [ht, ({ draggingNodeRect: e, transform: t }) => {
+		let n = c.current;
+		return e && n ? e.top + t.y < n.top ? {
+			...t,
+			y: n.top - e.top
+		} : e.bottom + t.y > n.bottom ? {
+			...t,
+			y: n.bottom - e.bottom
+		} : t : t;
+	}], []);
+	return (0, s.jsx)(dt, {
+		sensors: a,
+		collisionDetection: le,
+		modifiers: l,
+		onDragStart: () => {
+			c.current = ((e) => {
+				if (!e) return null;
+				let t = e.querySelectorAll(`[${Mt}]`);
+				if (t.length === 0) return null;
+				let n = 1 / 0, r = -1 / 0;
+				for (let e = 0; e < t.length; e++) {
+					let i = t[e].getBoundingClientRect();
+					i.top < n && (n = i.top), i.bottom > r && (r = i.bottom);
+				}
+				return {
+					top: n,
+					bottom: r
+				};
+			})(r.current);
+		},
+		onDragCancel: () => {
+			c.current = null;
+		},
+		autoScroll: { canScroll: (e) => {
+			if (e === document.scrollingElement || e === document.documentElement || e === document.body) return !1;
+			let t = r.current;
+			return !!t && (e === t || e.contains(t));
+		} },
+		onDragEnd: (e) => {
+			c.current = null;
+			let { active: r, over: i } = e;
+			if (!i || r.id === i.id) return;
+			let a = t.indexOf(String(r.id)), o = t.indexOf(String(i.id));
+			a !== -1 && o !== -1 && a !== o && n(a, o);
+		},
+		children: (0, s.jsx)(wt, {
+			items: t,
+			strategy: xt,
+			children: i
+		})
+	});
+});
+function Pt(e, t, n) {
+	let r = (0, o.useRef)(/* @__PURE__ */ new Map());
+	_(() => {
+		if (!t || !e.current) return void (r.current = /* @__PURE__ */ new Map());
+		let i = r.current, a = /* @__PURE__ */ new Map(), o = [], s = e.current.querySelectorAll(`[${Mt}]`);
+		for (let e = 0; e < s.length; e++) {
+			let t = s[e], n = t.getAttribute(Mt), r = t.offsetTop;
+			a.set(n, r);
+			let c = i.get(n);
+			c !== void 0 && c !== r && o.push({
+				element: t,
+				delta: c - r
+			});
+		}
+		if (r.current = a, o.length !== 0) {
+			if (n.current) n.current = !1;
+			else {
+				for (let { element: e, delta: t } of o) e.style.transition = "none", e.style.transform = `translateY(${t}px)`;
+				e.current.offsetHeight;
+				for (let { element: e } of o) e.style.transition = "transform 200ms ease", e.style.transform = "", e.addEventListener("transitionend", function t() {
+					e.style.transition = "", e.removeEventListener("transitionend", t);
+				});
+			}
+		}
+	});
+}
+Nt.displayName = "SortableCards";
+var Ft = (0, o.memo)((e) => {
+	let { id: t, disabled: n, children: r } = e, { setNodeRef: c, transform: l, transition: u, isDragging: d, listeners: f } = jt({
+		id: t,
+		disabled: n
+	}), p = (0, o.useMemo)(() => {
+		if (!f) return f;
+		let e = {};
+		for (let [t, n] of Object.entries(f)) e[t] = (e, ...t) => {
+			(e?.target)?.closest?.("button, input, textarea, select, a[href], [contenteditable=\"true\"], [role=\"combobox\"]") || n(e, ...t);
+		};
+		return e;
+	}, [f]);
+	return (0, s.jsx)(a, {
+		ref: c,
+		...p,
+		[Mt]: t,
+		className: i("sxl-sortable-card", {
+			"sxl-dragging": d,
+			"sxl-drag-disabled": n
+		}),
+		sx: {
+			flex: "0 0 auto",
+			borderRadius: (e) => e.spacing(1.25),
+			boxShadow: d ? 6 : void 0,
+			...n ? null : {
+				cursor: d ? "grabbing" : "grab",
+				"&:active": { cursor: "grabbing" }
+			},
+			...d ? {
+				"& *": { cursor: "grabbing !important" },
+				backgroundColor: (e) => e.palette.background.paper
+			} : null
+		},
+		style: {
+			transform: k.Translate.toString(l),
+			transition: u,
+			touchAction: "manipulation",
+			...d ? {
+				position: "relative",
+				zIndex: 1
+			} : null
+		},
+		children: r
+	});
+});
+Ft.displayName = "SortableCard";
+export { Ft as n, Nt as r, Pt as t };