@mailstep/design-system 0.8.26-beta.0 → 0.8.26-beta.2

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

@@ -0,0 +1,1730 @@
+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 fe(e, t) {
+	if (!e || e.length === 0) return null;
+	let [n] = e;
+	return t ? n[t] : n;
+}
+function R(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 z = (e) => {
+	let { collisionRect: t, droppableRects: n, droppableContainers: r } = e, i = R(t, t.left, t.top), a = [];
+	for (let e of r) {
+		let { id: t } = e, r = n.get(t);
+		if (r) {
+			let n = L(R(r), i);
+			a.push({
+				id: t,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return a.sort(ue);
+};
+function pe(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 me = (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 = pe(a, t);
+			n > 0 && i.push({
+				id: r,
+				data: {
+					droppableContainer: e,
+					value: n
+				}
+			});
+		}
+	}
+	return i.sort(de);
+};
+function he(e, t, n) {
+	return {
+		...e,
+		scaleX: t && n ? t.width / n.width : 1,
+		scaleY: t && n ? t.height / n.height : 1
+	};
+}
+function ge(e, t) {
+	return e && t ? {
+		x: e.left - t.left,
+		y: e.top - t.top
+	} : I;
+}
+function B(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 _e = /* @__PURE__ */ B(1);
+function ve(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 ye(e, t, n) {
+	let r = ve(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 be = { ignoreTransform: !1 };
+function V(e, t) {
+	t === void 0 && (t = be);
+	let n = e.getBoundingClientRect();
+	if (t.ignoreTransform) {
+		let { transform: t, transformOrigin: r } = a(e).getComputedStyle(e);
+		t && (n = ye(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 xe(e) {
+	return V(e, { ignoreTransform: !0 });
+}
+function H(e) {
+	let t = e.innerWidth, n = e.innerHeight;
+	return {
+		top: 0,
+		left: 0,
+		right: t,
+		bottom: n,
+		width: t,
+		height: n
+	};
+}
+function Se(e, t) {
+	return t === void 0 && (t = a(e).getComputedStyle(e)), t.position === "fixed";
+}
+function U(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 W(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 && U(i, c) && n.push(i), Se(i, c) ? n : r(i.parentNode);
+	}
+	return e ? r(e) : n;
+}
+function G(e) {
+	let [t] = W(e, 1);
+	return t ?? null;
+}
+function Ce(e) {
+	return !t || !e ? null : d(e) ? e : l(e) ? o(e) || e === i(e).scrollingElement ? window : s(e) ? e : null : null;
+}
+function we(e) {
+	return d(e) ? e.scrollX : e.scrollLeft;
+}
+function Te(e) {
+	return d(e) ? e.scrollY : e.scrollTop;
+}
+function K(e) {
+	return {
+		x: we(e),
+		y: Te(e)
+	};
+}
+var q;
+(function(e) {
+	e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(q ||= {});
+function Ee(e) {
+	return !t || !e ? !1 : e === document.scrollingElement;
+}
+function De(e) {
+	let t = {
+		x: 0,
+		y: 0
+	}, n = Ee(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 Oe = {
+	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 = Oe);
+	let { isTop: l, isBottom: u, isLeft: d, isRight: f } = De(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 Ae(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 J(t) {
+	return t.reduce((t, n) => e(t, K(n)), I);
+}
+function Y(e) {
+	return e.reduce((e, t) => e + we(t), 0);
+}
+function je(e) {
+	return e.reduce((e, t) => e + Te(t), 0);
+}
+function Me(e, t) {
+	if (t === void 0 && (t = V), !e) return;
+	let { top: n, left: r, bottom: i, right: a } = t(e);
+	G(e) && (i <= 0 || a <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+		block: "center",
+		inline: "center"
+	});
+}
+var X = [[
+	"x",
+	["left", "right"],
+	Y
+], [
+	"y",
+	["top", "bottom"],
+	je
+]], Ne = 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 = W(t), r = J(n);
+		this.rect = { ...e }, this.width = e.width, this.height = e.height;
+		for (let [e, t, i] of X) 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 });
+	}
+}, Pe = 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 Fe(e) {
+	let { EventTarget: t } = a(e);
+	return e instanceof t ? e : i(e);
+}
+function Ie(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 Z;
+(function(e) {
+	e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(Z ||= {});
+function Le(e) {
+	e.preventDefault();
+}
+function Re(e) {
+	e.stopPropagation();
+}
+var Q;
+(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";
+})(Q ||= {});
+var ze = {
+	start: [Q.Space, Q.Enter],
+	cancel: [Q.Esc],
+	end: [
+		Q.Space,
+		Q.Enter,
+		Q.Tab
+	]
+}, Be = (e, t) => {
+	let { currentCoordinates: n } = t;
+	switch (e.code) {
+		case Q.Right: return {
+			...n,
+			x: n.x + 25
+		};
+		case Q.Left: return {
+			...n,
+			x: n.x - 25
+		};
+		case Q.Down: return {
+			...n,
+			y: n.y + 25
+		};
+		case Q.Up: return {
+			...n,
+			y: n.y - 25
+		};
+	}
+}, Ve = 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 Pe(i(t)), this.windowListeners = new Pe(a(t)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+	}
+	attach() {
+		this.handleStart(), this.windowListeners.add(Z.Resize, this.handleCancel), this.windowListeners.add(Z.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(Z.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 = ze, coordinateGetter: o = Be, 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 } = De(e), p = Ae(e), m = {
+						x: Math.min(r === Q.Right ? p.right - p.width / 2 : p.right, Math.max(r === Q.Right ? p.left : p.left + p.width / 2, d.x)),
+						y: Math.min(r === Q.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(r === Q.Down ? p.top : p.top + p.height / 2, d.y))
+					}, h = r === Q.Right && !o || r === Q.Left && !c, g = r === Q.Down && !l || r === Q.Up && !a;
+					if (h && m.x !== d.x) {
+						let t = e.scrollLeft + n.x, a = r === Q.Right && t <= u.x || r === Q.Left && t >= f.x;
+						if (a && !n.y) {
+							e.scrollTo({
+								left: t,
+								behavior: s
+							});
+							return;
+						}
+						a ? i.x = e.scrollLeft - t : i.x = r === Q.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 === Q.Down && t <= u.y || r === Q.Up && t >= f.y;
+						if (a && !n.x) {
+							e.scrollTo({
+								top: t,
+								behavior: s
+							});
+							return;
+						}
+						a ? i.y = e.scrollTop - t : i.y = r === Q.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();
+	}
+};
+Ve.activators = [{
+	eventName: "onKeyDown",
+	handler: (e, t, n) => {
+		let { keyboardCodes: r = ze, 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 He(e) {
+	return !!(e && "distance" in e);
+}
+function Ue(e) {
+	return !!(e && "delay" in e);
+}
+var We = class {
+	constructor(e, t, n) {
+		n === void 0 && (n = Fe(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 Pe(this.document), this.listeners = new Pe(n), this.windowListeners = new Pe(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(Z.Resize, this.handleCancel), this.windowListeners.add(Z.DragStart, Le), this.windowListeners.add(Z.VisibilityChange, this.handleCancel), this.windowListeners.add(Z.ContextMenu, Le), this.documentListeners.add(Z.Keydown, this.handleKeydown), t) {
+			if (n != null && n({
+				event: this.props.event,
+				activeNode: this.props.activeNode,
+				options: this.props.options
+			})) return this.handleStart();
+			if (Ue(t)) {
+				this.timeoutId = setTimeout(this.handleStart, t.delay), this.handlePending(t);
+				return;
+			}
+			if (He(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(Z.Click, Re, { capture: !0 }), this.removeTextSelection(), this.documentListeners.add(Z.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 (He(o)) {
+				if (o.tolerance != null && Ie(c, o.tolerance)) return this.handleCancel();
+				if (Ie(c, o.distance)) return this.handleStart();
+			}
+			if (Ue(o) && Ie(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 === Q.Esc && this.handleCancel();
+	}
+	removeTextSelection() {
+		var e;
+		(e = this.document.getSelection()) == null || e.removeAllRanges();
+	}
+}, Ge = {
+	cancel: { name: "pointercancel" },
+	move: { name: "pointermove" },
+	end: { name: "pointerup" }
+}, Ke = class extends We {
+	constructor(e) {
+		let { event: t } = e, n = i(t.target);
+		super(e, Ge, n);
+	}
+};
+Ke.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 qe = {
+	move: { name: "mousemove" },
+	end: { name: "mouseup" }
+}, Je;
+(function(e) {
+	e[e.RightClick = 2] = "RightClick";
+})(Je ||= {});
+var Ye = class extends We {
+	constructor(e) {
+		super(e, qe, i(e.event.target));
+	}
+};
+Ye.activators = [{
+	eventName: "onMouseDown",
+	handler: (e, t) => {
+		let { nativeEvent: n } = e, { onActivation: r } = t;
+		return n.button === Je.RightClick ? !1 : (r?.({ event: n }), !0);
+	}
+}];
+var Xe = {
+	cancel: { name: "touchcancel" },
+	move: { name: "touchmove" },
+	end: { name: "touchend" }
+}, Ze = class extends We {
+	constructor(e) {
+		super(e, Xe);
+	}
+	static setup() {
+		return window.addEventListener(Xe.move.name, e, {
+			capture: !1,
+			passive: !1
+		}), function() {
+			window.removeEventListener(Xe.move.name, e);
+		};
+		function e() {}
+	}
+};
+Ze.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 Qe;
+(function(e) {
+	e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(Qe ||= {});
+var $e;
+(function(e) {
+	e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})($e ||= {});
+function et(e) {
+	let { acceleration: t, activator: n = Qe.Pointer, canScroll: r, draggingRect: i, enabled: a, interval: o = 5, order: s = $e.TreeOrder, pointerCoordinates: c, scrollableAncestors: l, scrollableAncestorRects: u, delta: d, threshold: f } = e, p = nt({
+		delta: d,
+		disabled: !a
+	}), [h, g] = m(), _ = A({
+		x: 0,
+		y: 0
+	}), v = A({
+		x: 0,
+		y: 0
+	}), y = k(() => {
+		switch (n) {
+			case Qe.Pointer: return c ? {
+				top: c.y,
+				bottom: c.y,
+				left: c.x,
+				right: c.x
+			} : null;
+			case Qe.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 === $e.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 = u[l.indexOf(e)];
+			if (!n) continue;
+			let { direction: i, speed: a } = ke(e, n, y, t, f);
+			for (let e of ["x", "y"]) p[e][i[e]] || (a[e] = 0, i[e] = 0);
+			if (a.x > 0 || a.y > 0) {
+				g(), ee.current = e, h(b, o), _.current = a, v.current = i;
+				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 tt = {
+	x: {
+		[q.Backward]: !1,
+		[q.Forward]: !1
+	},
+	y: {
+		[q.Backward]: !1,
+		[q.Forward]: !1
+	}
+};
+function nt(e) {
+	let { delta: t, disabled: n } = e, r = y(t);
+	return _((e) => {
+		if (n || !r || !e) return tt;
+		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 rt(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 it(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 at;
+(function(e) {
+	e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(at ||= {});
+var ot;
+(function(e) {
+	e.Optimized = "optimized";
+})(ot ||= {});
+var st = /* @__PURE__ */ new Map();
+function ct(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 st;
+		if (!t || t === st || 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 Ne(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 at.Always: return !1;
+			case at.BeforeDragging: return n;
+			default: return !n;
+		}
+	}
+}
+function lt(e, t) {
+	return _((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function ut(e, t) {
+	return lt(e, t);
+}
+function dt(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 ft(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 pt(e) {
+	return new Ne(V(e), e);
+}
+function mt(e, t, n) {
+	t === void 0 && (t = pt);
+	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 = dt({ 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 = ft({ callback: a });
+	return h(() => {
+		a(), e ? (s?.observe(e), o?.observe(document.body, {
+			childList: !0,
+			subtree: !0
+		})) : (s?.disconnect(), o?.disconnect());
+	}, [e]), r;
+}
+function ht(e) {
+	return ge(e, lt(e));
+}
+var gt = [];
+function _t(e) {
+	let t = A(e), n = _((n) => e ? n && n !== gt && e && t.current && e.parentNode === t.current.parentNode ? n : W(e) : gt, [e]);
+	return O(() => {
+		t.current = e;
+	}, [e]), n;
+}
+function vt(t) {
+	let [n, r] = j(null), i = A(t), a = E((e) => {
+		let t = Ce(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 = Ce(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) => {
+				Ce(e)?.removeEventListener("scroll", a);
+			});
+		}
+	}, [a, t]), k(() => t.length ? n ? Array.from(n.values()).reduce((t, n) => e(t, n), I) : J(t) : I, [t, n]);
+}
+function yt(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 bt(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 xt(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 St(e) {
+	return k(() => e ? H(e) : null, [e]);
+}
+var Ct = [];
+function wt(e, t) {
+	t === void 0 && (t = V);
+	let [n] = e, r = St(n ? a(n) : null), [i, o] = j(Ct);
+	function s() {
+		o(() => e.length ? e.map((e) => Ee(e) ? r : new Ne(t(e), e)) : Ct);
+	}
+	let c = ft({ callback: s });
+	return h(() => {
+		c?.disconnect(), s(), e.forEach((e) => c?.observe(e));
+	}, [e]), i;
+}
+function Tt(e) {
+	if (!e) return null;
+	if (e.children.length > 1) return e;
+	let t = e.children[0];
+	return s(t) ? t : e;
+}
+function Et(e) {
+	let { measure: t } = e, [n, r] = j(null), i = ft({ 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 = Tt(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 Dt = [{
+	sensor: Ke,
+	options: {}
+}, {
+	sensor: Ve,
+	options: {}
+}], Ot = { current: {} }, kt = {
+	draggable: { measure: xe },
+	droppable: {
+		measure: xe,
+		strategy: at.WhileDragging,
+		frequency: ot.Optimized
+	},
+	dragOverlay: { measure: V }
+}, At = 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;
+	}
+}, jt = {
+	activatorEvent: null,
+	active: null,
+	activeNode: null,
+	activeNodeRect: null,
+	collisions: null,
+	containerNodeRect: null,
+	draggableNodes: /* @__PURE__ */ new Map(),
+	droppableRects: /* @__PURE__ */ new Map(),
+	droppableContainers: /* @__PURE__ */ new At(),
+	over: null,
+	dragOverlay: {
+		nodeRef: { current: null },
+		rect: null,
+		setRef: ce
+	},
+	scrollableAncestors: [],
+	scrollableAncestorRects: [],
+	measuringConfiguration: kt,
+	measureDroppableContainers: ce,
+	windowRect: null,
+	measuringScheduled: !1
+}, Mt = /* @__PURE__ */ w({
+	activatorEvent: null,
+	activators: [],
+	active: null,
+	activeNodeRect: null,
+	ariaDescribedById: { draggable: "" },
+	dispatch: ce,
+	draggableNodes: /* @__PURE__ */ new Map(),
+	over: null,
+	measureDroppableContainers: ce
+}), Nt = /* @__PURE__ */ w(jt);
+function Pt() {
+	return {
+		draggable: {
+			active: null,
+			initialCoordinates: {
+				x: 0,
+				y: 0
+			},
+			nodes: /* @__PURE__ */ new Map(),
+			translate: {
+				x: 0,
+				y: 0
+			}
+		},
+		droppable: { containers: new At() }
+	};
+}
+function Ft(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 At(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 At(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 At(e.droppable.containers);
+			return a.delete(n), {
+				...e,
+				droppable: {
+					...e.droppable,
+					containers: a
+				}
+			};
+		}
+		default: return e;
+	}
+}
+function It(e) {
+	let { disabled: t } = e, { active: r, activatorEvent: i, draggableNodes: a } = D(Mt), 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 Lt(e, t) {
+	let { transform: n, ...r } = t;
+	return e != null && e.length ? e.reduce((e, t) => t({
+		transform: e,
+		...r
+	}), n) : n;
+}
+function Rt(e) {
+	return k(() => ({
+		draggable: {
+			...kt.draggable,
+			...e?.draggable
+		},
+		droppable: {
+			...kt.droppable,
+			...e?.droppable
+		},
+		dragOverlay: {
+			...kt.dragOverlay,
+			...e?.dragOverlay
+		}
+	}), [
+		e?.draggable,
+		e?.droppable,
+		e?.dragOverlay
+	]);
+}
+function zt(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 = ge(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 = G(e);
+			t && t.scrollBy({
+				top: i.y,
+				left: i.x
+			});
+		}
+	}, [
+		t,
+		o,
+		s,
+		r,
+		n
+	]);
+}
+var Bt = /* @__PURE__ */ w({
+	...I,
+	scaleX: 1,
+	scaleY: 1
+}), $;
+(function(e) {
+	e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})($ ||= {});
+var Vt = /* @__PURE__ */ T(function(t) {
+	let { id: n, accessibility: i, autoScroll: o = !0, children: s, sensors: c = Dt, collisionDetection: l = me, measuring: u, modifiers: d, ...f } = t, [p, m] = te(Ft, void 0, Pt), [_, v] = oe(), [y, b] = j($.Uninitialized), x = y === $.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 ?? Ot,
+		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 = Rt(u), { droppableRects: z, measureDroppableContainers: pe, measuringScheduled: ge } = ct(de, {
+		dragging: x,
+		dependencies: [T.x, T.y],
+		config: R.droppable
+	}), B = rt(w, S), ve = k(() => F ? r(F) : null, [F]), ye = Q(), be = ut(B, R.draggable.measure);
+	zt({
+		activeNode: S == null ? null : w.get(S),
+		config: ye.layoutShiftCompensation,
+		initialRect: be,
+		measure: R.draggable.measure
+	});
+	let V = mt(B, R.draggable.measure, be), xe = mt(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 = Et({ measure: R.dragOverlay.measure }), W = U.nodeRef.current ?? B, G = x ? U.rect ?? V : null, Ce = !!(U.nodeRef.current && U.rect), we = ht(Ce ? null : V), Te = St(W ? a(W) : null), K = _t(x ? Se ?? B : null), q = wt(K), Ee = Lt(d, {
+		transform: {
+			x: T.x - we.x,
+			y: T.y - we.y,
+			scaleX: 1,
+			scaleY: 1
+		},
+		activatorEvent: F,
+		active: M,
+		activeNodeRect: V,
+		containerNodeRect: xe,
+		draggingNodeRect: G,
+		over: H.current.over,
+		overlayNodeRect: U.rect,
+		scrollableAncestors: K,
+		scrollableAncestorRects: q,
+		windowRect: Te
+	}), De = ve ? e(ve, T) : null, Oe = vt(K), ke = yt(Oe), Ae = yt(Oe, [V]), J = e(Ee, ke), Y = G ? _e(G, Ee) : null, je = M && Y ? l({
+		active: M,
+		collisionRect: Y,
+		droppableRects: z,
+		droppableContainers: de,
+		pointerCoordinates: De
+	}) : null, Me = fe(je, "id"), [X, Ne] = j(null), Pe = he(Ce ? Ee : e(Ee, Ae), X?.rect ?? null, V), Fe = A(null), Ie = 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;
+		Fe.current = 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($.Initializing), m({
+						type: P.DragStart,
+						initialCoordinates: e,
+						active: t
+					}), _({
+						type: "onDragStart",
+						event: i
+					}), le(Fe.current), I(a);
+				});
+			},
+			onMove(e) {
+				m({
+					type: P.DragMove,
+					coordinates: e
+				});
+			},
+			onEnd: o(P.DragEnd),
+			onCancel: o(P.DragCancel)
+		});
+		function o(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($.Uninitialized), Ne(null), le(null), I(null), Fe.current = null;
+					let t = e === P.DragEnd ? "onDragEnd" : "onDragCancel";
+					if (o) {
+						let e = L.current[t];
+						e?.(o), _({
+							type: t,
+							event: o
+						});
+					}
+				});
+			};
+		}
+	}, [w]), Z = it(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, Ie(n, t));
+	}, [w, Ie]));
+	bt(c), h(() => {
+		V && y === $.Initializing && b($.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(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
+		};
+		re(() => {
+			Ne(s), a?.(c), _({
+				type: "onDragOver",
+				event: c
+			});
+		});
+	}, [Me]), h(() => {
+		H.current = {
+			activatorEvent: F,
+			active: M,
+			activeNode: B,
+			collisionRect: Y,
+			collisions: je,
+			droppableRects: z,
+			draggableNodes: w,
+			draggingNode: W,
+			draggingNodeRect: G,
+			droppableContainers: D,
+			over: X,
+			scrollableAncestors: K,
+			scrollAdjustedTranslate: J
+		}, ae.current = {
+			initial: G,
+			translated: Y
+		};
+	}, [
+		M,
+		B,
+		je,
+		Y,
+		w,
+		W,
+		G,
+		z,
+		D,
+		X,
+		K,
+		J
+	]), et({
+		...ye,
+		delta: T,
+		draggingRect: Y,
+		pointerCoordinates: De,
+		scrollableAncestors: K,
+		scrollableAncestorRects: q
+	});
+	let Le = k(() => ({
+		active: M,
+		activeNode: B,
+		activeNodeRect: V,
+		activatorEvent: F,
+		collisions: je,
+		containerNodeRect: xe,
+		dragOverlay: U,
+		draggableNodes: w,
+		droppableContainers: D,
+		droppableRects: z,
+		over: X,
+		measureDroppableContainers: pe,
+		scrollableAncestors: K,
+		scrollableAncestorRects: q,
+		measuringConfiguration: R,
+		measuringScheduled: ge,
+		windowRect: Te
+	}), [
+		M,
+		B,
+		V,
+		F,
+		je,
+		xe,
+		U,
+		w,
+		D,
+		z,
+		X,
+		pe,
+		K,
+		q,
+		R,
+		ge,
+		Te
+	]), Re = k(() => ({
+		activatorEvent: F,
+		activators: Z,
+		active: M,
+		activeNodeRect: V,
+		ariaDescribedById: { draggable: ue },
+		dispatch: m,
+		draggableNodes: w,
+		over: X,
+		measureDroppableContainers: pe
+	}), [
+		F,
+		Z,
+		M,
+		V,
+		m,
+		ue,
+		w,
+		X,
+		pe
+	]);
+	return C.createElement(ie.Provider, { value: v }, C.createElement(Mt.Provider, { value: Re }, C.createElement(Nt.Provider, { value: Le }, C.createElement(Bt.Provider, { value: Pe }, s)), C.createElement(It, { disabled: i?.restoreFocus === !1 })), C.createElement(se, {
+		...i,
+		hiddenTextDescribedById: ue
+	}));
+	function Q() {
+		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 };
+	}
+}), Ht = /* @__PURE__ */ w(null), Ut = "button", Wt = "Draggable";
+function Gt(e) {
+	let { id: t, data: n, disabled: r = !1, attributes: i } = e, a = ee(Wt), { activators: o, activatorEvent: s, active: c, activeNodeRect: l, ariaDescribedById: u, draggableNodes: d, over: f } = D(Mt), { role: p = Ut, roleDescription: m = "draggable", tabIndex: _ = 0 } = i ?? {}, y = c?.id === t, b = D(y ? Bt : Ht), [x, S] = v(), [C, w] = v(), T = xt(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 === Ut ? !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 Kt() {
+	return D(Nt);
+}
+var qt = "Droppable", Jt = { timeout: 25 };
+function Yt(e) {
+	let { data: t, disabled: n = !1, id: r, resizeObserverConfig: i } = e, a = ee(qt), { active: o, dispatch: s, over: c, measureDroppableContainers: l } = D(Mt), u = A({ disabled: n }), d = A(!1), f = A(null), p = A(null), { disabled: m, updateMeasurementsFor: h, timeout: _ } = {
+		...Jt,
+		...i
+	}, y = g(h ?? r), b = ft({
+		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 { Vt as DndContext, Q as KeyboardCode, Ke as PointerSensor, z as closestCenter, V as getClientRect, Kt as useDndContext, Gt as useDraggable, Yt as useDroppable, le as useSensor, F as useSensors };