@nxgt/material 2.0.1 → 2.2.0

package/dist/sortable-provider-DalccwHj.js

@@ -0,0 +1,2684 @@
+import { t as e, ut as t } from "./icon-button-38As1vrs.js";
+import { t as n } from "./utils-Brj-Qb2N.js";
+import { t as r } from "./use-material-translation-RhoPY_RC.js";
+import { GripVertical as i } from "lucide-react";
+import { jsx as a } from "react/jsx-runtime";
+import o, { cloneElement as s, createContext as c, forwardRef as l, memo as u, useCallback as d, useContext as f, useEffect as p, useLayoutEffect as m, useMemo as h, useReducer as g, useRef as _, useState as v } from "react";
+import { createPortal as y, unstable_batchedUpdates as b } from "react-dom";
+//#region node_modules/@dnd-kit/utilities/dist/utilities.esm.js
+function x() {
+	var e = [...arguments];
+	return h(() => (t) => {
+		e.forEach((e) => e(t));
+	}, e);
+}
+var S = typeof window < "u" && window.document !== void 0 && window.document.createElement !== void 0;
+function C(e) {
+	let t = Object.prototype.toString.call(e);
+	return t === "[object Window]" || t === "[object global]";
+}
+function w(e) {
+	return "nodeType" in e;
+}
+function T(e) {
+	return e ? C(e) ? e : w(e) ? e.ownerDocument?.defaultView ?? window : window : window;
+}
+function E(e) {
+	let { Document: t } = T(e);
+	return e instanceof t;
+}
+function D(e) {
+	return !C(e) && e instanceof T(e).HTMLElement;
+}
+function O(e) {
+	return e instanceof T(e).SVGElement;
+}
+function k(e) {
+	return e ? C(e) ? e.document : w(e) ? E(e) ? e : D(e) || O(e) ? e.ownerDocument : document : document : document;
+}
+var A = S ? m : p;
+function j(e) {
+	let t = _(e);
+	return A(() => {
+		t.current = e;
+	}), d(function() {
+		var e = [...arguments];
+		return t.current == null ? void 0 : t.current(...e);
+	}, []);
+}
+function M() {
+	let e = _(null);
+	return [d((t, n) => {
+		e.current = setInterval(t, n);
+	}, []), d(() => {
+		e.current !== null && (clearInterval(e.current), e.current = null);
+	}, [])];
+}
+function ee(e, t) {
+	t === void 0 && (t = [e]);
+	let n = _(e);
+	return A(() => {
+		n.current !== e && (n.current = e);
+	}, t), n;
+}
+function N(e, t) {
+	let n = _();
+	return h(() => {
+		let t = e(n.current);
+		return n.current = t, t;
+	}, [...t]);
+}
+function P(e) {
+	let t = j(e), n = _(null);
+	return [n, d((e) => {
+		e !== n.current && t?.(e, n.current), n.current = e;
+	}, [])];
+}
+function te(e) {
+	let t = _();
+	return p(() => {
+		t.current = e;
+	}, [e]), t.current;
+}
+var ne = {};
+function F(e, t) {
+	return h(() => {
+		if (t) return t;
+		let n = ne[e] == null ? 0 : ne[e] + 1;
+		return ne[e] = n, e + "-" + n;
+	}, [e, t]);
+}
+function I(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 re = /*#__PURE__*/ I(1), ie = /*#__PURE__*/ I(-1);
+function L(e) {
+	return "clientX" in e && "clientY" in e;
+}
+function ae(e) {
+	if (!e) return !1;
+	let { KeyboardEvent: t } = T(e.target);
+	return t && e instanceof t;
+}
+function R(e) {
+	if (!e) return !1;
+	let { TouchEvent: t } = T(e.target);
+	return t && e instanceof t;
+}
+function oe(e) {
+	if (R(e)) {
+		if (e.touches && e.touches.length) {
+			let { clientX: t, clientY: n } = e.touches[0];
+			return {
+				x: t,
+				y: n
+			};
+		} else if (e.changedTouches && e.changedTouches.length) {
+			let { clientX: t, clientY: n } = e.changedTouches[0];
+			return {
+				x: t,
+				y: n
+			};
+		}
+	}
+	return L(e) ? {
+		x: e.clientX,
+		y: e.clientY
+	} : null;
+}
+var z = /*#__PURE__*/ 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 [z.Translate.toString(e), z.Scale.toString(e)].join(" ");
+	} },
+	Transition: { toString(e) {
+		let { property: t, duration: n, easing: r } = e;
+		return t + " " + n + "ms " + r;
+	} }
+}), B = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function se(e) {
+	return e.matches(B) ? e : e.querySelector(B);
+}
+//#endregion
+//#region node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js
+var V = { display: "none" };
+function H(e) {
+	let { id: t, value: n } = e;
+	return o.createElement("div", {
+		id: t,
+		style: V
+	}, n);
+}
+function U(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);
+}
+function ce() {
+	let [e, t] = v("");
+	return {
+		announce: d((e) => {
+			e != null && t(e);
+		}, []),
+		announcement: e
+	};
+}
+//#endregion
+//#region node_modules/@dnd-kit/core/dist/core.esm.js
+var le = /*#__PURE__*/ c(null);
+function ue(e) {
+	let t = f(le);
+	p(() => {
+		if (!t) throw Error("useDndMonitor must be used within a children of <DndContext>");
+		return t(e);
+	}, [e, t]);
+}
+function de() {
+	let [e] = v(() => /* @__PURE__ */ new Set()), t = d((t) => (e.add(t), () => e.delete(t)), [e]);
+	return [d((t) => {
+		let { type: n, event: r } = t;
+		e.forEach((e) => e[n]?.call(e, r));
+	}, [e]), t];
+}
+var W = { 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  " }, fe = {
+	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 pe(e) {
+	let { announcements: t = fe, container: n, hiddenTextDescribedById: r, screenReaderInstructions: i = W } = e, { announce: a, announcement: s } = ce(), c = F("DndLiveRegion"), [l, u] = v(!1);
+	if (p(() => {
+		u(!0);
+	}, []), ue(h(() => ({
+		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])), !l) return null;
+	let d = o.createElement(o.Fragment, null, o.createElement(H, {
+		id: r,
+		value: i.draggable
+	}), o.createElement(U, {
+		id: c,
+		announcement: s
+	}));
+	return n ? y(d, n) : d;
+}
+var G;
+(function(e) {
+	e.DragStart = "dragStart", e.DragMove = "dragMove", e.DragEnd = "dragEnd", e.DragCancel = "dragCancel", e.DragOver = "dragOver", e.RegisterDroppable = "registerDroppable", e.SetDroppableDisabled = "setDroppableDisabled", e.UnregisterDroppable = "unregisterDroppable";
+})(G ||= {});
+function K() {}
+function me(e, t) {
+	return h(() => ({
+		sensor: e,
+		options: t ?? {}
+	}), [e, t]);
+}
+function q() {
+	var e = [...arguments];
+	return h(() => [...e].filter((e) => e != null), [...e]);
+}
+var J = /*#__PURE__*/ Object.freeze({
+	x: 0,
+	y: 0
+});
+function he(e, t) {
+	return Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
+}
+function ge(e, t) {
+	let n = oe(e);
+	if (!n) return "0 0";
+	let r = {
+		x: (n.x - t.left) / t.width * 100,
+		y: (n.y - t.top) / t.height * 100
+	};
+	return r.x + "% " + r.y + "%";
+}
+function _e(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return n - r;
+}
+function ve(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return r - n;
+}
+function Y(e) {
+	let { left: t, top: n, height: r, width: i } = e;
+	return [
+		{
+			x: t,
+			y: n
+		},
+		{
+			x: t + i,
+			y: n
+		},
+		{
+			x: t,
+			y: n + r
+		},
+		{
+			x: t + i,
+			y: n + r
+		}
+	];
+}
+function ye(e, t) {
+	if (!e || e.length === 0) return null;
+	let [n] = e;
+	return t ? n[t] : n;
+}
+function be(e, t, n) {
+	return t === void 0 && (t = e.left), n === void 0 && (n = e.top), {
+		x: t + e.width * .5,
+		y: n + e.height * .5
+	};
+}
+var xe = (e) => {
+	let { collisionRect: t, droppableRects: n, droppableContainers: r } = e, i = be(t, t.left, t.top), a = [];
+	for (let e of r) {
+		let { id: t } = e, r = n.get(t);
+		if (r) {
+			let n = he(be(r), i);
+			a.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return a.sort(_e);
+};
+function Se(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, a = i / (n + r - i);
+		return Number(a.toFixed(4));
+	}
+	return 0;
+}
+var Ce = (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 = Se(a, t);
+			n > 0 && i.push({
+				id: r,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return i.sort(ve);
+};
+function we(e, t) {
+	let { top: n, left: r, bottom: i, right: a } = t;
+	return n <= e.y && e.y <= i && r <= e.x && e.x <= a;
+}
+var Te = (e) => {
+	let { droppableContainers: t, droppableRects: n, pointerCoordinates: r } = e;
+	if (!r) return [];
+	let i = [];
+	for (let e of t) {
+		let { id: t } = e, a = n.get(t);
+		if (a && we(r, a)) {
+			let n = Y(a).reduce((e, t) => e + he(r, t), 0), o = Number((n / 4).toFixed(4));
+			i.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: o
+				}
+			});
+		}
+	}
+	return i.sort(_e);
+};
+function Ee(e, t, n) {
+	return {
+		...e,
+		scaleX: t && n ? t.width / n.width : 1,
+		scaleY: t && n ? t.height / n.height : 1
+	};
+}
+function De(e, t) {
+	return e && t ? {
+		x: e.left - t.left,
+		y: e.top - t.top
+	} : J;
+}
+function Oe(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 });
+	};
+}
+var ke = /*#__PURE__*/ Oe(1);
+function Ae(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]
+		};
+	} else 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;
+}
+function je(e, t, n) {
+	let r = Ae(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
+	};
+}
+var Me = { ignoreTransform: !1 };
+function X(e, t) {
+	t === void 0 && (t = Me);
+	let n = e.getBoundingClientRect();
+	if (t.ignoreTransform) {
+		let { transform: t, transformOrigin: r } = T(e).getComputedStyle(e);
+		t && (n = je(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 Ne(e) {
+	return X(e, { ignoreTransform: !0 });
+}
+function Pe(e) {
+	let t = e.innerWidth, n = e.innerHeight;
+	return {
+		top: 0,
+		left: 0,
+		right: t,
+		bottom: n,
+		width: t,
+		height: n
+	};
+}
+function Fe(e, t) {
+	return t === void 0 && (t = T(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Ie(e, t) {
+	t === void 0 && (t = T(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);
+	});
+}
+function Le(e, t) {
+	let n = [];
+	function r(i) {
+		if (t != null && n.length >= t || !i) return n;
+		if (E(i) && i.scrollingElement != null && !n.includes(i.scrollingElement)) return n.push(i.scrollingElement), n;
+		if (!D(i) || O(i) || n.includes(i)) return n;
+		let a = T(e).getComputedStyle(i);
+		return i !== e && Ie(i, a) && n.push(i), Fe(i, a) ? n : r(i.parentNode);
+	}
+	return e ? r(e) : n;
+}
+function Re(e) {
+	let [t] = Le(e, 1);
+	return t ?? null;
+}
+function ze(e) {
+	return !S || !e ? null : C(e) ? e : w(e) ? E(e) || e === k(e).scrollingElement ? window : D(e) ? e : null : null;
+}
+function Be(e) {
+	return C(e) ? e.scrollX : e.scrollLeft;
+}
+function Ve(e) {
+	return C(e) ? e.scrollY : e.scrollTop;
+}
+function He(e) {
+	return {
+		x: Be(e),
+		y: Ve(e)
+	};
+}
+var Z;
+(function(e) {
+	e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(Z ||= {});
+function Ue(e) {
+	return !S || !e ? !1 : e === document.scrollingElement;
+}
+function We(e) {
+	let t = {
+		x: 0,
+		y: 0
+	}, n = Ue(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
+	};
+}
+var Ge = {
+	x: .2,
+	y: .2
+};
+function Ke(e, t, n, r, i) {
+	let { top: a, left: o, right: s, bottom: c } = n;
+	r === void 0 && (r = 10), i === void 0 && (i = Ge);
+	let { isTop: l, isBottom: u, isLeft: d, isRight: f } = We(e), p = {
+		x: 0,
+		y: 0
+	}, m = {
+		x: 0,
+		y: 0
+	}, h = {
+		height: t.height * i.y,
+		width: t.width * i.x
+	};
+	return !l && a <= t.top + h.height ? (p.y = Z.Backward, m.y = r * Math.abs((t.top + h.height - a) / h.height)) : !u && c >= t.bottom - h.height && (p.y = Z.Forward, m.y = r * Math.abs((t.bottom - h.height - c) / h.height)), !f && s >= t.right - h.width ? (p.x = Z.Forward, m.x = r * Math.abs((t.right - h.width - s) / h.width)) : !d && o <= t.left + h.width && (p.x = Z.Backward, m.x = r * Math.abs((t.left + h.width - o) / h.width)), {
+		direction: p,
+		speed: m
+	};
+}
+function qe(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 Je(e) {
+	return e.reduce((e, t) => re(e, He(t)), J);
+}
+function Ye(e) {
+	return e.reduce((e, t) => e + Be(t), 0);
+}
+function Xe(e) {
+	return e.reduce((e, t) => e + Ve(t), 0);
+}
+function Ze(e, t) {
+	if (t === void 0 && (t = X), !e) return;
+	let { top: n, left: r, bottom: i, right: a } = t(e);
+	Re(e) && (i <= 0 || a <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+		block: "center",
+		inline: "center"
+	});
+}
+var Qe = [[
+	"x",
+	["left", "right"],
+	Ye
+], [
+	"y",
+	["top", "bottom"],
+	Xe
+]], $e = 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 = Le(t), r = Je(n);
+		this.rect = { ...e }, this.width = e.width, this.height = e.height;
+		for (let [e, t, i] of Qe) 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 });
+	}
+}, et = 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 tt(e) {
+	let { EventTarget: t } = T(e);
+	return e instanceof t ? e : k(e);
+}
+function nt(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;
+}
+var Q;
+(function(e) {
+	e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(Q ||= {});
+function rt(e) {
+	e.preventDefault();
+}
+function it(e) {
+	e.stopPropagation();
+}
+var $;
+(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";
+})($ ||= {});
+var at = {
+	start: [$.Space, $.Enter],
+	cancel: [$.Esc],
+	end: [
+		$.Space,
+		$.Enter,
+		$.Tab
+	]
+}, ot = (e, t) => {
+	let { currentCoordinates: n } = t;
+	switch (e.code) {
+		case $.Right: return {
+			...n,
+			x: n.x + 25
+		};
+		case $.Left: return {
+			...n,
+			x: n.x - 25
+		};
+		case $.Down: return {
+			...n,
+			y: n.y + 25
+		};
+		case $.Up: return {
+			...n,
+			y: n.y - 25
+		};
+	}
+}, st = 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 et(k(t)), this.windowListeners = new et(T(t)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+	}
+	attach() {
+		this.handleStart(), this.windowListeners.add(Q.Resize, this.handleCancel), this.windowListeners.add(Q.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(Q.Keydown, this.handleKeyDown));
+	}
+	handleStart() {
+		let { activeNode: e, onStart: t } = this.props, n = e.node.current;
+		n && Ze(n), t(J);
+	}
+	handleKeyDown(e) {
+		if (ae(e)) {
+			let { active: t, context: n, options: r } = this.props, { keyboardCodes: i = at, coordinateGetter: a = ot, scrollBehavior: o = "smooth" } = r, { code: s } = e;
+			if (i.end.includes(s)) {
+				this.handleEnd(e);
+				return;
+			}
+			if (i.cancel.includes(s)) {
+				this.handleCancel(e);
+				return;
+			}
+			let { collisionRect: c } = n.current, l = c ? {
+				x: c.left,
+				y: c.top
+			} : J;
+			this.referenceCoordinates ||= l;
+			let u = a(e, {
+				active: t,
+				context: n.current,
+				currentCoordinates: l
+			});
+			if (u) {
+				let t = ie(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 } = We(n), p = qe(n), m = {
+						x: Math.min(i === $.Right ? p.right - p.width / 2 : p.right, Math.max(i === $.Right ? p.left : p.left + p.width / 2, u.x)),
+						y: Math.min(i === $.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(i === $.Down ? p.top : p.top + p.height / 2, u.y))
+					}, h = i === $.Right && !s || i === $.Left && !c, g = i === $.Down && !l || i === $.Up && !a;
+					if (h && m.x !== u.x) {
+						let e = n.scrollLeft + t.x, a = i === $.Right && e <= d.x || i === $.Left && e >= f.x;
+						if (a && !t.y) {
+							n.scrollTo({
+								left: e,
+								behavior: o
+							});
+							return;
+						}
+						a ? r.x = n.scrollLeft - e : r.x = i === $.Right ? n.scrollLeft - d.x : n.scrollLeft - f.x, r.x && n.scrollBy({
+							left: -r.x,
+							behavior: o
+						});
+						break;
+					} else if (g && m.y !== u.y) {
+						let e = n.scrollTop + t.y, a = i === $.Down && e <= d.y || i === $.Up && e >= f.y;
+						if (a && !t.x) {
+							n.scrollTo({
+								top: e,
+								behavior: o
+							});
+							return;
+						}
+						a ? r.y = n.scrollTop - e : r.y = i === $.Down ? n.scrollTop - d.y : n.scrollTop - f.y, r.y && n.scrollBy({
+							top: -r.y,
+							behavior: o
+						});
+						break;
+					}
+				}
+				this.handleMove(e, re(ie(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();
+	}
+};
+st.activators = [{
+	eventName: "onKeyDown",
+	handler: (e, t, n) => {
+		let { keyboardCodes: r = at, 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 ? !1 : (e.preventDefault(), i?.({ event: e.nativeEvent }), !0);
+		}
+		return !1;
+	}
+}];
+function ct(e) {
+	return !!(e && "distance" in e);
+}
+function lt(e) {
+	return !!(e && "delay" in e);
+}
+var ut = class {
+	constructor(e, t, n) {
+		n === void 0 && (n = tt(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 = k(i), this.documentListeners = new et(this.document), this.listeners = new et(n), this.windowListeners = new et(T(i)), this.initialCoordinates = oe(r) ?? J, 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(Q.Resize, this.handleCancel), this.windowListeners.add(Q.DragStart, rt), this.windowListeners.add(Q.VisibilityChange, this.handleCancel), this.windowListeners.add(Q.ContextMenu, rt), this.documentListeners.add(Q.Keydown, this.handleKeydown), t) {
+			if (n != null && n({
+				event: this.props.event,
+				activeNode: this.props.activeNode,
+				options: this.props.options
+			})) return this.handleStart();
+			if (lt(t)) {
+				this.timeoutId = setTimeout(this.handleStart, t.delay), this.handlePending(t);
+				return;
+			}
+			if (ct(t)) {
+				this.handlePending(t);
+				return;
+			}
+		}
+		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(Q.Click, it, { capture: !0 }), this.removeTextSelection(), this.documentListeners.add(Q.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 = oe(e) ?? J, s = ie(n, o);
+		if (!t && a) {
+			if (ct(a)) {
+				if (a.tolerance != null && nt(s, a.tolerance)) return this.handleCancel();
+				if (nt(s, a.distance)) return this.handleStart();
+			}
+			if (lt(a) && nt(s, a.tolerance)) return this.handleCancel();
+			this.handlePending(a, s);
+			return;
+		}
+		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 === $.Esc && this.handleCancel();
+	}
+	removeTextSelection() {
+		var e;
+		(e = this.document.getSelection()) == null || e.removeAllRanges();
+	}
+}, dt = {
+	cancel: { name: "pointercancel" },
+	move: { name: "pointermove" },
+	end: { name: "pointerup" }
+}, ft = class extends ut {
+	constructor(e) {
+		let { event: t } = e, n = k(t.target);
+		super(e, dt, n);
+	}
+};
+ft.activators = [{
+	eventName: "onPointerDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return !n.isPrimary || n.button !== 0 ? !1 : (r?.({ event: n }), !0);
+	}
+}];
+var pt = {
+	move: { name: "mousemove" },
+	end: { name: "mouseup" }
+}, mt;
+(function(e) {
+	e[e.RightClick = 2] = "RightClick";
+})(mt ||= {});
+var ht = class extends ut {
+	constructor(e) {
+		super(e, pt, k(e.event.target));
+	}
+};
+ht.activators = [{
+	eventName: "onMouseDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return n.button === mt.RightClick ? !1 : (r?.({ event: n }), !0);
+	}
+}];
+var gt = {
+	cancel: { name: "touchcancel" },
+	move: { name: "touchmove" },
+	end: { name: "touchend" }
+}, _t = class extends ut {
+	constructor(e) {
+		super(e, gt);
+	}
+	static setup() {
+		return window.addEventListener(gt.move.name, e, {
+			capture: !1,
+			passive: !1
+		}), function() {
+			window.removeEventListener(gt.move.name, e);
+		};
+		function e() {}
+	}
+};
+_t.activators = [{
+	eventName: "onTouchStart",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t, { touches: i } = n;
+		return i.length > 1 ? !1 : (r?.({ event: n }), !0);
+	}
+}];
+var vt;
+(function(e) {
+	e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(vt ||= {});
+var yt;
+(function(e) {
+	e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(yt ||= {});
+function bt(e) {
+	let { acceleration: t, activator: n = vt.Pointer, canScroll: r, draggingRect: i, enabled: a, interval: o = 5, order: s = yt.TreeOrder, pointerCoordinates: c, scrollableAncestors: l, scrollableAncestorRects: u, delta: f, threshold: m } = e, g = St({
+		delta: f,
+		disabled: !a
+	}), [v, y] = M(), b = _({
+		x: 0,
+		y: 0
+	}), x = _({
+		x: 0,
+		y: 0
+	}), S = h(() => {
+		switch (n) {
+			case vt.Pointer: return c ? {
+				top: c.y,
+				bottom: c.y,
+				left: c.x,
+				right: c.x
+			} : null;
+			case vt.DraggableRect: return i;
+		}
+	}, [
+		n,
+		i,
+		c
+	]), C = _(null), w = d(() => {
+		let e = C.current;
+		if (!e) return;
+		let t = b.current.x * x.current.x, n = b.current.y * x.current.y;
+		e.scrollBy(t, n);
+	}, []), T = h(() => s === yt.TreeOrder ? [...l].reverse() : l, [s, l]);
+	p(() => {
+		if (!a || !l.length || !S) {
+			y();
+			return;
+		}
+		for (let e of T) {
+			if (r?.(e) === !1) continue;
+			let n = l.indexOf(e), i = u[n];
+			if (!i) continue;
+			let { direction: a, speed: s } = Ke(e, i, S, t, m);
+			for (let e of ["x", "y"]) g[e][a[e]] || (s[e] = 0, a[e] = 0);
+			if (s.x > 0 || s.y > 0) {
+				y(), C.current = e, v(w, o), b.current = s, x.current = a;
+				return;
+			}
+		}
+		b.current = {
+			x: 0,
+			y: 0
+		}, x.current = {
+			x: 0,
+			y: 0
+		}, y();
+	}, [
+		t,
+		w,
+		r,
+		y,
+		a,
+		o,
+		JSON.stringify(S),
+		JSON.stringify(g),
+		v,
+		l,
+		T,
+		u,
+		JSON.stringify(m)
+	]);
+}
+var xt = {
+	x: {
+		[Z.Backward]: !1,
+		[Z.Forward]: !1
+	},
+	y: {
+		[Z.Backward]: !1,
+		[Z.Forward]: !1
+	}
+};
+function St(e) {
+	let { delta: t, disabled: n } = e, r = te(t);
+	return N((e) => {
+		if (n || !r || !e) return xt;
+		let i = {
+			x: Math.sign(t.x - r.x),
+			y: Math.sign(t.y - r.y)
+		};
+		return {
+			x: {
+				[Z.Backward]: e.x[Z.Backward] || i.x === -1,
+				[Z.Forward]: e.x[Z.Forward] || i.x === 1
+			},
+			y: {
+				[Z.Backward]: e.y[Z.Backward] || i.y === -1,
+				[Z.Forward]: e.y[Z.Forward] || i.y === 1
+			}
+		};
+	}, [
+		n,
+		t,
+		r
+	]);
+}
+function Ct(e, t) {
+	let n = t == null ? void 0 : e.get(t), r = n ? n.node.current : null;
+	return N((e) => t == null ? null : r ?? e ?? null, [r, t]);
+}
+function wt(e, t) {
+	return h(() => e.reduce((e, n) => {
+		let { sensor: r } = n, i = r.activators.map((e) => ({
+			eventName: e.eventName,
+			handler: t(e.handler, n)
+		}));
+		return [...e, ...i];
+	}, []), [e, t]);
+}
+var Tt;
+(function(e) {
+	e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Tt ||= {});
+var Et;
+(function(e) {
+	e.Optimized = "optimized";
+})(Et ||= {});
+var Dt = /*#__PURE__*/ new Map();
+function Ot(e, t) {
+	let { dragging: n, dependencies: r, config: i } = t, [a, o] = v(null), { frequency: s, measure: c, strategy: l } = i, u = _(e), f = b(), m = ee(f), h = d(function(e) {
+		e === void 0 && (e = []), !m.current && o((t) => t === null ? e : t.concat(e.filter((e) => !t.includes(e))));
+	}, [m]), g = _(null), y = N((t) => {
+		if (f && !n) return Dt;
+		if (!t || t === Dt || u.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 $e(c(e), e) : null;
+				n.rect.current = r, r && t.set(n.id, r);
+			}
+			return t;
+		}
+		return t;
+	}, [
+		e,
+		a,
+		n,
+		f,
+		c
+	]);
+	return p(() => {
+		u.current = e;
+	}, [e]), p(() => {
+		f || h();
+	}, [n, f]), p(() => {
+		a && a.length > 0 && o(null);
+	}, [JSON.stringify(a)]), p(() => {
+		f || typeof s != "number" || g.current !== null || (g.current = setTimeout(() => {
+			h(), g.current = null;
+		}, s));
+	}, [
+		s,
+		f,
+		h,
+		...r
+	]), {
+		droppableRects: y,
+		measureDroppableContainers: h,
+		measuringScheduled: a != null
+	};
+	function b() {
+		switch (l) {
+			case Tt.Always: return !1;
+			case Tt.BeforeDragging: return n;
+			default: return !n;
+		}
+	}
+}
+function kt(e, t) {
+	return N((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function At(e, t) {
+	return kt(e, t);
+}
+function jt(e) {
+	let { callback: t, disabled: n } = e, r = j(t), i = h(() => {
+		if (n || typeof window > "u" || window.MutationObserver === void 0) return;
+		let { MutationObserver: e } = window;
+		return new e(r);
+	}, [r, n]);
+	return p(() => () => i?.disconnect(), [i]), i;
+}
+function Mt(e) {
+	let { callback: t, disabled: n } = e, r = j(t), i = h(() => {
+		if (n || typeof window > "u" || window.ResizeObserver === void 0) return;
+		let { ResizeObserver: e } = window;
+		return new e(r);
+	}, [n]);
+	return p(() => () => i?.disconnect(), [i]), i;
+}
+function Nt(e) {
+	return new $e(X(e), e);
+}
+function Pt(e, t, n) {
+	t === void 0 && (t = Nt);
+	let [r, i] = v(null);
+	function a() {
+		i((r) => {
+			if (!e) return null;
+			if (e.isConnected === !1) return r ?? n ?? null;
+			let i = t(e);
+			return JSON.stringify(r) === JSON.stringify(i) ? r : i;
+		});
+	}
+	let o = jt({ 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;
+			}
+		}
+	} }), s = Mt({ callback: a });
+	return A(() => {
+		a(), e ? (s?.observe(e), o?.observe(document.body, {
+			childList: !0,
+			subtree: !0
+		})) : (s?.disconnect(), o?.disconnect());
+	}, [e]), r;
+}
+function Ft(e) {
+	return De(e, kt(e));
+}
+var It = [];
+function Lt(e) {
+	let t = _(e), n = N((n) => e ? n && n !== It && e && t.current && e.parentNode === t.current.parentNode ? n : Le(e) : It, [e]);
+	return p(() => {
+		t.current = e;
+	}, [e]), n;
+}
+function Rt(e) {
+	let [t, n] = v(null), r = _(e), i = d((e) => {
+		let t = ze(e.target);
+		t && n((e) => e ? (e.set(t, He(t)), new Map(e)) : null);
+	}, []);
+	return p(() => {
+		let t = r.current;
+		if (e !== t) {
+			a(t);
+			let o = e.map((e) => {
+				let t = ze(e);
+				return t ? (t.addEventListener("scroll", i, { passive: !0 }), [t, He(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) => {
+				ze(e)?.removeEventListener("scroll", i);
+			});
+		}
+	}, [i, e]), h(() => e.length ? t ? Array.from(t.values()).reduce((e, t) => re(e, t), J) : Je(e) : J, [e, t]);
+}
+function zt(e, t) {
+	t === void 0 && (t = []);
+	let n = _(null);
+	return p(() => {
+		n.current = null;
+	}, t), p(() => {
+		let t = e !== J;
+		t && !n.current && (n.current = e), !t && n.current && (n.current = null);
+	}, [e]), n.current ? ie(e, n.current) : J;
+}
+function Bt(e) {
+	p(() => {
+		if (!S) 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;
+	}));
+}
+function Vt(e, t) {
+	return h(() => e.reduce((e, n) => {
+		let { eventName: r, handler: i } = n;
+		return e[r] = (e) => {
+			i(e, t);
+		}, e;
+	}, {}), [e, t]);
+}
+function Ht(e) {
+	return h(() => e ? Pe(e) : null, [e]);
+}
+var Ut = [];
+function Wt(e, t) {
+	t === void 0 && (t = X);
+	let [n] = e, r = Ht(n ? T(n) : null), [i, a] = v(Ut);
+	function o() {
+		a(() => e.length ? e.map((e) => Ue(e) ? r : new $e(t(e), e)) : Ut);
+	}
+	let s = Mt({ callback: o });
+	return A(() => {
+		s?.disconnect(), o(), e.forEach((e) => s?.observe(e));
+	}, [e]), i;
+}
+function Gt(e) {
+	if (!e) return null;
+	if (e.children.length > 1) return e;
+	let t = e.children[0];
+	return D(t) ? t : e;
+}
+function Kt(e) {
+	let { measure: t } = e, [n, r] = v(null), i = Mt({ callback: d((e) => {
+		for (let { target: n } of e) if (D(n)) {
+			r((e) => {
+				let r = t(n);
+				return e ? {
+					...e,
+					width: r.width,
+					height: r.height
+				} : r;
+			});
+			break;
+		}
+	}, [t]) }), [a, o] = P(d((e) => {
+		let n = Gt(e);
+		i?.disconnect(), n && i?.observe(n), r(n ? t(n) : null);
+	}, [t, i]));
+	return h(() => ({
+		nodeRef: a,
+		rect: n,
+		setRef: o
+	}), [
+		n,
+		a,
+		o
+	]);
+}
+var qt = [{
+	sensor: ft,
+	options: {}
+}, {
+	sensor: st,
+	options: {}
+}], Jt = { current: {} }, Yt = {
+	draggable: { measure: Ne },
+	droppable: {
+		measure: Ne,
+		strategy: Tt.WhileDragging,
+		frequency: Et.Optimized
+	},
+	dragOverlay: { measure: X }
+}, Xt = class extends Map {
+	get(e) {
+		return e == null ? void 0 : super.get(e) ?? 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;
+	}
+}, Zt = {
+	activatorEvent: null,
+	active: null,
+	activeNode: null,
+	activeNodeRect: null,
+	collisions: null,
+	containerNodeRect: null,
+	draggableNodes: /*#__PURE__*/ new Map(),
+	droppableRects: /*#__PURE__*/ new Map(),
+	droppableContainers: /*#__PURE__*/ new Xt(),
+	over: null,
+	dragOverlay: {
+		nodeRef: { current: null },
+		rect: null,
+		setRef: K
+	},
+	scrollableAncestors: [],
+	scrollableAncestorRects: [],
+	measuringConfiguration: Yt,
+	measureDroppableContainers: K,
+	windowRect: null,
+	measuringScheduled: !1
+}, Qt = {
+	activatorEvent: null,
+	activators: [],
+	active: null,
+	activeNodeRect: null,
+	ariaDescribedById: { draggable: "" },
+	dispatch: K,
+	draggableNodes: /*#__PURE__*/ new Map(),
+	over: null,
+	measureDroppableContainers: K
+}, $t = /*#__PURE__*/ c(Qt), en = /*#__PURE__*/ c(Zt);
+function tn() {
+	return {
+		draggable: {
+			active: null,
+			initialCoordinates: {
+				x: 0,
+				y: 0
+			},
+			nodes: /* @__PURE__ */ new Map(),
+			translate: {
+				x: 0,
+				y: 0
+			}
+		},
+		droppable: { containers: new Xt() }
+	};
+}
+function nn(e, t) {
+	switch (t.type) {
+		case G.DragStart: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				initialCoordinates: t.initialCoordinates,
+				active: t.active
+			}
+		};
+		case G.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 G.DragEnd:
+		case G.DragCancel: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				active: null,
+				initialCoordinates: {
+					x: 0,
+					y: 0
+				},
+				translate: {
+					x: 0,
+					y: 0
+				}
+			}
+		};
+		case G.RegisterDroppable: {
+			let { element: n } = t, { id: r } = n, i = new Xt(e.droppable.containers);
+			return i.set(r, n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: i
+				}
+			};
+		}
+		case G.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 Xt(e.droppable.containers);
+			return o.set(n, {
+				...a,
+				disabled: i
+			}), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: o
+				}
+			};
+		}
+		case G.UnregisterDroppable: {
+			let { id: n, key: r } = t, i = e.droppable.containers.get(n);
+			if (!i || r !== i.key) return e;
+			let a = new Xt(e.droppable.containers);
+			return a.delete(n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: a
+				}
+			};
+		}
+		default: return e;
+	}
+}
+function rn(e) {
+	let { disabled: t } = e, { active: n, activatorEvent: r, draggableNodes: i } = f($t), a = te(r), o = te(n?.id);
+	return p(() => {
+		if (!t && !r && a && o != null) {
+			if (!ae(a) || document.activeElement === a.target) return;
+			let e = i.get(o);
+			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 = se(e);
+					if (t) {
+						t.focus();
+						break;
+					}
+				}
+			});
+		}
+	}, [
+		r,
+		t,
+		i,
+		o,
+		a
+	]), null;
+}
+function an(e, t) {
+	let { transform: n, ...r } = t;
+	return e != null && e.length ? e.reduce((e, t) => t({
+		transform: e,
+		...r
+	}), n) : n;
+}
+function on(e) {
+	return h(() => ({
+		draggable: {
+			...Yt.draggable,
+			...e?.draggable
+		},
+		droppable: {
+			...Yt.droppable,
+			...e?.droppable
+		},
+		dragOverlay: {
+			...Yt.dragOverlay,
+			...e?.dragOverlay
+		}
+	}), [
+		e?.draggable,
+		e?.droppable,
+		e?.dragOverlay
+	]);
+}
+function sn(e) {
+	let { activeNode: t, measure: n, initialRect: r, config: i = !0 } = e, a = _(!1), { x: o, y: s } = typeof i == "boolean" ? {
+		x: i,
+		y: i
+	} : i;
+	A(() => {
+		if (!o && !s || !t) {
+			a.current = !1;
+			return;
+		}
+		if (a.current || !r) return;
+		let e = t?.node.current;
+		if (!e || e.isConnected === !1) return;
+		let i = De(n(e), r);
+		if (o || (i.x = 0), s || (i.y = 0), a.current = !0, Math.abs(i.x) > 0 || Math.abs(i.y) > 0) {
+			let t = Re(e);
+			t && t.scrollBy({
+				top: i.y,
+				left: i.x
+			});
+		}
+	}, [
+		t,
+		o,
+		s,
+		r,
+		n
+	]);
+}
+var cn = /*#__PURE__*/ c({
+	...J,
+	scaleX: 1,
+	scaleY: 1
+}), ln;
+(function(e) {
+	e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(ln ||= {});
+var un = /*#__PURE__*/ u(function(e) {
+	let { id: t, accessibility: n, autoScroll: r = !0, children: i, sensors: a = qt, collisionDetection: s = Ce, measuring: c, modifiers: l, ...u } = e, [f, m] = g(nn, void 0, tn), [y, x] = de(), [S, C] = v(ln.Uninitialized), w = S === ln.Initialized, { draggable: { active: E, nodes: D, translate: O }, droppable: { containers: k } } = f, j = E == null ? null : D.get(E), M = _({
+		initial: null,
+		translated: null
+	}), N = h(() => E == null ? null : {
+		id: E,
+		data: j?.data ?? Jt,
+		rect: M
+	}, [E, j]), P = _(null), [te, ne] = v(null), [I, ie] = v(null), L = ee(u, Object.values(u)), ae = F("DndDescribedBy", t), R = h(() => k.getEnabled(), [k]), z = on(c), { droppableRects: B, measureDroppableContainers: se, measuringScheduled: V } = Ot(R, {
+		dragging: w,
+		dependencies: [O.x, O.y],
+		config: z.droppable
+	}), H = Ct(D, E), U = h(() => I ? oe(I) : null, [I]), ce = Be(), ue = At(H, z.draggable.measure);
+	sn({
+		activeNode: E == null ? null : D.get(E),
+		config: ce.layoutShiftCompensation,
+		initialRect: ue,
+		measure: z.draggable.measure
+	});
+	let W = Pt(H, z.draggable.measure, ue), fe = Pt(H ? H.parentElement : null), K = _({
+		activatorEvent: null,
+		active: null,
+		activeNode: H,
+		collisionRect: null,
+		collisions: null,
+		droppableRects: B,
+		draggableNodes: D,
+		draggingNode: null,
+		draggingNodeRect: null,
+		droppableContainers: k,
+		over: null,
+		scrollableAncestors: [],
+		scrollAdjustedTranslate: null
+	}), me = k.getNodeFor(K.current.over?.id), q = Kt({ measure: z.dragOverlay.measure }), J = q.nodeRef.current ?? H, he = w ? q.rect ?? W : null, ge = !!(q.nodeRef.current && q.rect), _e = Ft(ge ? null : W), ve = Ht(J ? T(J) : null), Y = Lt(w ? me ?? H : null), be = Wt(Y), xe = an(l, {
+		transform: {
+			x: O.x - _e.x,
+			y: O.y - _e.y,
+			scaleX: 1,
+			scaleY: 1
+		},
+		activatorEvent: I,
+		active: N,
+		activeNodeRect: W,
+		containerNodeRect: fe,
+		draggingNodeRect: he,
+		over: K.current.over,
+		overlayNodeRect: q.rect,
+		scrollableAncestors: Y,
+		scrollableAncestorRects: be,
+		windowRect: ve
+	}), Se = U ? re(U, O) : null, we = Rt(Y), Te = zt(we), De = zt(we, [W]), Oe = re(xe, Te), Ae = he ? ke(he, xe) : null, je = N && Ae ? s({
+		active: N,
+		collisionRect: Ae,
+		droppableRects: B,
+		droppableContainers: R,
+		pointerCoordinates: Se
+	}) : null, Me = ye(je, "id"), [X, Ne] = v(null), Pe = Ee(ge ? xe : re(xe, De), X?.rect ?? null, W), Fe = _(null), Ie = d((e, t) => {
+		let { sensor: n, options: r } = t;
+		if (P.current == null) return;
+		let i = D.get(P.current);
+		if (!i) return;
+		let a = e.nativeEvent, o = new n({
+			active: P.current,
+			activeNode: i,
+			event: a,
+			options: r,
+			context: K,
+			onAbort(e) {
+				if (!D.get(e)) return;
+				let { onDragAbort: t } = L.current, n = { id: e };
+				t?.(n), y({
+					type: "onDragAbort",
+					event: n
+				});
+			},
+			onPending(e, t, n, r) {
+				if (!D.get(e)) return;
+				let { onDragPending: i } = L.current, a = {
+					id: e,
+					constraint: t,
+					initialCoordinates: n,
+					offset: r
+				};
+				i?.(a), y({
+					type: "onDragPending",
+					event: a
+				});
+			},
+			onStart(e) {
+				let t = P.current;
+				if (t == null) return;
+				let n = D.get(t);
+				if (!n) return;
+				let { onDragStart: r } = L.current, i = {
+					activatorEvent: a,
+					active: {
+						id: t,
+						data: n.data,
+						rect: M
+					}
+				};
+				b(() => {
+					r?.(i), C(ln.Initializing), m({
+						type: G.DragStart,
+						initialCoordinates: e,
+						active: t
+					}), y({
+						type: "onDragStart",
+						event: i
+					}), ne(Fe.current), ie(a);
+				});
+			},
+			onMove(e) {
+				m({
+					type: G.DragMove,
+					coordinates: e
+				});
+			},
+			onEnd: s(G.DragEnd),
+			onCancel: s(G.DragCancel)
+		});
+		Fe.current = o;
+		function s(e) {
+			return async function() {
+				let { active: t, collisions: n, over: r, scrollAdjustedTranslate: i } = K.current, o = null;
+				if (t && i) {
+					let { cancelDrop: s } = L.current;
+					o = {
+						activatorEvent: a,
+						active: t,
+						collisions: n,
+						delta: i,
+						over: r
+					}, e === G.DragEnd && typeof s == "function" && await Promise.resolve(s(o)) && (e = G.DragCancel);
+				}
+				P.current = null, b(() => {
+					m({ type: e }), C(ln.Uninitialized), Ne(null), ne(null), ie(null), Fe.current = null;
+					let t = e === G.DragEnd ? "onDragEnd" : "onDragCancel";
+					if (o) {
+						let e = L.current[t];
+						e?.(o), y({
+							type: t,
+							event: o
+						});
+					}
+				});
+			};
+		}
+	}, [D]), Le = wt(a, d((e, t) => (n, r) => {
+		let i = n.nativeEvent, a = D.get(r);
+		if (P.current !== null || !a || i.dndKit || i.defaultPrevented) return;
+		let o = { active: a };
+		e(n, t.options, o) === !0 && (i.dndKit = { capturedBy: t.sensor }, P.current = r, Ie(n, t));
+	}, [D, Ie]));
+	Bt(a), A(() => {
+		W && S === ln.Initializing && C(ln.Initialized);
+	}, [W, S]), p(() => {
+		let { onDragMove: e } = L.current, { active: t, activatorEvent: n, collisions: r, over: i } = K.current;
+		if (!t || !n) return;
+		let a = {
+			active: t,
+			activatorEvent: n,
+			collisions: r,
+			delta: {
+				x: Oe.x,
+				y: Oe.y
+			},
+			over: i
+		};
+		b(() => {
+			e?.(a), y({
+				type: "onDragMove",
+				event: a
+			});
+		});
+	}, [Oe.x, Oe.y]), p(() => {
+		let { active: e, activatorEvent: t, collisions: n, droppableContainers: r, scrollAdjustedTranslate: i } = K.current;
+		if (!e || P.current == null || !t || !i) return;
+		let { onDragOver: a } = L.current, o = r.get(Me), s = o && o.rect.current ? {
+			id: o.id,
+			rect: o.rect.current,
+			data: o.data,
+			disabled: o.disabled
+		} : null, c = {
+			active: e,
+			activatorEvent: t,
+			collisions: n,
+			delta: {
+				x: i.x,
+				y: i.y
+			},
+			over: s
+		};
+		b(() => {
+			Ne(s), a?.(c), y({
+				type: "onDragOver",
+				event: c
+			});
+		});
+	}, [Me]), A(() => {
+		K.current = {
+			activatorEvent: I,
+			active: N,
+			activeNode: H,
+			collisionRect: Ae,
+			collisions: je,
+			droppableRects: B,
+			draggableNodes: D,
+			draggingNode: J,
+			draggingNodeRect: he,
+			droppableContainers: k,
+			over: X,
+			scrollableAncestors: Y,
+			scrollAdjustedTranslate: Oe
+		}, M.current = {
+			initial: he,
+			translated: Ae
+		};
+	}, [
+		N,
+		H,
+		je,
+		Ae,
+		D,
+		J,
+		he,
+		B,
+		k,
+		X,
+		Y,
+		Oe
+	]), bt({
+		...ce,
+		delta: O,
+		draggingRect: Ae,
+		pointerCoordinates: Se,
+		scrollableAncestors: Y,
+		scrollableAncestorRects: be
+	});
+	let Re = h(() => ({
+		active: N,
+		activeNode: H,
+		activeNodeRect: W,
+		activatorEvent: I,
+		collisions: je,
+		containerNodeRect: fe,
+		dragOverlay: q,
+		draggableNodes: D,
+		droppableContainers: k,
+		droppableRects: B,
+		over: X,
+		measureDroppableContainers: se,
+		scrollableAncestors: Y,
+		scrollableAncestorRects: be,
+		measuringConfiguration: z,
+		measuringScheduled: V,
+		windowRect: ve
+	}), [
+		N,
+		H,
+		W,
+		I,
+		je,
+		fe,
+		q,
+		D,
+		k,
+		B,
+		X,
+		se,
+		Y,
+		be,
+		z,
+		V,
+		ve
+	]), ze = h(() => ({
+		activatorEvent: I,
+		activators: Le,
+		active: N,
+		activeNodeRect: W,
+		ariaDescribedById: { draggable: ae },
+		dispatch: m,
+		draggableNodes: D,
+		over: X,
+		measureDroppableContainers: se
+	}), [
+		I,
+		Le,
+		N,
+		W,
+		m,
+		ae,
+		D,
+		X,
+		se
+	]);
+	return o.createElement(le.Provider, { value: x }, o.createElement($t.Provider, { value: ze }, o.createElement(en.Provider, { value: Re }, o.createElement(cn.Provider, { value: Pe }, i)), o.createElement(rn, { disabled: n?.restoreFocus === !1 })), o.createElement(pe, {
+		...n,
+		hiddenTextDescribedById: ae
+	}));
+	function Be() {
+		let e = te?.autoScrollEnabled === !1, t = typeof r == "object" ? r.enabled === !1 : r === !1, n = w && !e && !t;
+		return typeof r == "object" ? {
+			...r,
+			enabled: n
+		} : { enabled: n };
+	}
+}), dn = /*#__PURE__*/ c(null), fn = "button", pn = "Draggable";
+function mn(e) {
+	let { id: t, data: n, disabled: r = !1, attributes: i } = e, a = F(pn), { activators: o, activatorEvent: s, active: c, activeNodeRect: l, ariaDescribedById: u, draggableNodes: d, over: p } = f($t), { role: m = fn, roleDescription: g = "draggable", tabIndex: _ = 0 } = i ?? {}, v = c?.id === t, y = f(v ? cn : dn), [b, x] = P(), [S, C] = P(), w = Vt(o, t), T = ee(n);
+	return A(() => (d.set(t, {
+		id: t,
+		key: a,
+		node: b,
+		activatorNode: S,
+		data: T
+	}), () => {
+		let e = d.get(t);
+		e && e.key === a && d.delete(t);
+	}), [d, t]), {
+		active: c,
+		activatorEvent: s,
+		activeNodeRect: l,
+		attributes: h(() => ({
+			role: m,
+			tabIndex: _,
+			"aria-disabled": r,
+			"aria-pressed": v && m === fn ? !0 : void 0,
+			"aria-roledescription": g,
+			"aria-describedby": u.draggable
+		}), [
+			r,
+			m,
+			_,
+			v,
+			g,
+			u.draggable
+		]),
+		isDragging: v,
+		listeners: r ? void 0 : w,
+		node: b,
+		over: p,
+		setNodeRef: x,
+		setActivatorNodeRef: C,
+		transform: y
+	};
+}
+function hn() {
+	return f(en);
+}
+var gn = "Droppable", _n = { timeout: 25 };
+function vn(e) {
+	let { data: t, disabled: n = !1, id: r, resizeObserverConfig: i } = e, a = F(gn), { active: o, dispatch: s, over: c, measureDroppableContainers: l } = f($t), u = _({ disabled: n }), m = _(!1), h = _(null), g = _(null), { disabled: v, updateMeasurementsFor: y, timeout: b } = {
+		..._n,
+		...i
+	}, x = ee(y ?? r), S = Mt({
+		callback: d(() => {
+			if (!m.current) {
+				m.current = !0;
+				return;
+			}
+			g.current != null && clearTimeout(g.current), g.current = setTimeout(() => {
+				l(Array.isArray(x.current) ? x.current : [x.current]), g.current = null;
+			}, b);
+		}, [b]),
+		disabled: v || !o
+	}), [C, w] = P(d((e, t) => {
+		S && (t && (S.unobserve(t), m.current = !1), e && S.observe(e));
+	}, [S])), T = ee(t);
+	return p(() => {
+		!S || !C.current || (S.disconnect(), m.current = !1, S.observe(C.current));
+	}, [C, S]), p(() => (s({
+		type: G.RegisterDroppable,
+		element: {
+			id: r,
+			key: a,
+			disabled: n,
+			node: C,
+			rect: h,
+			data: T
+		}
+	}), () => s({
+		type: G.UnregisterDroppable,
+		key: a,
+		id: r
+	})), [r]), p(() => {
+		n !== u.current.disabled && (s({
+			type: G.SetDroppableDisabled,
+			id: r,
+			key: a,
+			disabled: n
+		}), u.current.disabled = n);
+	}, [
+		r,
+		a,
+		n,
+		s
+	]), {
+		active: o,
+		rect: h,
+		isOver: c?.id === r,
+		node: C,
+		over: c,
+		setNodeRef: w
+	};
+}
+function yn(e) {
+	let { animation: t, children: n } = e, [r, i] = v(null), [a, c] = v(null), l = te(n);
+	return !n && !r && l && i(l), A(() => {
+		if (!a) return;
+		let e = r?.key, n = r?.props.id;
+		if (e == null || n == null) {
+			i(null);
+			return;
+		}
+		Promise.resolve(t(n, a)).then(() => {
+			i(null);
+		});
+	}, [
+		t,
+		r,
+		a
+	]), o.createElement(o.Fragment, null, n, r ? s(r, { ref: c }) : null);
+}
+var bn = {
+	x: 0,
+	y: 0,
+	scaleX: 1,
+	scaleY: 1
+};
+function xn(e) {
+	let { children: t } = e;
+	return o.createElement($t.Provider, { value: Qt }, o.createElement(cn.Provider, { value: bn }, t));
+}
+var Sn = {
+	position: "fixed",
+	touchAction: "none"
+}, Cn = (e) => ae(e) ? "transform 250ms ease" : void 0, wn = /*#__PURE__*/ l((e, t) => {
+	let { as: n, activatorEvent: r, adjustScale: i, children: a, className: s, rect: c, style: l, transform: u, transition: d = Cn } = e;
+	if (!c) return null;
+	let f = i ? u : {
+		...u,
+		scaleX: 1,
+		scaleY: 1
+	}, p = {
+		...Sn,
+		width: c.width,
+		height: c.height,
+		top: c.top,
+		left: c.left,
+		transform: z.Transform.toString(f),
+		transformOrigin: i && r ? ge(r, c) : void 0,
+		transition: typeof d == "function" ? d(r) : d,
+		...l
+	};
+	return o.createElement(n, {
+		className: s,
+		style: p,
+		ref: t
+	}, a);
+}), Tn = {
+	duration: 250,
+	easing: "ease",
+	keyframes: (e) => {
+		let { transform: { initial: t, final: n } } = e;
+		return [{ transform: z.Transform.toString(t) }, { transform: z.Transform.toString(n) }];
+	},
+	sideEffects: /*#__PURE__*/ ((e) => (t) => {
+		let { active: n, dragOverlay: r } = t, i = {}, { styles: a, className: o } = e;
+		if (a != null && a.active) for (let [e, t] of Object.entries(a.active)) t !== void 0 && (i[e] = n.node.style.getPropertyValue(e), n.node.style.setProperty(e, t));
+		if (a != null && a.dragOverlay) for (let [e, t] of Object.entries(a.dragOverlay)) t !== void 0 && r.node.style.setProperty(e, t);
+		return o != null && o.active && n.node.classList.add(o.active), o != null && o.dragOverlay && r.node.classList.add(o.dragOverlay), function() {
+			for (let [e, t] of Object.entries(i)) n.node.style.setProperty(e, t);
+			o != null && o.active && n.node.classList.remove(o.active);
+		};
+	})({ styles: { active: { opacity: "0" } } })
+};
+function En(e) {
+	let { config: t, draggableNodes: n, droppableContainers: r, measuringConfiguration: i } = e;
+	return j((e, a) => {
+		if (t === null) return;
+		let o = n.get(e);
+		if (!o) return;
+		let s = o.node.current;
+		if (!s) return;
+		let c = Gt(a);
+		if (!c) return;
+		let { transform: l } = T(a).getComputedStyle(a), u = Ae(l);
+		if (!u) return;
+		let d = typeof t == "function" ? t : Dn(t);
+		return Ze(s, i.draggable.measure), d({
+			active: {
+				id: e,
+				data: o.data,
+				node: s,
+				rect: i.draggable.measure(s)
+			},
+			draggableNodes: n,
+			dragOverlay: {
+				node: a,
+				rect: i.dragOverlay.measure(c)
+			},
+			droppableContainers: r,
+			measuringConfiguration: i,
+			transform: u
+		});
+	});
+}
+function Dn(e) {
+	let { duration: t, easing: n, sideEffects: r, keyframes: i } = {
+		...Tn,
+		...e
+	};
+	return (e) => {
+		let { active: a, dragOverlay: o, transform: s, ...c } = e;
+		if (!t) return;
+		let l = {
+			x: o.rect.left - a.rect.left,
+			y: o.rect.top - a.rect.top
+		}, u = {
+			scaleX: s.scaleX === 1 ? 1 : a.rect.width * s.scaleX / o.rect.width,
+			scaleY: s.scaleY === 1 ? 1 : a.rect.height * s.scaleY / o.rect.height
+		}, d = {
+			x: s.x - l.x,
+			y: s.y - l.y,
+			...u
+		}, f = i({
+			...c,
+			active: a,
+			dragOverlay: o,
+			transform: {
+				initial: s,
+				final: d
+			}
+		}), [p] = f, m = f[f.length - 1];
+		if (JSON.stringify(p) === JSON.stringify(m)) return;
+		let h = r?.({
+			active: a,
+			dragOverlay: o,
+			...c
+		}), g = o.node.animate(f, {
+			duration: t,
+			easing: n,
+			fill: "forwards"
+		});
+		return new Promise((e) => {
+			g.onfinish = () => {
+				h?.(), e();
+			};
+		});
+	};
+}
+var On = 0;
+function kn(e) {
+	return h(() => {
+		if (e != null) return On++, On;
+	}, [e]);
+}
+var An = /*#__PURE__*/ o.memo((e) => {
+	let { adjustScale: t = !1, children: n, dropAnimation: r, style: i, transition: a, modifiers: s, wrapperElement: c = "div", className: l, zIndex: u = 999 } = e, { activatorEvent: d, active: p, activeNodeRect: m, containerNodeRect: h, draggableNodes: g, droppableContainers: _, dragOverlay: v, over: y, measuringConfiguration: b, scrollableAncestors: x, scrollableAncestorRects: S, windowRect: C } = hn(), w = f(cn), T = kn(p?.id), E = an(s, {
+		activatorEvent: d,
+		active: p,
+		activeNodeRect: m,
+		containerNodeRect: h,
+		draggingNodeRect: v.rect,
+		over: y,
+		overlayNodeRect: v.rect,
+		scrollableAncestors: x,
+		scrollableAncestorRects: S,
+		transform: w,
+		windowRect: C
+	}), D = kt(m), O = En({
+		config: r,
+		draggableNodes: g,
+		droppableContainers: _,
+		measuringConfiguration: b
+	}), k = D ? v.setRef : void 0;
+	return o.createElement(xn, null, o.createElement(yn, { animation: O }, p && T ? o.createElement(wn, {
+		key: T,
+		id: p.id,
+		ref: k,
+		as: c,
+		activatorEvent: d,
+		adjustScale: t,
+		className: l,
+		transition: a,
+		rect: D,
+		style: {
+			zIndex: u,
+			...i
+		},
+		transform: E
+	}, n) : null));
+});
+//#endregion
+//#region node_modules/@dnd-kit/sortable/dist/sortable.esm.js
+function jn(e, t, n) {
+	let r = e.slice();
+	return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function Mn(e, t) {
+	return e.reduce((e, n, r) => {
+		let i = t.get(n);
+		return i && (e[r] = i), e;
+	}, Array(e.length));
+}
+function Nn(e) {
+	return e !== null && e >= 0;
+}
+function Pn(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;
+}
+function Fn(e) {
+	return typeof e == "boolean" ? {
+		draggable: e,
+		droppable: e
+	} : e;
+}
+var In = {
+	scaleX: 1,
+	scaleY: 1
+}, Ln = (e) => {
+	let { rects: t, activeNodeRect: n, activeIndex: r, overIndex: i, index: a } = e, o = t[r] ?? n;
+	if (!o) return null;
+	let s = Rn(t, a, r);
+	if (a === r) {
+		let e = t[i];
+		return e ? {
+			x: r < i ? e.left + e.width - (o.left + o.width) : e.left - o.left,
+			y: 0,
+			...In
+		} : null;
+	}
+	return a > r && a <= i ? {
+		x: -o.width - s,
+		y: 0,
+		...In
+	} : a < r && a >= i ? {
+		x: o.width + s,
+		y: 0,
+		...In
+	} : {
+		x: 0,
+		y: 0,
+		...In
+	};
+};
+function Rn(e, t, n) {
+	let r = e[t], i = e[t - 1], a = e[t + 1];
+	return !r || !i && !a ? 0 : n < t ? i ? r.left - (i.left + i.width) : a.left - (r.left + r.width) : a ? a.left - (r.left + r.width) : r.left - (i.left + i.width);
+}
+var zn = (e) => {
+	let { rects: t, activeIndex: n, overIndex: r, index: i } = e, a = jn(t, r, n), o = t[i], s = a[i];
+	return !s || !o ? null : {
+		x: s.left - o.left,
+		y: s.top - o.top,
+		scaleX: s.width / o.width,
+		scaleY: s.height / o.height
+	};
+}, Bn = {
+	scaleX: 1,
+	scaleY: 1
+}, Vn = (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,
+			...Bn
+		} : null;
+	}
+	let s = Hn(i, r, t);
+	return r > t && r <= a ? {
+		x: 0,
+		y: -o.height - s,
+		...Bn
+	} : r < t && r >= a ? {
+		x: 0,
+		y: o.height + s,
+		...Bn
+	} : {
+		x: 0,
+		y: 0,
+		...Bn
+	};
+};
+function Hn(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;
+}
+var Un = "Sortable", Wn = /*#__PURE__*/ o.createContext({
+	activeIndex: -1,
+	containerId: Un,
+	disableTransforms: !1,
+	items: [],
+	overIndex: -1,
+	useDragOverlay: !1,
+	sortedRects: [],
+	strategy: zn,
+	disabled: {
+		draggable: !1,
+		droppable: !1
+	}
+});
+function Gn(e) {
+	let { children: t, id: n, items: r, strategy: i = zn, disabled: a = !1 } = e, { active: s, dragOverlay: c, droppableRects: l, over: u, measureDroppableContainers: d } = hn(), f = F(Un, n), m = c.rect !== null, g = h(() => r.map((e) => typeof e == "object" && "id" in e ? e.id : e), [r]), v = s != null, y = s ? g.indexOf(s.id) : -1, b = u ? g.indexOf(u.id) : -1, x = _(g), S = !Pn(g, x.current), C = b !== -1 && y === -1 || S, w = Fn(a);
+	A(() => {
+		S && v && d(g);
+	}, [
+		S,
+		g,
+		v,
+		d
+	]), p(() => {
+		x.current = g;
+	}, [g]);
+	let T = h(() => ({
+		activeIndex: y,
+		containerId: f,
+		disabled: w,
+		disableTransforms: C,
+		items: g,
+		overIndex: b,
+		useDragOverlay: m,
+		sortedRects: Mn(g, l),
+		strategy: i
+	}), [
+		y,
+		f,
+		w.draggable,
+		w.droppable,
+		C,
+		g,
+		b,
+		l,
+		m,
+		i
+	]);
+	return o.createElement(Wn.Provider, { value: T }, t);
+}
+var Kn = (e) => {
+	let { id: t, items: n, activeIndex: r, overIndex: i } = e;
+	return jn(n, r, i).indexOf(t);
+}, qn = (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 ? !1 : n ? !0 : o !== i && t === c;
+}, Jn = {
+	duration: 200,
+	easing: "ease"
+}, Yn = "transform", Xn = /*#__PURE__*/ z.Transition.toString({
+	property: Yn,
+	duration: 0,
+	easing: "linear"
+}), Zn = { roleDescription: "sortable" };
+function Qn(e) {
+	let { disabled: t, index: n, node: r, rect: i } = e, [a, o] = v(null), s = _(n);
+	return A(() => {
+		if (!t && n !== s.current && r.current) {
+			let e = i.current;
+			if (e) {
+				let t = X(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) && o(n);
+			}
+		}
+		n !== s.current && (s.current = n);
+	}, [
+		t,
+		n,
+		r,
+		i
+	]), p(() => {
+		a && o(null);
+	}, [a]), a;
+}
+function $n(e) {
+	let { animateLayoutChanges: t = qn, attributes: n, disabled: r, data: i, getNewIndex: a = Kn, id: o, strategy: s, resizeObserverConfig: c, transition: l = Jn } = e, { items: u, containerId: d, activeIndex: m, disabled: g, disableTransforms: v, sortedRects: y, overIndex: b, useDragOverlay: S, strategy: C } = f(Wn), w = er(r, g), T = u.indexOf(o), E = h(() => ({
+		sortable: {
+			containerId: d,
+			index: T,
+			items: u
+		},
+		...i
+	}), [
+		d,
+		i,
+		T,
+		u
+	]), D = h(() => u.slice(u.indexOf(o)), [u, o]), { rect: O, node: k, isOver: A, setNodeRef: j } = vn({
+		id: o,
+		data: E,
+		disabled: w.droppable,
+		resizeObserverConfig: {
+			updateMeasurementsFor: D,
+			...c
+		}
+	}), { active: M, activatorEvent: ee, activeNodeRect: N, attributes: P, setNodeRef: te, listeners: ne, isDragging: F, over: I, setActivatorNodeRef: re, transform: ie } = mn({
+		id: o,
+		data: E,
+		attributes: {
+			...Zn,
+			...n
+		},
+		disabled: w.draggable
+	}), L = x(j, te), R = !!M, oe = R && !v && Nn(m) && Nn(b), B = !S && F, se = oe ? (B && oe ? ie : null) ?? (s ?? C)({
+		rects: y,
+		activeNodeRect: N,
+		activeIndex: m,
+		overIndex: b,
+		index: T
+	}) : null, V = Nn(m) && Nn(b) ? a({
+		id: o,
+		items: u,
+		activeIndex: m,
+		overIndex: b
+	}) : T, H = M?.id, U = _({
+		activeId: H,
+		items: u,
+		newIndex: V,
+		containerId: d
+	}), ce = u !== U.current.items, le = t({
+		active: M,
+		containerId: d,
+		isDragging: F,
+		isSorting: R,
+		id: o,
+		index: T,
+		items: u,
+		newIndex: U.current.newIndex,
+		previousItems: U.current.items,
+		previousContainerId: U.current.containerId,
+		transition: l,
+		wasDragging: U.current.activeId != null
+	}), ue = Qn({
+		disabled: !le,
+		index: T,
+		node: k,
+		rect: O
+	});
+	return p(() => {
+		R && U.current.newIndex !== V && (U.current.newIndex = V), d !== U.current.containerId && (U.current.containerId = d), u !== U.current.items && (U.current.items = u);
+	}, [
+		R,
+		V,
+		d,
+		u
+	]), p(() => {
+		if (H === U.current.activeId) return;
+		if (H != null && U.current.activeId == null) {
+			U.current.activeId = H;
+			return;
+		}
+		let e = setTimeout(() => {
+			U.current.activeId = H;
+		}, 50);
+		return () => clearTimeout(e);
+	}, [H]), {
+		active: M,
+		activeIndex: m,
+		attributes: P,
+		data: E,
+		rect: O,
+		index: T,
+		newIndex: V,
+		items: u,
+		isOver: A,
+		isSorting: R,
+		isDragging: F,
+		listeners: ne,
+		node: k,
+		overIndex: b,
+		over: I,
+		setNodeRef: L,
+		setActivatorNodeRef: re,
+		setDroppableNodeRef: j,
+		setDraggableNodeRef: te,
+		transform: ue ?? se,
+		transition: de()
+	};
+	function de() {
+		if (ue || ce && U.current.newIndex === T) return Xn;
+		if (!(B && !ae(ee) || !l) && (R || le)) return z.Transition.toString({
+			...l,
+			property: Yn
+		});
+	}
+}
+function er(e, t) {
+	return typeof e == "boolean" ? {
+		draggable: e,
+		droppable: !1
+	} : {
+		draggable: e?.draggable ?? t.draggable,
+		droppable: e?.droppable ?? t.droppable
+	};
+}
+$.Down, $.Right, $.Up, $.Left;
+//#endregion
+//#region lib/components/ui/collections/dnd/compose-refs.ts
+function tr(...e) {
+	return (t) => {
+		for (let n of e) n && (typeof n == "function" ? n(t) : n.current = t);
+	};
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/dnd-item-context.ts
+var nr = c(null), rr = nr.Provider;
+function ir() {
+	return f(nr);
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/use-dnd-active-id.ts
+function ar() {
+	let { active: e } = hn();
+	return e?.id ?? null;
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/dnd-overlay.tsx
+function or({ children: e, dropAnimation: t }) {
+	let n = ar();
+	return /* @__PURE__ */ a(An, {
+		dropAnimation: t,
+		children: typeof e == "function" ? e(n) : e
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/dnd-provider.tsx
+function sr({ disabled: e = !1, children: t, sensors: n, collisionDetection: r = xe, ...i }) {
+	let o = q(me(ft, { activationConstraint: { distance: 6 } }));
+	return /* @__PURE__ */ a(un, {
+		sensors: e ? [] : n ?? o,
+		collisionDetection: r,
+		...i,
+		children: t
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/drag-handle.tsx
+function cr({ label: o, asSlot: s = !1, className: c, onClick: l, ...u }) {
+	let { t: d } = r(), f = o ?? d("material.dnd.drag", "Drag"), p = ir(), m = p?.listeners, h = p?.attributes, g = p?.setActivatorNodeRef;
+	return s ? /* @__PURE__ */ a(t, {
+		ref: g,
+		"data-slot": "drag-handle",
+		className: n("cursor-pointer", c),
+		...h,
+		...m,
+		...u
+	}) : /* @__PURE__ */ a(e, {
+		ref: g,
+		type: "button",
+		variant: "ghost",
+		tooltip: f,
+		"aria-label": f,
+		"data-slot": "drag-handle",
+		className: n("size-7 cursor-pointer", c),
+		onClick: (e) => {
+			e.stopPropagation(), l?.(e);
+		},
+		...h,
+		...m,
+		...u,
+		children: /* @__PURE__ */ a(i, {})
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/draggable.tsx
+function lr({ id: e, data: r, disabled: i, asSlot: o = !1, className: s, style: c, ...l }) {
+	let { attributes: u, listeners: d, setNodeRef: f, setActivatorNodeRef: p, transform: m, isDragging: h } = mn({
+		id: e,
+		data: r,
+		disabled: i
+	});
+	return /* @__PURE__ */ a(rr, {
+		value: {
+			attributes: u,
+			listeners: d,
+			isDragging: h,
+			setActivatorNodeRef: p
+		},
+		children: /* @__PURE__ */ a(o ? t : "div", {
+			ref: f,
+			"data-slot": "draggable",
+			"data-dragging": h || void 0,
+			style: {
+				transform: z.Translate.toString(m),
+				opacity: h ? .5 : void 0,
+				...c
+			},
+			className: n(!i && "cursor-pointer", s),
+			...u,
+			...d,
+			...l
+		})
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/draggable-droppable.tsx
+function ur({ id: e, data: r, disabled: i, asSlot: o = !1, className: s, style: c, ...l }) {
+	let u = mn({
+		id: e,
+		data: r,
+		disabled: i
+	}), d = vn({
+		id: e,
+		data: r,
+		disabled: i
+	}), f = o ? t : "div";
+	return /* @__PURE__ */ a(rr, {
+		value: {
+			attributes: u.attributes,
+			listeners: u.listeners,
+			isDragging: u.isDragging,
+			setActivatorNodeRef: u.setActivatorNodeRef
+		},
+		children: /* @__PURE__ */ a(f, {
+			ref: tr(u.setNodeRef, d.setNodeRef),
+			"data-slot": "draggable-droppable",
+			"data-dragging": u.isDragging || void 0,
+			"data-over": d.isOver || void 0,
+			style: {
+				transform: z.Translate.toString(u.transform),
+				opacity: u.isDragging ? .5 : void 0,
+				...c
+			},
+			className: n(!i && "cursor-pointer", d.isOver && "bg-primary/5", s),
+			...u.attributes,
+			...u.listeners,
+			...l
+		})
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/droppable.tsx
+function dr({ id: e, data: r, disabled: i, asSlot: o = !1, className: s, ...c }) {
+	let { setNodeRef: l, isOver: u } = vn({
+		id: e,
+		data: r,
+		disabled: i
+	});
+	return /* @__PURE__ */ a(o ? t : "div", {
+		ref: l,
+		"data-slot": "droppable",
+		"data-over": u || void 0,
+		className: n(u && "bg-primary/5", s),
+		...c
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/insert-ids.ts
+function fr(e, t, n, r) {
+	let i = t.filter((e, t, n) => n.indexOf(e) === t), a = e.filter((e) => !i.includes(e)), o = n == null ? a.length : a.indexOf(n);
+	o < 0 && (o = a.length);
+	let s = r == null ? i.length : Math.max(0, r - a.length), c = i.slice(0, s);
+	return c.length === 0 ? e : [
+		...a.slice(0, o),
+		...c,
+		...a.slice(o)
+	];
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/sortable.tsx
+function pr({ id: e, data: r, disabled: i, asSlot: o = !1, handleOnly: s = !1, className: c, style: l, ...u }) {
+	let d = $n({
+		id: e,
+		data: r,
+		disabled: i
+	}), f = o ? t : "div";
+	return /* @__PURE__ */ a(rr, {
+		value: {
+			attributes: d.attributes,
+			listeners: d.listeners,
+			isDragging: d.isDragging,
+			setActivatorNodeRef: d.setActivatorNodeRef
+		},
+		children: /* @__PURE__ */ a(f, {
+			ref: d.setNodeRef,
+			"data-slot": "sortable",
+			"data-dragging": d.isDragging || void 0,
+			style: {
+				transform: z.Transform.toString(d.transform),
+				transition: d.transition,
+				opacity: d.isDragging ? .5 : void 0,
+				...l
+			},
+			className: n(!i && !s && "cursor-pointer", c),
+			...s ? {} : d.attributes,
+			...s ? {} : d.listeners,
+			...u
+		})
+	});
+}
+//#endregion
+//#region lib/components/ui/collections/dnd/sortable-provider.tsx
+function mr({ items: e, strategy: t = Vn, children: n }) {
+	return /* @__PURE__ */ a(Gn, {
+		items: e,
+		strategy: t,
+		children: n
+	});
+}
+//#endregion
+export { Te as _, ur as a, sr as c, ir as d, tr as f, xe as g, Vn as h, dr as i, or as l, Ln as m, pr as n, lr as o, jn as p, fr as r, cr as s, mr as t, ar as u, Ce as v, z as y };