@noxickon/onyx 5.0.2 → 6.0.0

package/dist/node_modules/@dnd-kit/core/dist/core.esm.js

@@ -0,0 +1,1767 @@
+import { add as e, canUseDOM as t, findFirstFocusableNode as n, getEventCoordinates as r, getOwnerDocument as i, getWindow as a, isDocument as o, isHTMLElement as s, isKeyboardEvent as c, isNode as l, isSVGElement as u, isWindow as d, subtract as f, useEvent as p, useInterval as m, useIsomorphicLayoutEffect as h, useLatestValue as g, useLazyMemo as _, useNodeRef as v, usePrevious as y, useUniqueId as ee } from "../../utilities/dist/utilities.esm.js";
+import { HiddenText as b, LiveRegion as x, useAnnouncement as S } from "../../accessibility/dist/accessibility.esm.js";
+import C, { createContext as w, memo as T, useCallback as E, useContext as D, useEffect as O, useMemo as k, useReducer as te, useRef as A, useState as j } from "react";
+import { createPortal as ne, unstable_batchedUpdates as re } from "react-dom";
+//#region node_modules/@dnd-kit/core/dist/core.esm.js
+var ie = /*#__PURE__*/ w(null);
+function ae(e) {
+	let t = D(ie);
+	O(() => {
+		if (!t) throw Error("useDndMonitor must be used within a children of <DndContext>");
+		return t(e);
+	}, [e, t]);
+}
+function oe() {
+	let [e] = j(() => /* @__PURE__ */ new Set()), t = E((t) => (e.add(t), () => e.delete(t)), [e]);
+	return [E((t) => {
+		let { type: n, event: r } = t;
+		e.forEach((e) => e[n]?.call(e, r));
+	}, [e]), t];
+}
+var M = { 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  " }, N = {
+	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 se(e) {
+	let { announcements: t = N, container: n, hiddenTextDescribedById: r, screenReaderInstructions: i = M } = e, { announce: a, announcement: o } = S(), s = ee("DndLiveRegion"), [c, l] = j(!1);
+	if (O(() => {
+		l(!0);
+	}, []), ae(k(() => ({
+		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])), !c) return null;
+	let u = C.createElement(C.Fragment, null, C.createElement(b, {
+		id: r,
+		value: i.draggable
+	}), C.createElement(x, {
+		id: s,
+		announcement: o
+	}));
+	return n ? ne(u, n) : u;
+}
+var P;
+(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";
+})(P ||= {});
+function ce() {}
+function le(e, t) {
+	return k(() => ({
+		sensor: e,
+		options: t ?? {}
+	}), [e, t]);
+}
+function F() {
+	var e = [...arguments];
+	return k(() => [...e].filter((e) => e != null), [...e]);
+}
+var I = /*#__PURE__*/ Object.freeze({
+	x: 0,
+	y: 0
+});
+function L(e, t) {
+	return Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
+}
+function ue(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return n - r;
+}
+function de(e, t) {
+	let { data: { value: n } } = e, { data: { value: r } } = t;
+	return r - n;
+}
+function R(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 fe(e, t) {
+	if (!e || e.length === 0) return null;
+	let [n] = e;
+	return t ? n[t] : n;
+}
+function z(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 pe = (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 = L(z(r), i);
+			a.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return a.sort(ue);
+}, me = (e) => {
+	let { collisionRect: t, droppableRects: n, droppableContainers: r } = e, i = R(t), a = [];
+	for (let e of r) {
+		let { id: t } = e, r = n.get(t);
+		if (r) {
+			let n = R(r), o = i.reduce((e, t, r) => e + L(n[r], t), 0), s = Number((o / 4).toFixed(4));
+			a.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: s
+				}
+			});
+		}
+	}
+	return a.sort(ue);
+};
+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, a = i / (n + r - i);
+		return Number(a.toFixed(4));
+	}
+	return 0;
+}
+var he = (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(de);
+};
+function ge(e, t, n) {
+	return {
+		...e,
+		scaleX: t && n ? t.width / n.width : 1,
+		scaleY: t && n ? t.height / n.height : 1
+	};
+}
+function _e(e, t) {
+	return e && t ? {
+		x: e.left - t.left,
+		y: e.top - t.top
+	} : I;
+}
+function ve(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 ye = /*#__PURE__*/ ve(1);
+function be(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 V(e, t, n) {
+	let r = be(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 xe = { ignoreTransform: !1 };
+function H(e, t) {
+	t === void 0 && (t = xe);
+	let n = e.getBoundingClientRect();
+	if (t.ignoreTransform) {
+		let { transform: t, transformOrigin: r } = a(e).getComputedStyle(e);
+		t && (n = V(n, t, r));
+	}
+	let { top: r, left: i, width: o, height: s, bottom: c, right: l } = n;
+	return {
+		top: r,
+		left: i,
+		width: o,
+		height: s,
+		bottom: c,
+		right: l
+	};
+}
+function Se(e) {
+	return H(e, { ignoreTransform: !0 });
+}
+function U(e) {
+	let t = e.innerWidth, n = e.innerHeight;
+	return {
+		top: 0,
+		left: 0,
+		right: t,
+		bottom: n,
+		width: t,
+		height: n
+	};
+}
+function Ce(e, t) {
+	return t === void 0 && (t = a(e).getComputedStyle(e)), t.position === "fixed";
+}
+function W(e, t) {
+	t === void 0 && (t = a(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) : !1;
+	});
+}
+function we(e, t) {
+	let n = [];
+	function r(i) {
+		if (t != null && n.length >= t || !i) return n;
+		if (o(i) && i.scrollingElement != null && !n.includes(i.scrollingElement)) return n.push(i.scrollingElement), n;
+		if (!s(i) || u(i) || n.includes(i)) return n;
+		let c = a(e).getComputedStyle(i);
+		return i !== e && W(i, c) && n.push(i), Ce(i, c) ? n : r(i.parentNode);
+	}
+	return e ? r(e) : n;
+}
+function Te(e) {
+	let [t] = we(e, 1);
+	return t ?? null;
+}
+function Ee(e) {
+	return !t || !e ? null : d(e) ? e : l(e) ? o(e) || e === i(e).scrollingElement ? window : s(e) ? e : null : null;
+}
+function G(e) {
+	return d(e) ? e.scrollX : e.scrollLeft;
+}
+function De(e) {
+	return d(e) ? e.scrollY : e.scrollTop;
+}
+function K(e) {
+	return {
+		x: G(e),
+		y: De(e)
+	};
+}
+var q;
+(function(e) {
+	e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(q ||= {});
+function Oe(e) {
+	return !t || !e ? !1 : e === document.scrollingElement;
+}
+function ke(e) {
+	let t = {
+		x: 0,
+		y: 0
+	}, n = Oe(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 Ae = {
+	x: .2,
+	y: .2
+};
+function J(e, t, n, r, i) {
+	let { top: a, left: o, right: s, bottom: c } = n;
+	r === void 0 && (r = 10), i === void 0 && (i = Ae);
+	let { isTop: l, isBottom: u, isLeft: d, isRight: f } = ke(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 = q.Backward, m.y = r * Math.abs((t.top + h.height - a) / h.height)) : !u && c >= t.bottom - h.height && (p.y = q.Forward, m.y = r * Math.abs((t.bottom - h.height - c) / h.height)), !f && s >= t.right - h.width ? (p.x = q.Forward, m.x = r * Math.abs((t.right - h.width - s) / h.width)) : !d && o <= t.left + h.width && (p.x = q.Backward, m.x = r * Math.abs((t.left + h.width - o) / h.width)), {
+		direction: p,
+		speed: m
+	};
+}
+function Y(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 X(t) {
+	return t.reduce((t, n) => e(t, K(n)), I);
+}
+function je(e) {
+	return e.reduce((e, t) => e + G(t), 0);
+}
+function Z(e) {
+	return e.reduce((e, t) => e + De(t), 0);
+}
+function Me(e, t) {
+	if (t === void 0 && (t = H), !e) return;
+	let { top: n, left: r, bottom: i, right: a } = t(e);
+	Te(e) && (i <= 0 || a <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+		block: "center",
+		inline: "center"
+	});
+}
+var Ne = [[
+	"x",
+	["left", "right"],
+	je
+], [
+	"y",
+	["top", "bottom"],
+	Z
+]], Pe = 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 = we(t), r = X(n);
+		this.rect = { ...e }, this.width = e.width, this.height = e.height;
+		for (let [e, t, i] of Ne) 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 });
+	}
+}, Fe = 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 Ie(e) {
+	let { EventTarget: t } = a(e);
+	return e instanceof t ? e : i(e);
+}
+function Le(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 : !1;
+}
+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 Re(e) {
+	e.preventDefault();
+}
+function ze(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 Be = {
+	start: [$.Space, $.Enter],
+	cancel: [$.Esc],
+	end: [
+		$.Space,
+		$.Enter,
+		$.Tab
+	]
+}, Ve = (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
+		};
+	}
+}, He = 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 Fe(i(t)), this.windowListeners = new Fe(a(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 && Me(n), t(I);
+	}
+	handleKeyDown(t) {
+		if (c(t)) {
+			let { active: n, context: r, options: i } = this.props, { keyboardCodes: a = Be, coordinateGetter: o = Ve, scrollBehavior: s = "smooth" } = i, { code: c } = t;
+			if (a.end.includes(c)) {
+				this.handleEnd(t);
+				return;
+			}
+			if (a.cancel.includes(c)) {
+				this.handleCancel(t);
+				return;
+			}
+			let { collisionRect: l } = r.current, u = l ? {
+				x: l.left,
+				y: l.top
+			} : I;
+			this.referenceCoordinates ||= u;
+			let d = o(t, {
+				active: n,
+				context: r.current,
+				currentCoordinates: u
+			});
+			if (d) {
+				let n = f(d, u), i = {
+					x: 0,
+					y: 0
+				}, { scrollableAncestors: a } = r.current;
+				for (let e of a) {
+					let r = t.code, { isTop: a, isRight: o, isLeft: c, isBottom: l, maxScroll: u, minScroll: f } = ke(e), p = Y(e), m = {
+						x: Math.min(r === $.Right ? p.right - p.width / 2 : p.right, Math.max(r === $.Right ? p.left : p.left + p.width / 2, d.x)),
+						y: Math.min(r === $.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(r === $.Down ? p.top : p.top + p.height / 2, d.y))
+					}, h = r === $.Right && !o || r === $.Left && !c, g = r === $.Down && !l || r === $.Up && !a;
+					if (h && m.x !== d.x) {
+						let t = e.scrollLeft + n.x, a = r === $.Right && t <= u.x || r === $.Left && t >= f.x;
+						if (a && !n.y) {
+							e.scrollTo({
+								left: t,
+								behavior: s
+							});
+							return;
+						}
+						a ? i.x = e.scrollLeft - t : i.x = r === $.Right ? e.scrollLeft - u.x : e.scrollLeft - f.x, i.x && e.scrollBy({
+							left: -i.x,
+							behavior: s
+						});
+						break;
+					} else if (g && m.y !== d.y) {
+						let t = e.scrollTop + n.y, a = r === $.Down && t <= u.y || r === $.Up && t >= f.y;
+						if (a && !n.x) {
+							e.scrollTo({
+								top: t,
+								behavior: s
+							});
+							return;
+						}
+						a ? i.y = e.scrollTop - t : i.y = r === $.Down ? e.scrollTop - u.y : e.scrollTop - f.y, i.y && e.scrollBy({
+							top: -i.y,
+							behavior: s
+						});
+						break;
+					}
+				}
+				this.handleMove(t, e(f(d, this.referenceCoordinates), i));
+			}
+		}
+	}
+	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();
+	}
+};
+He.activators = [{
+	eventName: "onKeyDown",
+	handler: (e, t, n) => {
+		let { keyboardCodes: r = Be, 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 Ue(e) {
+	return !!(e && "distance" in e);
+}
+function We(e) {
+	return !!(e && "delay" in e);
+}
+var Ge = class {
+	constructor(e, t, n) {
+		n === void 0 && (n = Ie(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: o } = e, { target: s } = o;
+		this.props = e, this.events = t, this.document = i(s), this.documentListeners = new Fe(this.document), this.listeners = new Fe(n), this.windowListeners = new Fe(a(s)), this.initialCoordinates = r(o) ?? 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(Q.Resize, this.handleCancel), this.windowListeners.add(Q.DragStart, Re), this.windowListeners.add(Q.VisibilityChange, this.handleCancel), this.windowListeners.add(Q.ContextMenu, Re), 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 (We(t)) {
+				this.timeoutId = setTimeout(this.handleStart, t.delay), this.handlePending(t);
+				return;
+			}
+			if (Ue(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, ze, { capture: !0 }), this.removeTextSelection(), this.documentListeners.add(Q.SelectionChange, this.removeTextSelection), t(e));
+	}
+	handleMove(e) {
+		let { activated: t, initialCoordinates: n, props: i } = this, { onMove: a, options: { activationConstraint: o } } = i;
+		if (!n) return;
+		let s = r(e) ?? I, c = f(n, s);
+		if (!t && o) {
+			if (Ue(o)) {
+				if (o.tolerance != null && Le(c, o.tolerance)) return this.handleCancel();
+				if (Le(c, o.distance)) return this.handleStart();
+			}
+			if (We(o) && Le(c, o.tolerance)) return this.handleCancel();
+			this.handlePending(o, c);
+			return;
+		}
+		e.cancelable && e.preventDefault(), a(s);
+	}
+	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();
+	}
+}, Ke = {
+	cancel: { name: "pointercancel" },
+	move: { name: "pointermove" },
+	end: { name: "pointerup" }
+}, qe = class extends Ge {
+	constructor(e) {
+		let { event: t } = e, n = i(t.target);
+		super(e, Ke, n);
+	}
+};
+qe.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 Je = {
+	move: { name: "mousemove" },
+	end: { name: "mouseup" }
+}, Ye;
+(function(e) {
+	e[e.RightClick = 2] = "RightClick";
+})(Ye ||= {});
+var Xe = class extends Ge {
+	constructor(e) {
+		super(e, Je, i(e.event.target));
+	}
+};
+Xe.activators = [{
+	eventName: "onMouseDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return n.button === Ye.RightClick ? !1 : (r?.({ event: n }), !0);
+	}
+}];
+var Ze = {
+	cancel: { name: "touchcancel" },
+	move: { name: "touchmove" },
+	end: { name: "touchend" }
+}, Qe = class extends Ge {
+	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() {}
+	}
+};
+Qe.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 $e;
+(function(e) {
+	e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})($e ||= {});
+var et;
+(function(e) {
+	e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(et ||= {});
+function tt(e) {
+	let { acceleration: t, activator: n = $e.Pointer, canScroll: r, draggingRect: i, enabled: a, interval: o = 5, order: s = et.TreeOrder, pointerCoordinates: c, scrollableAncestors: l, scrollableAncestorRects: u, delta: d, threshold: f } = e, p = rt({
+		delta: d,
+		disabled: !a
+	}), [h, g] = m(), _ = A({
+		x: 0,
+		y: 0
+	}), v = A({
+		x: 0,
+		y: 0
+	}), y = k(() => {
+		switch (n) {
+			case $e.Pointer: return c ? {
+				top: c.y,
+				bottom: c.y,
+				left: c.x,
+				right: c.x
+			} : null;
+			case $e.DraggableRect: return i;
+		}
+	}, [
+		n,
+		i,
+		c
+	]), ee = A(null), b = E(() => {
+		let e = ee.current;
+		if (!e) return;
+		let t = _.current.x * v.current.x, n = _.current.y * v.current.y;
+		e.scrollBy(t, n);
+	}, []), x = k(() => s === et.TreeOrder ? [...l].reverse() : l, [s, l]);
+	O(() => {
+		if (!a || !l.length || !y) {
+			g();
+			return;
+		}
+		for (let e of x) {
+			if (r?.(e) === !1) continue;
+			let n = l.indexOf(e), i = u[n];
+			if (!i) continue;
+			let { direction: a, speed: s } = J(e, i, y, t, f);
+			for (let e of ["x", "y"]) p[e][a[e]] || (s[e] = 0, a[e] = 0);
+			if (s.x > 0 || s.y > 0) {
+				g(), ee.current = e, h(b, o), _.current = s, v.current = a;
+				return;
+			}
+		}
+		_.current = {
+			x: 0,
+			y: 0
+		}, v.current = {
+			x: 0,
+			y: 0
+		}, g();
+	}, [
+		t,
+		b,
+		r,
+		g,
+		a,
+		o,
+		JSON.stringify(y),
+		JSON.stringify(p),
+		h,
+		l,
+		x,
+		u,
+		JSON.stringify(f)
+	]);
+}
+var nt = {
+	x: {
+		[q.Backward]: !1,
+		[q.Forward]: !1
+	},
+	y: {
+		[q.Backward]: !1,
+		[q.Forward]: !1
+	}
+};
+function rt(e) {
+	let { delta: t, disabled: n } = e, r = y(t);
+	return _((e) => {
+		if (n || !r || !e) return nt;
+		let i = {
+			x: Math.sign(t.x - r.x),
+			y: Math.sign(t.y - r.y)
+		};
+		return {
+			x: {
+				[q.Backward]: e.x[q.Backward] || i.x === -1,
+				[q.Forward]: e.x[q.Forward] || i.x === 1
+			},
+			y: {
+				[q.Backward]: e.y[q.Backward] || i.y === -1,
+				[q.Forward]: e.y[q.Forward] || i.y === 1
+			}
+		};
+	}, [
+		n,
+		t,
+		r
+	]);
+}
+function it(e, t) {
+	let n = t == null ? void 0 : e.get(t), r = n ? n.node.current : null;
+	return _((e) => t == null ? null : r ?? e ?? null, [r, t]);
+}
+function at(e, t) {
+	return k(() => 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 ot;
+(function(e) {
+	e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(ot ||= {});
+var st;
+(function(e) {
+	e.Optimized = "optimized";
+})(st ||= {});
+var ct = /*#__PURE__*/ new Map();
+function lt(e, t) {
+	let { dragging: n, dependencies: r, config: i } = t, [a, o] = j(null), { frequency: s, measure: c, strategy: l } = i, u = A(e), d = v(), f = g(d), p = E(function(e) {
+		e === void 0 && (e = []), !f.current && o((t) => t === null ? e : t.concat(e.filter((e) => !t.includes(e))));
+	}, [f]), m = A(null), h = _((t) => {
+		if (d && !n) return ct;
+		if (!t || t === ct || 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 Pe(c(e), e) : null;
+				n.rect.current = r, r && t.set(n.id, r);
+			}
+			return t;
+		}
+		return t;
+	}, [
+		e,
+		a,
+		n,
+		d,
+		c
+	]);
+	return O(() => {
+		u.current = e;
+	}, [e]), O(() => {
+		d || p();
+	}, [n, d]), O(() => {
+		a && a.length > 0 && o(null);
+	}, [JSON.stringify(a)]), O(() => {
+		d || typeof s != "number" || m.current !== null || (m.current = setTimeout(() => {
+			p(), m.current = null;
+		}, s));
+	}, [
+		s,
+		d,
+		p,
+		...r
+	]), {
+		droppableRects: h,
+		measureDroppableContainers: p,
+		measuringScheduled: a != null
+	};
+	function v() {
+		switch (l) {
+			case ot.Always: return !1;
+			case ot.BeforeDragging: return n;
+			default: return !n;
+		}
+	}
+}
+function ut(e, t) {
+	return _((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function dt(e, t) {
+	return ut(e, t);
+}
+function ft(e) {
+	let { callback: t, disabled: n } = e, r = p(t), i = k(() => {
+		if (n || typeof window > "u" || window.MutationObserver === void 0) return;
+		let { MutationObserver: e } = window;
+		return new e(r);
+	}, [r, n]);
+	return O(() => () => i?.disconnect(), [i]), i;
+}
+function pt(e) {
+	let { callback: t, disabled: n } = e, r = p(t), i = k(() => {
+		if (n || typeof window > "u" || window.ResizeObserver === void 0) return;
+		let { ResizeObserver: e } = window;
+		return new e(r);
+	}, [n]);
+	return O(() => () => i?.disconnect(), [i]), i;
+}
+function mt(e) {
+	return new Pe(H(e), e);
+}
+function ht(e, t, n) {
+	t === void 0 && (t = mt);
+	let [r, i] = j(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 = ft({ 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 = pt({ callback: a });
+	return h(() => {
+		a(), e ? (s?.observe(e), o?.observe(document.body, {
+			childList: !0,
+			subtree: !0
+		})) : (s?.disconnect(), o?.disconnect());
+	}, [e]), r;
+}
+function gt(e) {
+	return _e(e, ut(e));
+}
+var _t = [];
+function vt(e) {
+	let t = A(e), n = _((n) => e ? n && n !== _t && e && t.current && e.parentNode === t.current.parentNode ? n : we(e) : _t, [e]);
+	return O(() => {
+		t.current = e;
+	}, [e]), n;
+}
+function yt(t) {
+	let [n, r] = j(null), i = A(t), a = E((e) => {
+		let t = Ee(e.target);
+		t && r((e) => e ? (e.set(t, K(t)), new Map(e)) : null);
+	}, []);
+	return O(() => {
+		let e = i.current;
+		if (t !== e) {
+			n(e);
+			let o = t.map((e) => {
+				let t = Ee(e);
+				return t ? (t.addEventListener("scroll", a, { passive: !0 }), [t, K(t)]) : null;
+			}).filter((e) => e != null);
+			r(o.length ? new Map(o) : null), i.current = t;
+		}
+		return () => {
+			n(t), n(e);
+		};
+		function n(e) {
+			e.forEach((e) => {
+				Ee(e)?.removeEventListener("scroll", a);
+			});
+		}
+	}, [a, t]), k(() => t.length ? n ? Array.from(n.values()).reduce((t, n) => e(t, n), I) : X(t) : I, [t, n]);
+}
+function bt(e, t) {
+	t === void 0 && (t = []);
+	let n = A(null);
+	return O(() => {
+		n.current = null;
+	}, t), O(() => {
+		let t = e !== I;
+		t && !n.current && (n.current = e), !t && n.current && (n.current = null);
+	}, [e]), n.current ? f(e, n.current) : I;
+}
+function xt(e) {
+	O(() => {
+		if (!t) return;
+		let n = e.map((e) => {
+			let { sensor: t } = e;
+			return t.setup == null ? void 0 : t.setup();
+		});
+		return () => {
+			for (let e of n) e?.();
+		};
+	}, e.map((e) => {
+		let { sensor: t } = e;
+		return t;
+	}));
+}
+function St(e, t) {
+	return k(() => e.reduce((e, n) => {
+		let { eventName: r, handler: i } = n;
+		return e[r] = (e) => {
+			i(e, t);
+		}, e;
+	}, {}), [e, t]);
+}
+function Ct(e) {
+	return k(() => e ? U(e) : null, [e]);
+}
+var wt = [];
+function Tt(e, t) {
+	t === void 0 && (t = H);
+	let [n] = e, r = Ct(n ? a(n) : null), [i, o] = j(wt);
+	function s() {
+		o(() => e.length ? e.map((e) => Oe(e) ? r : new Pe(t(e), e)) : wt);
+	}
+	let c = pt({ callback: s });
+	return h(() => {
+		c?.disconnect(), s(), e.forEach((e) => c?.observe(e));
+	}, [e]), i;
+}
+function Et(e) {
+	if (!e) return null;
+	if (e.children.length > 1) return e;
+	let t = e.children[0];
+	return s(t) ? t : e;
+}
+function Dt(e) {
+	let { measure: t } = e, [n, r] = j(null), i = pt({ callback: E((e) => {
+		for (let { target: n } of e) if (s(n)) {
+			r((e) => {
+				let r = t(n);
+				return e ? {
+					...e,
+					width: r.width,
+					height: r.height
+				} : r;
+			});
+			break;
+		}
+	}, [t]) }), [a, o] = v(E((e) => {
+		let n = Et(e);
+		i?.disconnect(), n && i?.observe(n), r(n ? t(n) : null);
+	}, [t, i]));
+	return k(() => ({
+		nodeRef: a,
+		rect: n,
+		setRef: o
+	}), [
+		n,
+		a,
+		o
+	]);
+}
+var Ot = [{
+	sensor: qe,
+	options: {}
+}, {
+	sensor: He,
+	options: {}
+}], kt = { current: {} }, At = {
+	draggable: { measure: Se },
+	droppable: {
+		measure: Se,
+		strategy: ot.WhileDragging,
+		frequency: st.Optimized
+	},
+	dragOverlay: { measure: H }
+}, jt = 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;
+	}
+}, Mt = {
+	activatorEvent: null,
+	active: null,
+	activeNode: null,
+	activeNodeRect: null,
+	collisions: null,
+	containerNodeRect: null,
+	draggableNodes: /*#__PURE__*/ new Map(),
+	droppableRects: /*#__PURE__*/ new Map(),
+	droppableContainers: /*#__PURE__*/ new jt(),
+	over: null,
+	dragOverlay: {
+		nodeRef: { current: null },
+		rect: null,
+		setRef: ce
+	},
+	scrollableAncestors: [],
+	scrollableAncestorRects: [],
+	measuringConfiguration: At,
+	measureDroppableContainers: ce,
+	windowRect: null,
+	measuringScheduled: !1
+}, Nt = /*#__PURE__*/ w({
+	activatorEvent: null,
+	activators: [],
+	active: null,
+	activeNodeRect: null,
+	ariaDescribedById: { draggable: "" },
+	dispatch: ce,
+	draggableNodes: /*#__PURE__*/ new Map(),
+	over: null,
+	measureDroppableContainers: ce
+}), Pt = /*#__PURE__*/ w(Mt);
+function Ft() {
+	return {
+		draggable: {
+			active: null,
+			initialCoordinates: {
+				x: 0,
+				y: 0
+			},
+			nodes: /* @__PURE__ */ new Map(),
+			translate: {
+				x: 0,
+				y: 0
+			}
+		},
+		droppable: { containers: new jt() }
+	};
+}
+function It(e, t) {
+	switch (t.type) {
+		case P.DragStart: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				initialCoordinates: t.initialCoordinates,
+				active: t.active
+			}
+		};
+		case P.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 P.DragEnd:
+		case P.DragCancel: return {
+			...e,
+			draggable: {
+				...e.draggable,
+				active: null,
+				initialCoordinates: {
+					x: 0,
+					y: 0
+				},
+				translate: {
+					x: 0,
+					y: 0
+				}
+			}
+		};
+		case P.RegisterDroppable: {
+			let { element: n } = t, { id: r } = n, i = new jt(e.droppable.containers);
+			return i.set(r, n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: i
+				}
+			};
+		}
+		case P.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 jt(e.droppable.containers);
+			return o.set(n, {
+				...a,
+				disabled: i
+			}), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: o
+				}
+			};
+		}
+		case P.UnregisterDroppable: {
+			let { id: n, key: r } = t, i = e.droppable.containers.get(n);
+			if (!i || r !== i.key) return e;
+			let a = new jt(e.droppable.containers);
+			return a.delete(n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: a
+				}
+			};
+		}
+		default: return e;
+	}
+}
+function Lt(e) {
+	let { disabled: t } = e, { active: r, activatorEvent: i, draggableNodes: a } = D(Nt), o = y(i), s = y(r?.id);
+	return O(() => {
+		if (!t && !i && o && s != null) {
+			if (!c(o) || document.activeElement === o.target) return;
+			let e = a.get(s);
+			if (!e) return;
+			let { activatorNode: t, node: r } = e;
+			if (!t.current && !r.current) return;
+			requestAnimationFrame(() => {
+				for (let e of [t.current, r.current]) {
+					if (!e) continue;
+					let t = n(e);
+					if (t) {
+						t.focus();
+						break;
+					}
+				}
+			});
+		}
+	}, [
+		i,
+		t,
+		a,
+		s,
+		o
+	]), null;
+}
+function Rt(e, t) {
+	let { transform: n, ...r } = t;
+	return e != null && e.length ? e.reduce((e, t) => t({
+		transform: e,
+		...r
+	}), n) : n;
+}
+function zt(e) {
+	return k(() => ({
+		draggable: {
+			...At.draggable,
+			...e?.draggable
+		},
+		droppable: {
+			...At.droppable,
+			...e?.droppable
+		},
+		dragOverlay: {
+			...At.dragOverlay,
+			...e?.dragOverlay
+		}
+	}), [
+		e?.draggable,
+		e?.droppable,
+		e?.dragOverlay
+	]);
+}
+function Bt(e) {
+	let { activeNode: t, measure: n, initialRect: r, config: i = !0 } = e, a = A(!1), { x: o, y: s } = typeof i == "boolean" ? {
+		x: i,
+		y: i
+	} : i;
+	h(() => {
+		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 = _e(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 = Te(e);
+			t && t.scrollBy({
+				top: i.y,
+				left: i.x
+			});
+		}
+	}, [
+		t,
+		o,
+		s,
+		r,
+		n
+	]);
+}
+var Vt = /*#__PURE__*/ w({
+	...I,
+	scaleX: 1,
+	scaleY: 1
+}), Ht;
+(function(e) {
+	e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(Ht ||= {});
+var Ut = /*#__PURE__*/ T(function(t) {
+	let { id: n, accessibility: i, autoScroll: o = !0, children: s, sensors: c = Ot, collisionDetection: l = he, measuring: u, modifiers: d, ...f } = t, [p, m] = te(It, void 0, Ft), [_, v] = oe(), [y, b] = j(Ht.Uninitialized), x = y === Ht.Initialized, { draggable: { active: S, nodes: w, translate: T }, droppable: { containers: D } } = p, ne = S == null ? null : w.get(S), ae = A({
+		initial: null,
+		translated: null
+	}), M = k(() => S == null ? null : {
+		id: S,
+		data: ne?.data ?? kt,
+		rect: ae
+	}, [S, ne]), N = A(null), [ce, le] = j(null), [F, I] = j(null), L = g(f, Object.values(f)), ue = ee("DndDescribedBy", n), de = k(() => D.getEnabled(), [D]), R = zt(u), { droppableRects: z, measureDroppableContainers: pe, measuringScheduled: me } = lt(de, {
+		dragging: x,
+		dependencies: [T.x, T.y],
+		config: R.droppable
+	}), B = it(w, S), _e = k(() => F ? r(F) : null, [F]), ve = Re(), be = dt(B, R.draggable.measure);
+	Bt({
+		activeNode: S == null ? null : w.get(S),
+		config: ve.layoutShiftCompensation,
+		initialRect: be,
+		measure: R.draggable.measure
+	});
+	let V = ht(B, R.draggable.measure, be), xe = ht(B ? B.parentElement : null), H = A({
+		activatorEvent: null,
+		active: null,
+		activeNode: B,
+		collisionRect: null,
+		collisions: null,
+		droppableRects: z,
+		draggableNodes: w,
+		draggingNode: null,
+		draggingNodeRect: null,
+		droppableContainers: D,
+		over: null,
+		scrollableAncestors: [],
+		scrollAdjustedTranslate: null
+	}), Se = D.getNodeFor(H.current.over?.id), U = Dt({ measure: R.dragOverlay.measure }), Ce = U.nodeRef.current ?? B, W = x ? U.rect ?? V : null, we = !!(U.nodeRef.current && U.rect), Te = gt(we ? null : V), Ee = Ct(Ce ? a(Ce) : null), G = vt(x ? Se ?? B : null), De = Tt(G), K = Rt(d, {
+		transform: {
+			x: T.x - Te.x,
+			y: T.y - Te.y,
+			scaleX: 1,
+			scaleY: 1
+		},
+		activatorEvent: F,
+		active: M,
+		activeNodeRect: V,
+		containerNodeRect: xe,
+		draggingNodeRect: W,
+		over: H.current.over,
+		overlayNodeRect: U.rect,
+		scrollableAncestors: G,
+		scrollableAncestorRects: De,
+		windowRect: Ee
+	}), q = _e ? e(_e, T) : null, Oe = yt(G), ke = bt(Oe), Ae = bt(Oe, [V]), J = e(K, ke), Y = W ? ye(W, K) : null, X = M && Y ? l({
+		active: M,
+		collisionRect: Y,
+		droppableRects: z,
+		droppableContainers: de,
+		pointerCoordinates: q
+	}) : null, je = fe(X, "id"), [Z, Me] = j(null), Ne = ge(we ? K : e(K, Ae), Z?.rect ?? null, V), Pe = A(null), Fe = E((e, t) => {
+		let { sensor: n, options: r } = t;
+		if (N.current == null) return;
+		let i = w.get(N.current);
+		if (!i) return;
+		let a = e.nativeEvent, o = new n({
+			active: N.current,
+			activeNode: i,
+			event: a,
+			options: r,
+			context: H,
+			onAbort(e) {
+				if (!w.get(e)) return;
+				let { onDragAbort: t } = L.current, n = { id: e };
+				t?.(n), _({
+					type: "onDragAbort",
+					event: n
+				});
+			},
+			onPending(e, t, n, r) {
+				if (!w.get(e)) return;
+				let { onDragPending: i } = L.current, a = {
+					id: e,
+					constraint: t,
+					initialCoordinates: n,
+					offset: r
+				};
+				i?.(a), _({
+					type: "onDragPending",
+					event: a
+				});
+			},
+			onStart(e) {
+				let t = N.current;
+				if (t == null) return;
+				let n = w.get(t);
+				if (!n) return;
+				let { onDragStart: r } = L.current, i = {
+					activatorEvent: a,
+					active: {
+						id: t,
+						data: n.data,
+						rect: ae
+					}
+				};
+				re(() => {
+					r?.(i), b(Ht.Initializing), m({
+						type: P.DragStart,
+						initialCoordinates: e,
+						active: t
+					}), _({
+						type: "onDragStart",
+						event: i
+					}), le(Pe.current), I(a);
+				});
+			},
+			onMove(e) {
+				m({
+					type: P.DragMove,
+					coordinates: e
+				});
+			},
+			onEnd: s(P.DragEnd),
+			onCancel: s(P.DragCancel)
+		});
+		Pe.current = o;
+		function s(e) {
+			return async function() {
+				let { active: t, collisions: n, over: r, scrollAdjustedTranslate: i } = H.current, o = null;
+				if (t && i) {
+					let { cancelDrop: s } = L.current;
+					o = {
+						activatorEvent: a,
+						active: t,
+						collisions: n,
+						delta: i,
+						over: r
+					}, e === P.DragEnd && typeof s == "function" && await Promise.resolve(s(o)) && (e = P.DragCancel);
+				}
+				N.current = null, re(() => {
+					m({ type: e }), b(Ht.Uninitialized), Me(null), le(null), I(null), Pe.current = null;
+					let t = e === P.DragEnd ? "onDragEnd" : "onDragCancel";
+					if (o) {
+						let e = L.current[t];
+						e?.(o), _({
+							type: t,
+							event: o
+						});
+					}
+				});
+			};
+		}
+	}, [w]), Ie = at(c, E((e, t) => (n, r) => {
+		let i = n.nativeEvent, a = w.get(r);
+		if (N.current !== null || !a || i.dndKit || i.defaultPrevented) return;
+		let o = { active: a };
+		e(n, t.options, o) === !0 && (i.dndKit = { capturedBy: t.sensor }, N.current = r, Fe(n, t));
+	}, [w, Fe]));
+	xt(c), h(() => {
+		V && y === Ht.Initializing && b(Ht.Initialized);
+	}, [V, y]), O(() => {
+		let { onDragMove: e } = L.current, { active: t, activatorEvent: n, collisions: r, over: i } = H.current;
+		if (!t || !n) return;
+		let a = {
+			active: t,
+			activatorEvent: n,
+			collisions: r,
+			delta: {
+				x: J.x,
+				y: J.y
+			},
+			over: i
+		};
+		re(() => {
+			e?.(a), _({
+				type: "onDragMove",
+				event: a
+			});
+		});
+	}, [J.x, J.y]), O(() => {
+		let { active: e, activatorEvent: t, collisions: n, droppableContainers: r, scrollAdjustedTranslate: i } = H.current;
+		if (!e || N.current == null || !t || !i) return;
+		let { onDragOver: a } = L.current, o = r.get(je), 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
+		};
+		re(() => {
+			Me(s), a?.(c), _({
+				type: "onDragOver",
+				event: c
+			});
+		});
+	}, [je]), h(() => {
+		H.current = {
+			activatorEvent: F,
+			active: M,
+			activeNode: B,
+			collisionRect: Y,
+			collisions: X,
+			droppableRects: z,
+			draggableNodes: w,
+			draggingNode: Ce,
+			draggingNodeRect: W,
+			droppableContainers: D,
+			over: Z,
+			scrollableAncestors: G,
+			scrollAdjustedTranslate: J
+		}, ae.current = {
+			initial: W,
+			translated: Y
+		};
+	}, [
+		M,
+		B,
+		X,
+		Y,
+		w,
+		Ce,
+		W,
+		z,
+		D,
+		Z,
+		G,
+		J
+	]), tt({
+		...ve,
+		delta: T,
+		draggingRect: Y,
+		pointerCoordinates: q,
+		scrollableAncestors: G,
+		scrollableAncestorRects: De
+	});
+	let Le = k(() => ({
+		active: M,
+		activeNode: B,
+		activeNodeRect: V,
+		activatorEvent: F,
+		collisions: X,
+		containerNodeRect: xe,
+		dragOverlay: U,
+		draggableNodes: w,
+		droppableContainers: D,
+		droppableRects: z,
+		over: Z,
+		measureDroppableContainers: pe,
+		scrollableAncestors: G,
+		scrollableAncestorRects: De,
+		measuringConfiguration: R,
+		measuringScheduled: me,
+		windowRect: Ee
+	}), [
+		M,
+		B,
+		V,
+		F,
+		X,
+		xe,
+		U,
+		w,
+		D,
+		z,
+		Z,
+		pe,
+		G,
+		De,
+		R,
+		me,
+		Ee
+	]), Q = k(() => ({
+		activatorEvent: F,
+		activators: Ie,
+		active: M,
+		activeNodeRect: V,
+		ariaDescribedById: { draggable: ue },
+		dispatch: m,
+		draggableNodes: w,
+		over: Z,
+		measureDroppableContainers: pe
+	}), [
+		F,
+		Ie,
+		M,
+		V,
+		m,
+		ue,
+		w,
+		Z,
+		pe
+	]);
+	return C.createElement(ie.Provider, { value: v }, C.createElement(Nt.Provider, { value: Q }, C.createElement(Pt.Provider, { value: Le }, C.createElement(Vt.Provider, { value: Ne }, s)), C.createElement(Lt, { disabled: i?.restoreFocus === !1 })), C.createElement(se, {
+		...i,
+		hiddenTextDescribedById: ue
+	}));
+	function Re() {
+		let e = ce?.autoScrollEnabled === !1, t = typeof o == "object" ? o.enabled === !1 : o === !1, n = x && !e && !t;
+		return typeof o == "object" ? {
+			...o,
+			enabled: n
+		} : { enabled: n };
+	}
+}), Wt = /*#__PURE__*/ w(null), Gt = "button", Kt = "Draggable";
+function qt(e) {
+	let { id: t, data: n, disabled: r = !1, attributes: i } = e, a = ee(Kt), { activators: o, activatorEvent: s, active: c, activeNodeRect: l, ariaDescribedById: u, draggableNodes: d, over: f } = D(Nt), { role: p = Gt, roleDescription: m = "draggable", tabIndex: _ = 0 } = i ?? {}, y = c?.id === t, b = D(y ? Vt : Wt), [x, S] = v(), [C, w] = v(), T = St(o, t), E = g(n);
+	return h(() => (d.set(t, {
+		id: t,
+		key: a,
+		node: x,
+		activatorNode: C,
+		data: E
+	}), () => {
+		let e = d.get(t);
+		e && e.key === a && d.delete(t);
+	}), [d, t]), {
+		active: c,
+		activatorEvent: s,
+		activeNodeRect: l,
+		attributes: k(() => ({
+			role: p,
+			tabIndex: _,
+			"aria-disabled": r,
+			"aria-pressed": y && p === Gt ? !0 : void 0,
+			"aria-roledescription": m,
+			"aria-describedby": u.draggable
+		}), [
+			r,
+			p,
+			_,
+			y,
+			m,
+			u.draggable
+		]),
+		isDragging: y,
+		listeners: r ? void 0 : T,
+		node: x,
+		over: f,
+		setNodeRef: S,
+		setActivatorNodeRef: w,
+		transform: b
+	};
+}
+function Jt() {
+	return D(Pt);
+}
+var Yt = "Droppable", Xt = { timeout: 25 };
+function Zt(e) {
+	let { data: t, disabled: n = !1, id: r, resizeObserverConfig: i } = e, a = ee(Yt), { active: o, dispatch: s, over: c, measureDroppableContainers: l } = D(Nt), u = A({ disabled: n }), d = A(!1), f = A(null), p = A(null), { disabled: m, updateMeasurementsFor: h, timeout: _ } = {
+		...Xt,
+		...i
+	}, y = g(h ?? r), b = pt({
+		callback: E(() => {
+			if (!d.current) {
+				d.current = !0;
+				return;
+			}
+			p.current != null && clearTimeout(p.current), p.current = setTimeout(() => {
+				l(Array.isArray(y.current) ? y.current : [y.current]), p.current = null;
+			}, _);
+		}, [_]),
+		disabled: m || !o
+	}), [x, S] = v(E((e, t) => {
+		b && (t && (b.unobserve(t), d.current = !1), e && b.observe(e));
+	}, [b])), C = g(t);
+	return O(() => {
+		!b || !x.current || (b.disconnect(), d.current = !1, b.observe(x.current));
+	}, [x, b]), O(() => (s({
+		type: P.RegisterDroppable,
+		element: {
+			id: r,
+			key: a,
+			disabled: n,
+			node: x,
+			rect: f,
+			data: C
+		}
+	}), () => s({
+		type: P.UnregisterDroppable,
+		key: a,
+		id: r
+	})), [r]), O(() => {
+		n !== u.current.disabled && (s({
+			type: P.SetDroppableDisabled,
+			id: r,
+			key: a,
+			disabled: n
+		}), u.current.disabled = n);
+	}, [
+		r,
+		a,
+		n,
+		s
+	]), {
+		active: o,
+		rect: f,
+		isOver: c?.id === r,
+		node: x,
+		over: c,
+		setNodeRef: S
+	};
+}
+//#endregion
+export { $e as AutoScrollActivator, Ut as DndContext, $ as KeyboardCode, He as KeyboardSensor, st as MeasuringFrequency, ot as MeasuringStrategy, Xe as MouseSensor, qe as PointerSensor, Qe as TouchSensor, et as TraversalOrder, Rt as applyModifiers, pe as closestCenter, me as closestCorners, N as defaultAnnouncements, I as defaultCoordinates, Ve as defaultKeyboardCoordinateGetter, M as defaultScreenReaderInstructions, H as getClientRect, fe as getFirstCollision, we as getScrollableAncestors, he as rectIntersection, Jt as useDndContext, ae as useDndMonitor, qt as useDraggable, Zt as useDroppable, le as useSensor, F as useSensors };