@pie-lib/rubric 2.0.3-next.3 → 2.0.4-next.0

package/dist/node_modules/.bun/@hello-pangea_dnd@18.0.1_d0d44917b9a63a72/node_modules/@hello-pangea/dnd/dist/dnd.esm.js

@@ -0,0 +1,4451 @@
+import { applyMiddleware as e, bindActionCreators as t, compose as n, createStore as r } from "../../../../../redux@5.0.1/node_modules/redux/dist/redux.js";
+import { Provider_default as i, connect as a } from "../../../../../react-redux@9.3.0_9e2203c65d1d5fa1/node_modules/react-redux/dist/react-redux.js";
+import { calculateBox as o, createBox as s, expand as c, getBox as l, getRect as u, offset as d, withScroll as f } from "../../../../../css-box-model@1.2.1/node_modules/css-box-model/dist/css-box-model.esm.js";
+import p from "../../../../../raf-schd@4.0.3/node_modules/raf-schd/dist/raf-schd.esm.js";
+import { _extends as m } from "../../../../../@babel_runtime@7.29.7/node_modules/@babel/runtime/helpers/esm/extends.js";
+import h, { useContext as g, useEffect as _, useLayoutEffect as v, useRef as y, useState as b } from "react";
+import x, { flushSync as S } from "react-dom";
+//#region ../../../node_modules/.bun/@hello-pangea+dnd@18.0.1+d0d44917b9a63a72/node_modules/@hello-pangea/dnd/dist/dnd.esm.js
+var C = process.env.NODE_ENV === "production", w = /[ \t]{2,}/g, T = /^[ \t]*/gm, E = (e) => e.replace(w, " ").replace(T, "").trim(), ee = (e) => E(`
+  %c@hello-pangea/dnd
+
+  %c${E(e)}
+
+  %c👷‍ This is a development only message. It will be removed in production builds.
+`), te = (e) => [
+	ee(e),
+	"color: #00C584; font-size: 1.2em; font-weight: bold;",
+	"line-height: 1.5",
+	"color: #723874;"
+], ne = "__@hello-pangea/dnd-disable-dev-warnings";
+function re(e, t) {
+	C || typeof window < "u" && window[ne] || console[e](...te(t));
+}
+var D = re.bind(null, "warn"), ie = re.bind(null, "error");
+function O() {}
+function ae(e, t) {
+	return {
+		...e,
+		...t
+	};
+}
+function k(e, t, n) {
+	let r = t.map((t) => {
+		let r = ae(n, t.options);
+		return e.addEventListener(t.eventName, t.fn, r), function() {
+			e.removeEventListener(t.eventName, t.fn, r);
+		};
+	});
+	return function() {
+		r.forEach((e) => {
+			e();
+		});
+	};
+}
+var oe = process.env.NODE_ENV === "production", se = "Invariant failed", ce = class extends Error {};
+ce.prototype.toString = function() {
+	return this.message;
+};
+function A(e, t) {
+	throw oe ? new ce(se) : new ce(`${se}: ${t || ""}`);
+}
+var le = class extends h.Component {
+	constructor(...e) {
+		super(...e), this.callbacks = null, this.unbind = O, this.onWindowError = (e) => {
+			let t = this.getCallbacks();
+			t.isDragging() && (t.tryAbort(), process.env.NODE_ENV !== "production" && D("\n        An error was caught by our window 'error' event listener while a drag was occurring.\n        The active drag has been aborted.\n      "));
+			let n = e.error;
+			n instanceof ce && (e.preventDefault(), process.env.NODE_ENV !== "production" && ie(n.message));
+		}, this.getCallbacks = () => {
+			if (!this.callbacks) throw Error("Unable to find AppCallbacks in <ErrorBoundary/>");
+			return this.callbacks;
+		}, this.setCallbacks = (e) => {
+			this.callbacks = e;
+		};
+	}
+	componentDidMount() {
+		this.unbind = k(window, [{
+			eventName: "error",
+			fn: this.onWindowError
+		}]);
+	}
+	componentDidCatch(e) {
+		if (e instanceof ce) {
+			process.env.NODE_ENV !== "production" && ie(e.message), this.setState({});
+			return;
+		}
+		throw e;
+	}
+	componentWillUnmount() {
+		this.unbind();
+	}
+	render() {
+		return this.props.children(this.setCallbacks);
+	}
+}, ue = "\n  Press space bar to start a drag.\n  When dragging you can use the arrow keys to move the item around and escape to cancel.\n  Some screen readers may require you to be in focus mode or to use your pass through key\n", de = (e) => e + 1, fe = (e) => `
+  You have lifted an item in position ${de(e.source.index)}
+`, pe = (e, t) => {
+	let n = e.droppableId === t.droppableId, r = de(e.index), i = de(t.index);
+	return n ? `
+      You have moved the item from position ${r}
+      to position ${i}
+    ` : `
+    You have moved the item from position ${r}
+    in list ${e.droppableId}
+    to list ${t.droppableId}
+    in position ${i}
+  `;
+}, me = (e, t, n) => t.droppableId === n.droppableId ? `
+      The item ${e}
+      has been combined with ${n.draggableId}` : `
+      The item ${e}
+      in list ${t.droppableId}
+      has been combined with ${n.draggableId}
+      in list ${n.droppableId}
+    `, he = (e) => {
+	let t = e.destination;
+	if (t) return pe(e.source, t);
+	let n = e.combine;
+	return n ? me(e.draggableId, e.source, n) : "You are over an area that cannot be dropped on";
+}, ge = (e) => `
+  The item has returned to its starting position
+  of ${de(e.index)}
+`, _e = {
+	dragHandleUsageInstructions: ue,
+	onDragStart: fe,
+	onDragUpdate: he,
+	onDragEnd: (e) => {
+		if (e.reason === "CANCEL") return `
+      Movement cancelled.
+      ${ge(e.source)}
+    `;
+		let t = e.destination, n = e.combine;
+		return t ? `
+      You have dropped the item.
+      ${pe(e.source, t)}
+    ` : n ? `
+      You have dropped the item.
+      ${me(e.draggableId, e.source, n)}
+    ` : `
+    The item has been dropped while not over a drop area.
+    ${ge(e.source)}
+  `;
+	}
+};
+function ve(e, t) {
+	return !!(e === t || Number.isNaN(e) && Number.isNaN(t));
+}
+function ye(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (!ve(e[n], t[n])) return !1;
+	return !0;
+}
+function j(e, t) {
+	let n = b(() => ({
+		inputs: t,
+		result: e()
+	}))[0], r = y(!0), i = y(n), a = r.current || t && i.current.inputs && ye(t, i.current.inputs) ? i.current : {
+		inputs: t,
+		result: e()
+	};
+	return _(() => {
+		r.current = !1, i.current = a;
+	}, [a]), a.result;
+}
+function M(e, t) {
+	return j(() => e, t);
+}
+var N = {
+	x: 0,
+	y: 0
+}, P = (e, t) => ({
+	x: e.x + t.x,
+	y: e.y + t.y
+}), F = (e, t) => ({
+	x: e.x - t.x,
+	y: e.y - t.y
+}), I = (e, t) => e.x === t.x && e.y === t.y, L = (e) => ({
+	x: e.x === 0 ? 0 : -e.x,
+	y: e.y === 0 ? 0 : -e.y
+}), R = (e, t, n = 0) => e === "x" ? {
+	x: t,
+	y: n
+} : {
+	x: n,
+	y: t
+}, be = (e, t) => Math.sqrt((t.x - e.x) ** 2 + (t.y - e.y) ** 2), xe = (e, t) => Math.min(...t.map((t) => be(e, t))), Se = (e) => (t) => ({
+	x: e(t.x),
+	y: e(t.y)
+}), Ce = (e, t) => {
+	let n = u({
+		top: Math.max(t.top, e.top),
+		right: Math.min(t.right, e.right),
+		bottom: Math.min(t.bottom, e.bottom),
+		left: Math.max(t.left, e.left)
+	});
+	return n.width <= 0 || n.height <= 0 ? null : n;
+}, we = (e, t) => ({
+	top: e.top + t.y,
+	left: e.left + t.x,
+	bottom: e.bottom + t.y,
+	right: e.right + t.x
+}), Te = (e) => [
+	{
+		x: e.left,
+		y: e.top
+	},
+	{
+		x: e.right,
+		y: e.top
+	},
+	{
+		x: e.left,
+		y: e.bottom
+	},
+	{
+		x: e.right,
+		y: e.bottom
+	}
+], Ee = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+}, De = (e, t) => t ? we(e, t.scroll.diff.displacement) : e, Oe = (e, t, n) => n && n.increasedBy ? {
+	...e,
+	[t.end]: e[t.end] + n.increasedBy[t.line]
+} : e, ke = (e, t) => t && t.shouldClipSubject ? Ce(t.pageMarginBox, e) : u(e), z = ({ page: e, withPlaceholder: t, axis: n, frame: r }) => ({
+	page: e,
+	withPlaceholder: t,
+	active: ke(Oe(De(e.marginBox, r), n, t), r)
+}), Ae = (e, t) => {
+	!e.frame && (process.env.NODE_ENV, A());
+	let n = e.frame, r = F(t, n.scroll.initial), i = L(r), a = {
+		...n,
+		scroll: {
+			initial: n.scroll.initial,
+			current: t,
+			diff: {
+				value: r,
+				displacement: i
+			},
+			max: n.scroll.max
+		}
+	}, o = z({
+		page: e.subject.page,
+		withPlaceholder: e.subject.withPlaceholder,
+		axis: e.axis,
+		frame: a
+	});
+	return {
+		...e,
+		frame: a,
+		subject: o
+	};
+};
+function B(e, t = ye) {
+	let n = null;
+	function r(...r) {
+		if (n && n.lastThis === this && t(r, n.lastArgs)) return n.lastResult;
+		let i = e.apply(this, r);
+		return n = {
+			lastResult: i,
+			lastArgs: r,
+			lastThis: this
+		}, i;
+	}
+	return r.clear = function() {
+		n = null;
+	}, r;
+}
+var je = B((e) => e.reduce((e, t) => (e[t.descriptor.id] = t, e), {})), Me = B((e) => e.reduce((e, t) => (e[t.descriptor.id] = t, e), {})), Ne = B((e) => Object.values(e)), Pe = B((e) => Object.values(e)), V = B((e, t) => Pe(t).filter((t) => e === t.descriptor.droppableId).sort((e, t) => e.descriptor.index - t.descriptor.index));
+function Fe(e) {
+	return e.at && e.at.type === "REORDER" ? e.at.destination : null;
+}
+function Ie(e) {
+	return e.at && e.at.type === "COMBINE" ? e.at.combine : null;
+}
+var Le = B((e, t) => t.filter((t) => t.descriptor.id !== e.descriptor.id)), Re = ({ isMovingForward: e, draggable: t, destination: n, insideDestination: r, previousImpact: i }) => {
+	if (!n.isCombineEnabled || !Fe(i)) return null;
+	function a(e) {
+		let t = {
+			type: "COMBINE",
+			combine: {
+				draggableId: e,
+				droppableId: n.descriptor.id
+			}
+		};
+		return {
+			...i,
+			at: t
+		};
+	}
+	let o = i.displaced.all, s = o.length ? o[0] : null;
+	if (e) return s ? a(s) : null;
+	let c = Le(t, r);
+	if (!s) {
+		if (!c.length) return null;
+		let e = c[c.length - 1];
+		return a(e.descriptor.id);
+	}
+	let l = c.findIndex((e) => e.descriptor.id === s);
+	l === -1 && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find displaced item in set"));
+	let u = l - 1;
+	if (u < 0) return null;
+	let d = c[u];
+	return a(d.descriptor.id);
+}, H = (e, t) => e.descriptor.droppableId === t.descriptor.id, ze = {
+	point: N,
+	value: 0
+}, U = {
+	invisible: {},
+	visible: {},
+	all: []
+}, Be = {
+	displaced: U,
+	displacedBy: ze,
+	at: null
+}, W = (e, t) => (n) => e <= n && n <= t, Ve = (e) => {
+	let t = W(e.top, e.bottom), n = W(e.left, e.right);
+	return (r) => {
+		if (t(r.top) && t(r.bottom) && n(r.left) && n(r.right)) return !0;
+		let i = t(r.top) || t(r.bottom), a = n(r.left) || n(r.right);
+		if (i && a) return !0;
+		let o = r.top < e.top && r.bottom > e.bottom, s = r.left < e.left && r.right > e.right;
+		return o && s ? !0 : o && a || s && i;
+	};
+}, He = (e) => {
+	let t = W(e.top, e.bottom), n = W(e.left, e.right);
+	return (e) => t(e.top) && t(e.bottom) && n(e.left) && n(e.right);
+}, Ue = {
+	direction: "vertical",
+	line: "y",
+	crossAxisLine: "x",
+	start: "top",
+	end: "bottom",
+	size: "height",
+	crossAxisStart: "left",
+	crossAxisEnd: "right",
+	crossAxisSize: "width"
+}, We = {
+	direction: "horizontal",
+	line: "x",
+	crossAxisLine: "y",
+	start: "left",
+	end: "right",
+	size: "width",
+	crossAxisStart: "top",
+	crossAxisEnd: "bottom",
+	crossAxisSize: "height"
+}, Ge = (e) => (t) => {
+	let n = W(t.top, t.bottom), r = W(t.left, t.right);
+	return (t) => e === Ue ? n(t.top) && n(t.bottom) : r(t.left) && r(t.right);
+}, Ke = (e, t) => we(e, t.frame ? t.frame.scroll.diff.displacement : N), qe = (e, t, n) => t.subject.active ? n(t.subject.active)(e) : !1, Je = (e, t, n) => n(t)(e), Ye = ({ target: e, destination: t, viewport: n, withDroppableDisplacement: r, isVisibleThroughFrameFn: i }) => {
+	let a = r ? Ke(e, t) : e;
+	return qe(a, t, i) && Je(a, n, i);
+}, Xe = (e) => Ye({
+	...e,
+	isVisibleThroughFrameFn: Ve
+}), Ze = (e) => Ye({
+	...e,
+	isVisibleThroughFrameFn: He
+}), Qe = (e) => Ye({
+	...e,
+	isVisibleThroughFrameFn: Ge(e.destination.axis)
+}), $e = (e, t, n) => {
+	if (typeof n == "boolean") return n;
+	if (!t) return !0;
+	let { invisible: r, visible: i } = t;
+	if (r[e]) return !1;
+	let a = i[e];
+	return a ? a.shouldAnimate : !0;
+};
+function et(e, t) {
+	let n = e.page.marginBox;
+	return u(c(n, {
+		top: t.point.y,
+		right: 0,
+		bottom: 0,
+		left: t.point.x
+	}));
+}
+function tt({ afterDragging: e, destination: t, displacedBy: n, viewport: r, forceShouldAnimate: i, last: a }) {
+	return e.reduce(function(e, o) {
+		let s = et(o, n), c = o.descriptor.id;
+		if (e.all.push(c), !Xe({
+			target: s,
+			destination: t,
+			viewport: r,
+			withDroppableDisplacement: !0
+		})) return e.invisible[o.descriptor.id] = !0, e;
+		let l = {
+			draggableId: c,
+			shouldAnimate: $e(c, a, i)
+		};
+		return e.visible[c] = l, e;
+	}, {
+		all: [],
+		visible: {},
+		invisible: {}
+	});
+}
+function nt(e, t) {
+	if (!e.length) return 0;
+	let n = e[e.length - 1].descriptor.index;
+	return t.inHomeList ? n : n + 1;
+}
+function rt({ insideDestination: e, inHomeList: t, displacedBy: n, destination: r }) {
+	let i = nt(e, { inHomeList: t });
+	return {
+		displaced: U,
+		displacedBy: n,
+		at: {
+			type: "REORDER",
+			destination: {
+				droppableId: r.descriptor.id,
+				index: i
+			}
+		}
+	};
+}
+function it({ draggable: e, insideDestination: t, destination: n, viewport: r, displacedBy: i, last: a, index: o, forceShouldAnimate: s }) {
+	let c = H(e, n);
+	if (o == null) return rt({
+		insideDestination: t,
+		inHomeList: c,
+		displacedBy: i,
+		destination: n
+	});
+	let l = t.find((e) => e.descriptor.index === o);
+	if (!l) return rt({
+		insideDestination: t,
+		inHomeList: c,
+		displacedBy: i,
+		destination: n
+	});
+	let u = Le(e, t), d = t.indexOf(l);
+	return {
+		displaced: tt({
+			afterDragging: u.slice(d),
+			destination: n,
+			displacedBy: i,
+			last: a,
+			viewport: r.frame,
+			forceShouldAnimate: s
+		}),
+		displacedBy: i,
+		at: {
+			type: "REORDER",
+			destination: {
+				droppableId: n.descriptor.id,
+				index: o
+			}
+		}
+	};
+}
+function G(e, t) {
+	return !!t.effected[e];
+}
+var at = ({ isMovingForward: e, destination: t, draggables: n, combine: r, afterCritical: i }) => {
+	if (!t.isCombineEnabled) return null;
+	let a = r.draggableId, o = n[a].descriptor.index;
+	return G(a, i) ? e ? o : o - 1 : e ? o + 1 : o;
+}, ot = ({ isMovingForward: e, isInHomeList: t, insideDestination: n, location: r }) => {
+	if (!n.length) return null;
+	let i = r.index, a = e ? i + 1 : i - 1, o = n[0].descriptor.index, s = n[n.length - 1].descriptor.index, c = t ? s : s + 1;
+	return a < o || a > c ? null : a;
+}, st = ({ isMovingForward: e, isInHomeList: t, draggable: n, draggables: r, destination: i, insideDestination: a, previousImpact: o, viewport: s, afterCritical: c }) => {
+	let l = o.at;
+	if (!l && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot move in direction without previous impact location")), l.type === "REORDER") {
+		let r = ot({
+			isMovingForward: e,
+			isInHomeList: t,
+			location: l.destination,
+			insideDestination: a
+		});
+		return r == null ? null : it({
+			draggable: n,
+			insideDestination: a,
+			destination: i,
+			viewport: s,
+			last: o.displaced,
+			displacedBy: o.displacedBy,
+			index: r
+		});
+	}
+	let u = at({
+		isMovingForward: e,
+		destination: i,
+		displaced: o.displaced,
+		draggables: r,
+		combine: l.combine,
+		afterCritical: c
+	});
+	return u == null ? null : it({
+		draggable: n,
+		insideDestination: a,
+		destination: i,
+		viewport: s,
+		last: o.displaced,
+		displacedBy: o.displacedBy,
+		index: u
+	});
+}, ct = ({ displaced: e, afterCritical: t, combineWith: n, displacedBy: r }) => {
+	let i = !!(e.visible[n] || e.invisible[n]);
+	return G(n, t) ? i ? N : L(r.point) : i ? r.point : N;
+}, lt = ({ afterCritical: e, impact: t, draggables: n }) => {
+	let r = Ie(t);
+	!r && (process.env.NODE_ENV, A());
+	let i = r.draggableId, a = n[i].page.borderBox.center;
+	return P(a, ct({
+		displaced: t.displaced,
+		afterCritical: e,
+		combineWith: i,
+		displacedBy: t.displacedBy
+	}));
+}, ut = (e, t) => t.margin[e.start] + t.borderBox[e.size] / 2, dt = (e, t) => t.margin[e.end] + t.borderBox[e.size] / 2, ft = (e, t, n) => t[e.crossAxisStart] + n.margin[e.crossAxisStart] + n.borderBox[e.crossAxisSize] / 2, pt = ({ axis: e, moveRelativeTo: t, isMoving: n }) => R(e.line, t.marginBox[e.end] + ut(e, n), ft(e, t.marginBox, n)), mt = ({ axis: e, moveRelativeTo: t, isMoving: n }) => R(e.line, t.marginBox[e.start] - dt(e, n), ft(e, t.marginBox, n)), ht = ({ axis: e, moveInto: t, isMoving: n }) => R(e.line, t.contentBox[e.start] + ut(e, n), ft(e, t.contentBox, n)), gt = ({ impact: e, draggable: t, draggables: n, droppable: r, afterCritical: i }) => {
+	let a = V(r.descriptor.id, n), o = t.page, s = r.axis;
+	if (!a.length) return ht({
+		axis: s,
+		moveInto: r.page,
+		isMoving: o
+	});
+	let { displaced: c, displacedBy: l } = e, u = c.all[0];
+	if (u) {
+		let e = n[u];
+		return G(u, i) ? mt({
+			axis: s,
+			moveRelativeTo: e.page,
+			isMoving: o
+		}) : mt({
+			axis: s,
+			moveRelativeTo: d(e.page, l.point),
+			isMoving: o
+		});
+	}
+	let f = a[a.length - 1];
+	return f.descriptor.id === t.descriptor.id ? o.borderBox.center : G(f.descriptor.id, i) ? pt({
+		axis: s,
+		moveRelativeTo: d(f.page, L(i.displacedBy.point)),
+		isMoving: o
+	}) : pt({
+		axis: s,
+		moveRelativeTo: f.page,
+		isMoving: o
+	});
+}, _t = (e, t) => {
+	let n = e.frame;
+	return n ? P(t, n.scroll.diff.displacement) : t;
+}, vt = ({ impact: e, draggable: t, droppable: n, draggables: r, afterCritical: i }) => {
+	let a = t.page.borderBox.center, o = e.at;
+	return !n || !o ? a : o.type === "REORDER" ? gt({
+		impact: e,
+		draggable: t,
+		draggables: r,
+		droppable: n,
+		afterCritical: i
+	}) : lt({
+		impact: e,
+		draggables: r,
+		afterCritical: i
+	});
+}, yt = (e) => {
+	let t = vt(e), n = e.droppable;
+	return n ? _t(n, t) : t;
+}, bt = (e, t) => {
+	let n = F(t, e.scroll.initial), r = L(n);
+	return {
+		frame: u({
+			top: t.y,
+			bottom: t.y + e.frame.height,
+			left: t.x,
+			right: t.x + e.frame.width
+		}),
+		scroll: {
+			initial: e.scroll.initial,
+			max: e.scroll.max,
+			current: t,
+			diff: {
+				value: n,
+				displacement: r
+			}
+		}
+	};
+};
+function xt(e, t) {
+	return e.map((e) => t[e]);
+}
+function St(e, t) {
+	for (let n = 0; n < t.length; n++) {
+		let r = t[n].visible[e];
+		if (r) return r;
+	}
+	return null;
+}
+var Ct = ({ impact: e, viewport: t, destination: n, draggables: r, maxScrollChange: i }) => {
+	let a = bt(t, P(t.scroll.current, i)), o = n.frame ? Ae(n, P(n.frame.scroll.current, i)) : n, s = e.displaced, c = tt({
+		afterDragging: xt(s.all, r),
+		destination: n,
+		displacedBy: e.displacedBy,
+		viewport: a.frame,
+		last: s,
+		forceShouldAnimate: !1
+	}), l = tt({
+		afterDragging: xt(s.all, r),
+		destination: o,
+		displacedBy: e.displacedBy,
+		viewport: t.frame,
+		last: s,
+		forceShouldAnimate: !1
+	}), u = {}, d = {}, f = [
+		s,
+		c,
+		l
+	];
+	return s.all.forEach((e) => {
+		let t = St(e, f);
+		if (t) {
+			d[e] = t;
+			return;
+		}
+		u[e] = !0;
+	}), {
+		...e,
+		displaced: {
+			all: s.all,
+			invisible: u,
+			visible: d
+		}
+	};
+}, wt = (e, t) => P(e.scroll.diff.displacement, t), Tt = ({ pageBorderBoxCenter: e, draggable: t, viewport: n }) => {
+	let r = F(wt(n, e), t.page.borderBox.center);
+	return P(t.client.borderBox.center, r);
+}, Et = ({ draggable: e, destination: t, newPageBorderBoxCenter: n, viewport: r, withDroppableDisplacement: i, onlyOnMainAxis: a = !1 }) => {
+	let o = F(n, e.page.borderBox.center), s = {
+		target: we(e.page.borderBox, o),
+		destination: t,
+		withDroppableDisplacement: i,
+		viewport: r
+	};
+	return a ? Qe(s) : Ze(s);
+}, Dt = ({ isMovingForward: e, draggable: t, destination: n, draggables: r, previousImpact: i, viewport: a, previousPageBorderBoxCenter: o, previousClientSelection: s, afterCritical: c }) => {
+	if (!n.isEnabled) return null;
+	let l = V(n.descriptor.id, r), u = H(t, n), d = Re({
+		isMovingForward: e,
+		draggable: t,
+		destination: n,
+		insideDestination: l,
+		previousImpact: i
+	}) || st({
+		isMovingForward: e,
+		isInHomeList: u,
+		draggable: t,
+		draggables: r,
+		destination: n,
+		insideDestination: l,
+		previousImpact: i,
+		viewport: a,
+		afterCritical: c
+	});
+	if (!d) return null;
+	let f = yt({
+		impact: d,
+		draggable: t,
+		droppable: n,
+		draggables: r,
+		afterCritical: c
+	});
+	if (Et({
+		draggable: t,
+		destination: n,
+		newPageBorderBoxCenter: f,
+		viewport: a.frame,
+		withDroppableDisplacement: !1,
+		onlyOnMainAxis: !0
+	})) return {
+		clientSelection: Tt({
+			pageBorderBoxCenter: f,
+			draggable: t,
+			viewport: a
+		}),
+		impact: d,
+		scrollJumpRequest: null
+	};
+	let p = F(f, o);
+	return {
+		clientSelection: s,
+		impact: Ct({
+			impact: d,
+			viewport: a,
+			destination: n,
+			draggables: r,
+			maxScrollChange: p
+		}),
+		scrollJumpRequest: p
+	};
+}, K = (e) => {
+	let t = e.subject.active;
+	return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot get clipped area from droppable")), t;
+}, Ot = ({ isMovingForward: e, pageBorderBoxCenter: t, source: n, droppables: r, viewport: i }) => {
+	let a = n.subject.active;
+	if (!a) return null;
+	let o = n.axis, s = W(a[o.start], a[o.end]), c = Ne(r).filter((e) => e !== n).filter((e) => e.isEnabled).filter((e) => !!e.subject.active).filter((e) => Ve(i.frame)(K(e))).filter((t) => {
+		let n = K(t);
+		return e ? a[o.crossAxisEnd] < n[o.crossAxisEnd] : n[o.crossAxisStart] < a[o.crossAxisStart];
+	}).filter((e) => {
+		let t = K(e), n = W(t[o.start], t[o.end]);
+		return s(t[o.start]) || s(t[o.end]) || n(a[o.start]) || n(a[o.end]);
+	}).sort((t, n) => {
+		let r = K(t)[o.crossAxisStart], i = K(n)[o.crossAxisStart];
+		return e ? r - i : i - r;
+	}).filter((e, t, n) => K(e)[o.crossAxisStart] === K(n[0])[o.crossAxisStart]);
+	if (!c.length) return null;
+	if (c.length === 1) return c[0];
+	let l = c.filter((e) => W(K(e)[o.start], K(e)[o.end])(t[o.line]));
+	return l.length === 1 ? l[0] : l.length > 1 ? l.sort((e, t) => K(e)[o.start] - K(t)[o.start])[0] : c.sort((e, n) => {
+		let r = xe(t, Te(K(e))), i = xe(t, Te(K(n)));
+		return r === i ? K(e)[o.start] - K(n)[o.start] : r - i;
+	})[0];
+}, kt = (e, t) => {
+	let n = e.page.borderBox.center;
+	return G(e.descriptor.id, t) ? F(n, t.displacedBy.point) : n;
+}, At = (e, t) => {
+	let n = e.page.borderBox;
+	return G(e.descriptor.id, t) ? we(n, L(t.displacedBy.point)) : n;
+}, jt = ({ pageBorderBoxCenter: e, viewport: t, destination: n, insideDestination: r, afterCritical: i }) => r.filter((e) => Ze({
+	target: At(e, i),
+	destination: n,
+	viewport: t.frame,
+	withDroppableDisplacement: !0
+})).sort((t, r) => {
+	let a = be(e, _t(n, kt(t, i))), o = be(e, _t(n, kt(r, i)));
+	return a < o ? -1 : o < a ? 1 : t.descriptor.index - r.descriptor.index;
+})[0] || null, Mt = B(function(e, t) {
+	let n = t[e.line];
+	return {
+		value: n,
+		point: R(e.line, n)
+	};
+}), Nt = (e, t, n) => {
+	let r = e.axis;
+	if (e.descriptor.mode === "virtual") return R(r.line, t[r.line]);
+	let i = e.subject.page.contentBox[r.size], a = V(e.descriptor.id, n).reduce((e, t) => e + t.client.marginBox[r.size], 0) + t[r.line] - i;
+	return a <= 0 ? null : R(r.line, a);
+}, Pt = (e, t) => ({
+	...e,
+	scroll: {
+		...e.scroll,
+		max: t
+	}
+}), Ft = (e, t, n) => {
+	let r = e.frame;
+	H(t, e) && (process.env.NODE_ENV === "production" ? A() : A(!1, "Should not add placeholder space to home list")), e.subject.withPlaceholder && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot add placeholder size to a subject when it already has one"));
+	let i = Mt(e.axis, t.displaceBy).point, a = Nt(e, i, n), o = {
+		placeholderSize: i,
+		increasedBy: a,
+		oldFrameMaxScroll: e.frame ? e.frame.scroll.max : null
+	};
+	if (!r) {
+		let t = z({
+			page: e.subject.page,
+			withPlaceholder: o,
+			axis: e.axis,
+			frame: e.frame
+		});
+		return {
+			...e,
+			subject: t
+		};
+	}
+	let s = Pt(r, a ? P(r.scroll.max, a) : r.scroll.max), c = z({
+		page: e.subject.page,
+		withPlaceholder: o,
+		axis: e.axis,
+		frame: s
+	});
+	return {
+		...e,
+		subject: c,
+		frame: s
+	};
+}, It = (e) => {
+	let t = e.subject.withPlaceholder;
+	!t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot remove placeholder form subject when there was none"));
+	let n = e.frame;
+	if (!n) {
+		let t = z({
+			page: e.subject.page,
+			axis: e.axis,
+			frame: null,
+			withPlaceholder: null
+		});
+		return {
+			...e,
+			subject: t
+		};
+	}
+	let r = t.oldFrameMaxScroll;
+	!r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected droppable with frame to have old max frame scroll when removing placeholder"));
+	let i = Pt(n, r), a = z({
+		page: e.subject.page,
+		axis: e.axis,
+		frame: i,
+		withPlaceholder: null
+	});
+	return {
+		...e,
+		subject: a,
+		frame: i
+	};
+}, Lt = ({ previousPageBorderBoxCenter: e, moveRelativeTo: t, insideDestination: n, draggable: r, draggables: i, destination: a, viewport: o, afterCritical: s }) => {
+	if (!t) {
+		if (n.length) return null;
+		let e = {
+			displaced: U,
+			displacedBy: ze,
+			at: {
+				type: "REORDER",
+				destination: {
+					droppableId: a.descriptor.id,
+					index: 0
+				}
+			}
+		}, t = yt({
+			impact: e,
+			draggable: r,
+			droppable: a,
+			draggables: i,
+			afterCritical: s
+		});
+		return Et({
+			draggable: r,
+			destination: H(r, a) ? a : Ft(a, r, i),
+			newPageBorderBoxCenter: t,
+			viewport: o.frame,
+			withDroppableDisplacement: !1,
+			onlyOnMainAxis: !0
+		}) ? e : null;
+	}
+	let c = e[a.axis.line] <= t.page.borderBox.center[a.axis.line], l = (() => {
+		let e = t.descriptor.index;
+		return t.descriptor.id === r.descriptor.id || c ? e : e + 1;
+	})();
+	return it({
+		draggable: r,
+		insideDestination: n,
+		destination: a,
+		viewport: o,
+		displacedBy: Mt(a.axis, r.displaceBy),
+		last: U,
+		index: l
+	});
+}, Rt = ({ isMovingForward: e, previousPageBorderBoxCenter: t, draggable: n, isOver: r, draggables: i, droppables: a, viewport: o, afterCritical: s }) => {
+	let c = Ot({
+		isMovingForward: e,
+		pageBorderBoxCenter: t,
+		source: r,
+		droppables: a,
+		viewport: o
+	});
+	if (!c) return null;
+	let l = V(c.descriptor.id, i), u = Lt({
+		previousPageBorderBoxCenter: t,
+		destination: c,
+		draggable: n,
+		draggables: i,
+		moveRelativeTo: jt({
+			pageBorderBoxCenter: t,
+			viewport: o,
+			destination: c,
+			insideDestination: l,
+			afterCritical: s
+		}),
+		insideDestination: l,
+		viewport: o,
+		afterCritical: s
+	});
+	return u ? {
+		clientSelection: Tt({
+			pageBorderBoxCenter: yt({
+				impact: u,
+				draggable: n,
+				droppable: c,
+				draggables: i,
+				afterCritical: s
+			}),
+			draggable: n,
+			viewport: o
+		}),
+		impact: u,
+		scrollJumpRequest: null
+	} : null;
+}, q = (e) => {
+	let t = e.at;
+	return t ? t.type === "REORDER" ? t.destination.droppableId : t.combine.droppableId : null;
+}, zt = (e, t) => {
+	let n = q(e);
+	return n ? t[n] : null;
+}, Bt = ({ state: e, type: t }) => {
+	let n = zt(e.impact, e.dimensions.droppables), r = !!n, i = e.dimensions.droppables[e.critical.droppable.id], a = n || i, o = a.axis.direction, s = o === "vertical" && (t === "MOVE_UP" || t === "MOVE_DOWN") || o === "horizontal" && (t === "MOVE_LEFT" || t === "MOVE_RIGHT");
+	if (s && !r) return null;
+	let c = t === "MOVE_DOWN" || t === "MOVE_RIGHT", l = e.dimensions.draggables[e.critical.draggable.id], u = e.current.page.borderBoxCenter, { draggables: d, droppables: f } = e.dimensions;
+	return s ? Dt({
+		isMovingForward: c,
+		previousPageBorderBoxCenter: u,
+		draggable: l,
+		destination: a,
+		draggables: d,
+		viewport: e.viewport,
+		previousClientSelection: e.current.client.selection,
+		previousImpact: e.impact,
+		afterCritical: e.afterCritical
+	}) : Rt({
+		isMovingForward: c,
+		previousPageBorderBoxCenter: u,
+		draggable: l,
+		isOver: a,
+		draggables: d,
+		droppables: f,
+		viewport: e.viewport,
+		afterCritical: e.afterCritical
+	});
+};
+function J(e) {
+	return e.phase === "DRAGGING" || e.phase === "COLLECTING";
+}
+function Vt(e) {
+	let t = W(e.top, e.bottom), n = W(e.left, e.right);
+	return function(e) {
+		return t(e.y) && n(e.x);
+	};
+}
+function Ht(e, t) {
+	return e.left < t.right && e.right > t.left && e.top < t.bottom && e.bottom > t.top;
+}
+function Ut({ pageBorderBox: e, draggable: t, candidates: n }) {
+	let r = t.page.borderBox.center, i = n.map((t) => {
+		let n = t.axis, i = R(t.axis.line, e.center[n.line], t.page.borderBox.center[n.crossAxisLine]);
+		return {
+			id: t.descriptor.id,
+			distance: be(r, i)
+		};
+	}).sort((e, t) => t.distance - e.distance);
+	return i[0] ? i[0].id : null;
+}
+function Wt({ pageBorderBox: e, draggable: t, droppables: n }) {
+	let r = Ne(n).filter((t) => {
+		if (!t.isEnabled) return !1;
+		let n = t.subject.active;
+		if (!n || !Ht(e, n)) return !1;
+		if (Vt(n)(e.center)) return !0;
+		let r = t.axis, i = n.center[r.crossAxisLine], a = e[r.crossAxisStart], o = e[r.crossAxisEnd], s = W(n[r.crossAxisStart], n[r.crossAxisEnd]), c = s(a), l = s(o);
+		return !c && !l ? !0 : c ? a < i : o > i;
+	});
+	return r.length ? r.length === 1 ? r[0].descriptor.id : Ut({
+		pageBorderBox: e,
+		draggable: t,
+		candidates: r
+	}) : null;
+}
+var Gt = (e, t) => u(we(e, t)), Kt = (e, t) => {
+	let n = e.frame;
+	return n ? Gt(t, n.scroll.diff.value) : t;
+};
+function qt({ displaced: e, id: t }) {
+	return !!(e.visible[t] || e.invisible[t]);
+}
+function Jt({ draggable: e, closest: t, inHomeList: n }) {
+	return t ? n && t.descriptor.index > e.descriptor.index ? t.descriptor.index - 1 : t.descriptor.index : null;
+}
+var Yt = ({ pageBorderBoxWithDroppableScroll: e, draggable: t, destination: n, insideDestination: r, last: i, viewport: a, afterCritical: o }) => {
+	let s = n.axis, c = Mt(n.axis, t.displaceBy), l = c.value, u = e[s.start], d = e[s.end];
+	return it({
+		draggable: t,
+		insideDestination: r,
+		destination: n,
+		viewport: a,
+		last: i,
+		displacedBy: c,
+		index: Jt({
+			draggable: t,
+			closest: Le(t, r).find((e) => {
+				let t = e.descriptor.id, n = e.page.borderBox.center[s.line], r = G(t, o), a = qt({
+					displaced: i,
+					id: t
+				});
+				return r ? a ? d <= n : u < n - l : a ? d <= n + l : u < n;
+			}) || null,
+			inHomeList: H(t, n)
+		})
+	});
+}, Xt = 4, Zt = ({ draggable: e, pageBorderBoxWithDroppableScroll: t, previousImpact: n, destination: r, insideDestination: i, afterCritical: a }) => {
+	if (!r.isCombineEnabled) return null;
+	let o = r.axis, s = Mt(r.axis, e.displaceBy), c = s.value, l = t[o.start], u = t[o.end], d = Le(e, i).find((e) => {
+		let t = e.descriptor.id, r = e.page.borderBox, i = r[o.size] / Xt, s = G(t, a), d = qt({
+			displaced: n.displaced,
+			id: t
+		});
+		return s ? d ? u > r[o.start] + i && u < r[o.end] - i : l > r[o.start] - c + i && l < r[o.end] - c - i : d ? u > r[o.start] + c + i && u < r[o.end] + c - i : l > r[o.start] + i && l < r[o.end] - i;
+	});
+	return d ? {
+		displacedBy: s,
+		displaced: n.displaced,
+		at: {
+			type: "COMBINE",
+			combine: {
+				draggableId: d.descriptor.id,
+				droppableId: r.descriptor.id
+			}
+		}
+	} : null;
+}, Qt = ({ pageOffset: e, draggable: t, draggables: n, droppables: r, previousImpact: i, viewport: a, afterCritical: o }) => {
+	let s = Gt(t.page.borderBox, e), c = Wt({
+		pageBorderBox: s,
+		draggable: t,
+		droppables: r
+	});
+	if (!c) return Be;
+	let l = r[c], u = V(l.descriptor.id, n), d = Kt(l, s);
+	return Zt({
+		pageBorderBoxWithDroppableScroll: d,
+		draggable: t,
+		previousImpact: i,
+		destination: l,
+		insideDestination: u,
+		afterCritical: o
+	}) || Yt({
+		pageBorderBoxWithDroppableScroll: d,
+		draggable: t,
+		destination: l,
+		insideDestination: u,
+		last: i.displaced,
+		viewport: a,
+		afterCritical: o
+	});
+}, $t = (e, t) => ({
+	...e,
+	[t.descriptor.id]: t
+}), en = ({ previousImpact: e, impact: t, droppables: n }) => {
+	let r = q(e), i = q(t);
+	if (!r || r === i) return n;
+	let a = n[r];
+	return a.subject.withPlaceholder ? $t(n, It(a)) : n;
+}, tn = ({ draggable: e, draggables: t, droppables: n, previousImpact: r, impact: i }) => {
+	let a = en({
+		previousImpact: r,
+		impact: i,
+		droppables: n
+	}), o = q(i);
+	if (!o) return a;
+	let s = n[o];
+	return H(e, s) || s.subject.withPlaceholder ? a : $t(a, Ft(s, e, t));
+}, nn = ({ state: e, clientSelection: t, dimensions: n, viewport: r, impact: i, scrollJumpRequest: a }) => {
+	let o = r || e.viewport, s = n || e.dimensions, c = t || e.current.client.selection, l = F(c, e.initial.client.selection), u = {
+		offset: l,
+		selection: c,
+		borderBoxCenter: P(e.initial.client.borderBoxCenter, l)
+	}, d = {
+		selection: P(u.selection, o.scroll.current),
+		borderBoxCenter: P(u.borderBoxCenter, o.scroll.current),
+		offset: P(u.offset, o.scroll.diff.value)
+	}, f = {
+		client: u,
+		page: d
+	};
+	if (e.phase === "COLLECTING") return {
+		...e,
+		dimensions: s,
+		viewport: o,
+		current: f
+	};
+	let p = s.draggables[e.critical.draggable.id], m = i || Qt({
+		pageOffset: d.offset,
+		draggable: p,
+		draggables: s.draggables,
+		droppables: s.droppables,
+		previousImpact: e.impact,
+		viewport: o,
+		afterCritical: e.afterCritical
+	}), h = tn({
+		draggable: p,
+		impact: m,
+		previousImpact: e.impact,
+		draggables: s.draggables,
+		droppables: s.droppables
+	});
+	return {
+		...e,
+		current: f,
+		dimensions: {
+			draggables: s.draggables,
+			droppables: h
+		},
+		impact: m,
+		viewport: o,
+		scrollJumpRequest: a || null,
+		forceShouldAnimate: a ? !1 : null
+	};
+};
+function rn(e, t) {
+	return e.map((e) => t[e]);
+}
+var an = ({ impact: e, viewport: t, draggables: n, destination: r, forceShouldAnimate: i }) => {
+	let a = e.displaced, o = tt({
+		afterDragging: rn(a.all, n),
+		destination: r,
+		displacedBy: e.displacedBy,
+		viewport: t.frame,
+		forceShouldAnimate: i,
+		last: a
+	});
+	return {
+		...e,
+		displaced: o
+	};
+}, on = ({ impact: e, draggable: t, droppable: n, draggables: r, viewport: i, afterCritical: a }) => Tt({
+	pageBorderBoxCenter: yt({
+		impact: e,
+		draggable: t,
+		draggables: r,
+		droppable: n,
+		afterCritical: a
+	}),
+	draggable: t,
+	viewport: i
+}), sn = ({ state: e, dimensions: t, viewport: n }) => {
+	e.movementMode !== "SNAP" && (process.env.NODE_ENV, A());
+	let r = e.impact, i = n || e.viewport, a = t || e.dimensions, { draggables: o, droppables: s } = a, c = o[e.critical.draggable.id], l = q(r);
+	!l && (process.env.NODE_ENV === "production" ? A() : A(!1, "Must be over a destination in SNAP movement mode"));
+	let u = s[l], d = an({
+		impact: r,
+		viewport: i,
+		destination: u,
+		draggables: o
+	});
+	return nn({
+		impact: d,
+		clientSelection: on({
+			impact: d,
+			draggable: c,
+			droppable: u,
+			draggables: o,
+			viewport: i,
+			afterCritical: e.afterCritical
+		}),
+		state: e,
+		dimensions: a,
+		viewport: i
+	});
+}, cn = (e) => ({
+	index: e.index,
+	droppableId: e.droppableId
+}), ln = ({ draggable: e, home: t, draggables: n, viewport: r }) => {
+	let i = Mt(t.axis, e.displaceBy), a = V(t.descriptor.id, n), o = a.indexOf(e);
+	o === -1 && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected draggable to be inside home list"));
+	let s = a.slice(o + 1), c = s.reduce((e, t) => (e[t.descriptor.id] = !0, e), {}), l = {
+		inVirtualList: t.descriptor.mode === "virtual",
+		displacedBy: i,
+		effected: c
+	};
+	return {
+		impact: {
+			displaced: tt({
+				afterDragging: s,
+				destination: t,
+				displacedBy: i,
+				last: null,
+				viewport: r.frame,
+				forceShouldAnimate: !1
+			}),
+			displacedBy: i,
+			at: {
+				type: "REORDER",
+				destination: cn(e.descriptor)
+			}
+		},
+		afterCritical: l
+	};
+}, un = (e, t) => ({
+	draggables: e.draggables,
+	droppables: $t(e.droppables, t)
+}), dn = (e) => {
+	process.env.NODE_ENV;
+}, fn = (e) => {
+	process.env.NODE_ENV;
+}, pn = ({ draggable: e, offset: t, initialWindowScroll: n }) => {
+	let r = d(e.client, t), i = f(r, n);
+	return {
+		...e,
+		placeholder: {
+			...e.placeholder,
+			client: r
+		},
+		client: r,
+		page: i
+	};
+}, mn = (e) => {
+	let t = e.frame;
+	return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected Droppable to have a frame")), t;
+}, hn = ({ additions: e, updatedDroppables: t, viewport: n }) => {
+	let r = n.scroll.diff.value;
+	return e.map((e) => {
+		let i = t[e.descriptor.droppableId], a = mn(i).scroll.diff.value;
+		return pn({
+			draggable: e,
+			offset: P(r, a),
+			initialWindowScroll: n.scroll.initial
+		});
+	});
+}, gn = ({ state: e, published: t }) => {
+	dn();
+	let n = t.modified.map((t) => {
+		let n = e.dimensions.droppables[t.droppableId];
+		return Ae(n, t.scroll);
+	}), r = {
+		...e.dimensions.droppables,
+		...je(n)
+	}, i = Me(hn({
+		additions: t.additions,
+		updatedDroppables: r,
+		viewport: e.viewport
+	})), a = {
+		...e.dimensions.draggables,
+		...i
+	};
+	t.removals.forEach((e) => {
+		delete a[e];
+	});
+	let o = {
+		droppables: r,
+		draggables: a
+	}, s = q(e.impact), c = s ? o.droppables[s] : null, l = o.draggables[e.critical.draggable.id], u = o.droppables[e.critical.droppable.id], { impact: d, afterCritical: f } = ln({
+		draggable: l,
+		home: u,
+		draggables: a,
+		viewport: e.viewport
+	}), p = c && c.isCombineEnabled ? e.impact : d, m = Qt({
+		pageOffset: e.current.page.offset,
+		draggable: o.draggables[e.critical.draggable.id],
+		draggables: o.draggables,
+		droppables: o.droppables,
+		previousImpact: p,
+		viewport: e.viewport,
+		afterCritical: f
+	});
+	fn();
+	let h = {
+		...e,
+		phase: "DRAGGING",
+		impact: m,
+		onLiftImpact: d,
+		dimensions: o,
+		afterCritical: f,
+		forceShouldAnimate: !1
+	};
+	return e.phase === "COLLECTING" ? h : {
+		...h,
+		phase: "DROP_PENDING",
+		reason: e.reason,
+		isWaiting: !1
+	};
+}, _n = (e) => e.movementMode === "SNAP", vn = (e, t, n) => {
+	let r = un(e.dimensions, t);
+	return !_n(e) || n ? nn({
+		state: e,
+		dimensions: r
+	}) : sn({
+		state: e,
+		dimensions: r
+	});
+};
+function yn(e) {
+	return e.isDragging && e.movementMode === "SNAP" ? {
+		...e,
+		scrollJumpRequest: null
+	} : e;
+}
+var bn = {
+	phase: "IDLE",
+	completed: null,
+	shouldFlush: !1
+}, xn = (e = bn, t) => {
+	if (t.type === "FLUSH") return {
+		...bn,
+		shouldFlush: !0
+	};
+	if (t.type === "INITIAL_PUBLISH") {
+		e.phase !== "IDLE" && (process.env.NODE_ENV === "production" ? A() : A(!1, "INITIAL_PUBLISH must come after a IDLE phase"));
+		let { critical: n, clientSelection: r, viewport: i, dimensions: a, movementMode: o } = t.payload, s = a.draggables[n.draggable.id], c = a.droppables[n.droppable.id], l = {
+			selection: r,
+			borderBoxCenter: s.client.borderBox.center,
+			offset: N
+		}, u = {
+			client: l,
+			page: {
+				selection: P(l.selection, i.scroll.initial),
+				borderBoxCenter: P(l.selection, i.scroll.initial),
+				offset: P(l.selection, i.scroll.diff.value)
+			}
+		}, d = Ne(a.droppables).every((e) => !e.isFixedOnPage), { impact: f, afterCritical: p } = ln({
+			draggable: s,
+			home: c,
+			draggables: a.draggables,
+			viewport: i
+		});
+		return {
+			phase: "DRAGGING",
+			isDragging: !0,
+			critical: n,
+			movementMode: o,
+			dimensions: a,
+			initial: u,
+			current: u,
+			isWindowScrollAllowed: d,
+			impact: f,
+			afterCritical: p,
+			onLiftImpact: f,
+			viewport: i,
+			scrollJumpRequest: null,
+			forceShouldAnimate: null
+		};
+	}
+	if (t.type === "COLLECTION_STARTING") return e.phase === "COLLECTING" || e.phase === "DROP_PENDING" ? e : (e.phase !== "DRAGGING" && (process.env.NODE_ENV === "production" ? A() : A(!1, `Collection cannot start from phase ${e.phase}`)), {
+		...e,
+		phase: "COLLECTING"
+	});
+	if (t.type === "PUBLISH_WHILE_DRAGGING") return !(e.phase === "COLLECTING" || e.phase === "DROP_PENDING") && (process.env.NODE_ENV === "production" ? A() : A(!1, `Unexpected ${t.type} received in phase ${e.phase}`)), gn({
+		state: e,
+		published: t.payload
+	});
+	if (t.type === "MOVE") {
+		if (e.phase === "DROP_PENDING") return e;
+		!J(e) && (process.env.NODE_ENV === "production" ? A() : A(!1, `${t.type} not permitted in phase ${e.phase}`));
+		let { client: n } = t.payload;
+		return I(n, e.current.client.selection) ? e : nn({
+			state: e,
+			clientSelection: n,
+			impact: _n(e) ? e.impact : null
+		});
+	}
+	if (t.type === "UPDATE_DROPPABLE_SCROLL") {
+		if (e.phase === "DROP_PENDING" || e.phase === "COLLECTING") return yn(e);
+		!J(e) && (process.env.NODE_ENV === "production" ? A() : A(!1, `${t.type} not permitted in phase ${e.phase}`));
+		let { id: n, newScroll: r } = t.payload, i = e.dimensions.droppables[n];
+		return i ? vn(e, Ae(i, r), !1) : e;
+	}
+	if (t.type === "UPDATE_DROPPABLE_IS_ENABLED") {
+		if (e.phase === "DROP_PENDING") return e;
+		!J(e) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Attempting to move in an unsupported phase ${e.phase}`));
+		let { id: n, isEnabled: r } = t.payload, i = e.dimensions.droppables[n];
+		return !i && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot find Droppable[id: ${n}] to toggle its enabled state`)), i.isEnabled === r && (process.env.NODE_ENV === "production" ? A() : A(!1, `Trying to set droppable isEnabled to ${String(r)}
+      but it is already ${String(i.isEnabled)}`)), vn(e, {
+			...i,
+			isEnabled: r
+		}, !0);
+	}
+	if (t.type === "UPDATE_DROPPABLE_IS_COMBINE_ENABLED") {
+		if (e.phase === "DROP_PENDING") return e;
+		!J(e) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Attempting to move in an unsupported phase ${e.phase}`));
+		let { id: n, isCombineEnabled: r } = t.payload, i = e.dimensions.droppables[n];
+		return !i && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot find Droppable[id: ${n}] to toggle its isCombineEnabled state`)), i.isCombineEnabled === r && (process.env.NODE_ENV === "production" ? A() : A(!1, `Trying to set droppable isCombineEnabled to ${String(r)}
+      but it is already ${String(i.isCombineEnabled)}`)), vn(e, {
+			...i,
+			isCombineEnabled: r
+		}, !0);
+	}
+	if (t.type === "MOVE_BY_WINDOW_SCROLL") {
+		if (e.phase === "DROP_PENDING" || e.phase === "DROP_ANIMATING") return e;
+		!J(e) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot move by window in phase ${e.phase}`)), !e.isWindowScrollAllowed && (process.env.NODE_ENV === "production" ? A() : A(!1, "Window scrolling is currently not supported for fixed lists"));
+		let n = t.payload.newScroll;
+		if (I(e.viewport.scroll.current, n)) return yn(e);
+		let r = bt(e.viewport, n);
+		return _n(e) ? sn({
+			state: e,
+			viewport: r
+		}) : nn({
+			state: e,
+			viewport: r
+		});
+	}
+	if (t.type === "UPDATE_VIEWPORT_MAX_SCROLL") {
+		if (!J(e)) return e;
+		let n = t.payload.maxScroll;
+		if (I(n, e.viewport.scroll.max)) return e;
+		let r = {
+			...e.viewport,
+			scroll: {
+				...e.viewport.scroll,
+				max: n
+			}
+		};
+		return {
+			...e,
+			viewport: r
+		};
+	}
+	if (t.type === "MOVE_UP" || t.type === "MOVE_DOWN" || t.type === "MOVE_LEFT" || t.type === "MOVE_RIGHT") {
+		if (e.phase === "COLLECTING" || e.phase === "DROP_PENDING") return e;
+		e.phase !== "DRAGGING" && (process.env.NODE_ENV === "production" ? A() : A(!1, `${t.type} received while not in DRAGGING phase`));
+		let n = Bt({
+			state: e,
+			type: t.type
+		});
+		return n ? nn({
+			state: e,
+			impact: n.impact,
+			clientSelection: n.clientSelection,
+			scrollJumpRequest: n.scrollJumpRequest
+		}) : e;
+	}
+	if (t.type === "DROP_PENDING") {
+		let n = t.payload.reason;
+		return e.phase !== "COLLECTING" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Can only move into the DROP_PENDING phase from the COLLECTING phase")), {
+			...e,
+			phase: "DROP_PENDING",
+			isWaiting: !0,
+			reason: n
+		};
+	}
+	if (t.type === "DROP_ANIMATE") {
+		let { completed: n, dropDuration: r, newHomeClientOffset: i } = t.payload;
+		return !(e.phase === "DRAGGING" || e.phase === "DROP_PENDING") && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot animate drop from phase ${e.phase}`)), {
+			phase: "DROP_ANIMATING",
+			completed: n,
+			dropDuration: r,
+			newHomeClientOffset: i,
+			dimensions: e.dimensions
+		};
+	}
+	if (t.type === "DROP_COMPLETE") {
+		let { completed: e } = t.payload;
+		return {
+			phase: "IDLE",
+			completed: e,
+			shouldFlush: !1
+		};
+	}
+	return e;
+};
+function Y(e, t) {
+	return e instanceof Object && "type" in e && e.type === t;
+}
+var Sn = (e) => ({
+	type: "BEFORE_INITIAL_CAPTURE",
+	payload: e
+}), Cn = (e) => ({
+	type: "LIFT",
+	payload: e
+}), wn = (e) => ({
+	type: "INITIAL_PUBLISH",
+	payload: e
+}), Tn = (e) => ({
+	type: "PUBLISH_WHILE_DRAGGING",
+	payload: e
+}), En = () => ({
+	type: "COLLECTION_STARTING",
+	payload: null
+}), Dn = (e) => ({
+	type: "UPDATE_DROPPABLE_SCROLL",
+	payload: e
+}), On = (e) => ({
+	type: "UPDATE_DROPPABLE_IS_ENABLED",
+	payload: e
+}), kn = (e) => ({
+	type: "UPDATE_DROPPABLE_IS_COMBINE_ENABLED",
+	payload: e
+}), An = (e) => ({
+	type: "MOVE",
+	payload: e
+}), jn = (e) => ({
+	type: "MOVE_BY_WINDOW_SCROLL",
+	payload: e
+}), Mn = (e) => ({
+	type: "UPDATE_VIEWPORT_MAX_SCROLL",
+	payload: e
+}), Nn = () => ({
+	type: "MOVE_UP",
+	payload: null
+}), Pn = () => ({
+	type: "MOVE_DOWN",
+	payload: null
+}), Fn = () => ({
+	type: "MOVE_RIGHT",
+	payload: null
+}), In = () => ({
+	type: "MOVE_LEFT",
+	payload: null
+}), Ln = () => ({
+	type: "FLUSH",
+	payload: null
+}), Rn = (e) => ({
+	type: "DROP_ANIMATE",
+	payload: e
+}), zn = (e) => ({
+	type: "DROP_COMPLETE",
+	payload: e
+}), Bn = (e) => ({
+	type: "DROP",
+	payload: e
+}), Vn = (e) => ({
+	type: "DROP_PENDING",
+	payload: e
+}), Hn = () => ({
+	type: "DROP_ANIMATION_FINISHED",
+	payload: null
+});
+function Un(e) {
+	if (e.length <= 1) return;
+	let t = e.map((e) => e.descriptor.index), n = {};
+	for (let e = 1; e < t.length; e++) {
+		let r = t[e];
+		r !== t[e - 1] + 1 && (n[r] = !0);
+	}
+	if (!Object.keys(n).length) return;
+	let r = t.map((e) => n[e] ? `[🔥${e}]` : `${e}`).join(", ");
+	process.env.NODE_ENV !== "production" && D(`
+    Detected non-consecutive <Draggable /> indexes.
+
+    (This can cause unexpected bugs)
+
+    ${r}
+  `);
+}
+function Wn(e, t) {
+	process.env.NODE_ENV !== "production" && Un(V(e.droppable.id, t.draggables));
+}
+var Gn = (e) => ({ getState: t, dispatch: n }) => (r) => (i) => {
+	if (!Y(i, "LIFT")) {
+		r(i);
+		return;
+	}
+	let { id: a, clientSelection: o, movementMode: s } = i.payload, c = t();
+	c.phase === "DROP_ANIMATING" && n(zn({ completed: c.completed })), t().phase !== "IDLE" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Unexpected phase to start a drag")), n(Ln()), n(Sn({
+		draggableId: a,
+		movementMode: s
+	}));
+	let l = {
+		draggableId: a,
+		scrollOptions: { shouldPublishImmediately: s === "SNAP" }
+	}, { critical: u, dimensions: d, viewport: f } = e.startPublishing(l);
+	Wn(u, d), n(wn({
+		critical: u,
+		dimensions: d,
+		clientSelection: o,
+		movementMode: s,
+		viewport: f
+	}));
+}, Kn = (e) => () => (t) => (n) => {
+	Y(n, "INITIAL_PUBLISH") && e.dragging(), Y(n, "DROP_ANIMATE") && e.dropping(n.payload.completed.result.reason), (Y(n, "FLUSH") || Y(n, "DROP_COMPLETE")) && e.resting(), t(n);
+}, qn = {
+	outOfTheWay: "cubic-bezier(0.2, 0, 0, 1)",
+	drop: "cubic-bezier(.2,1,.1,1)"
+}, Jn = {
+	opacity: {
+		drop: 0,
+		combining: .7
+	},
+	scale: { drop: .75 }
+}, Yn = {
+	outOfTheWay: .2,
+	minDropTime: .33,
+	maxDropTime: .55
+}, X = `${Yn.outOfTheWay}s ${qn.outOfTheWay}`, Xn = {
+	fluid: `opacity ${X}`,
+	snap: `transform ${X}, opacity ${X}`,
+	drop: (e) => {
+		let t = `${e}s ${qn.drop}`;
+		return `transform ${t}, opacity ${t}`;
+	},
+	outOfTheWay: `transform ${X}`,
+	placeholder: `height ${X}, width ${X}, margin ${X}`
+}, Zn = (e) => I(e, N) ? void 0 : `translate(${e.x}px, ${e.y}px)`, Qn = {
+	moveTo: Zn,
+	drop: (e, t) => {
+		let n = Zn(e);
+		if (n) return t ? `${n} scale(${Jn.scale.drop})` : n;
+	}
+}, { minDropTime: $n, maxDropTime: er } = Yn, tr = er - $n, nr = 1500, rr = .6, ir = ({ current: e, destination: t, reason: n }) => {
+	let r = be(e, t);
+	if (r <= 0) return $n;
+	if (r >= nr) return er;
+	let i = $n + r / nr * tr, a = n === "CANCEL" ? i * rr : i;
+	return Number(a.toFixed(2));
+}, ar = ({ impact: e, draggable: t, dimensions: n, viewport: r, afterCritical: i }) => {
+	let { draggables: a, droppables: o } = n, s = q(e), c = s ? o[s] : null, l = o[t.descriptor.droppableId];
+	return F(on({
+		impact: e,
+		draggable: t,
+		draggables: a,
+		afterCritical: i,
+		droppable: c || l,
+		viewport: r
+	}), t.client.borderBox.center);
+}, or = ({ draggables: e, reason: t, lastImpact: n, home: r, viewport: i, onLiftImpact: a }) => !n.at || t !== "DROP" ? {
+	impact: an({
+		draggables: e,
+		impact: a,
+		destination: r,
+		viewport: i,
+		forceShouldAnimate: !0
+	}),
+	didDropInsideDroppable: !1
+} : n.at.type === "REORDER" ? {
+	impact: n,
+	didDropInsideDroppable: !0
+} : {
+	impact: {
+		...n,
+		displaced: U
+	},
+	didDropInsideDroppable: !0
+}, sr = ({ getState: e, dispatch: t }) => (n) => (r) => {
+	if (!Y(r, "DROP")) {
+		n(r);
+		return;
+	}
+	let i = e(), a = r.payload.reason;
+	if (i.phase === "COLLECTING") {
+		t(Vn({ reason: a }));
+		return;
+	}
+	if (i.phase === "IDLE") return;
+	i.phase === "DROP_PENDING" && i.isWaiting && (process.env.NODE_ENV === "production" ? A() : A(!1, "A DROP action occurred while DROP_PENDING and still waiting")), !(i.phase === "DRAGGING" || i.phase === "DROP_PENDING") && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot drop in phase: ${i.phase}`));
+	let o = i.critical, s = i.dimensions, c = s.draggables[i.critical.draggable.id], { impact: l, didDropInsideDroppable: u } = or({
+		reason: a,
+		lastImpact: i.impact,
+		afterCritical: i.afterCritical,
+		onLiftImpact: i.onLiftImpact,
+		home: i.dimensions.droppables[i.critical.droppable.id],
+		viewport: i.viewport,
+		draggables: i.dimensions.draggables
+	}), d = u ? Fe(l) : null, f = u ? Ie(l) : null, p = {
+		index: o.draggable.index,
+		droppableId: o.droppable.id
+	}, m = {
+		draggableId: c.descriptor.id,
+		type: c.descriptor.type,
+		source: p,
+		reason: a,
+		mode: i.movementMode,
+		destination: d,
+		combine: f
+	}, h = ar({
+		impact: l,
+		draggable: c,
+		dimensions: s,
+		viewport: i.viewport,
+		afterCritical: i.afterCritical
+	}), g = {
+		critical: i.critical,
+		afterCritical: i.afterCritical,
+		result: m,
+		impact: l
+	};
+	if (!(!I(i.current.client.offset, h) || m.combine)) {
+		t(zn({ completed: g }));
+		return;
+	}
+	t(Rn({
+		newHomeClientOffset: h,
+		dropDuration: ir({
+			current: i.current.client.offset,
+			destination: h,
+			reason: a
+		}),
+		completed: g
+	}));
+}, cr = () => ({
+	x: window.pageXOffset,
+	y: window.pageYOffset
+});
+function lr(e) {
+	return {
+		eventName: "scroll",
+		options: {
+			passive: !0,
+			capture: !1
+		},
+		fn: (t) => {
+			t.target !== window && t.target !== window.document || e();
+		}
+	};
+}
+function ur({ onWindowScroll: e }) {
+	function t() {
+		e(cr());
+	}
+	let n = p(t), r = lr(n), i = O;
+	function a() {
+		return i !== O;
+	}
+	function o() {
+		a() && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot start scroll listener when already active")), i = k(window, [r]);
+	}
+	function s() {
+		!a() && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot stop scroll listener when not active")), n.cancel(), i(), i = O;
+	}
+	return {
+		start: o,
+		stop: s,
+		isActive: a
+	};
+}
+var dr = (e) => Y(e, "DROP_COMPLETE") || Y(e, "DROP_ANIMATE") || Y(e, "FLUSH"), fr = (e) => {
+	let t = ur({ onWindowScroll: (t) => {
+		e.dispatch(jn({ newScroll: t }));
+	} });
+	return (e) => (n) => {
+		!t.isActive() && Y(n, "INITIAL_PUBLISH") && t.start(), t.isActive() && dr(n) && t.stop(), e(n);
+	};
+}, pr = (e) => {
+	let t = !1, n = !1, r = setTimeout(() => {
+		n = !0;
+	}), i = (i) => {
+		if (t) {
+			process.env.NODE_ENV !== "production" && D("Announcement already made. Not making a second announcement");
+			return;
+		}
+		if (n) {
+			process.env.NODE_ENV !== "production" && D("\n        Announcements cannot be made asynchronously.\n        Default message has already been announced.\n      ");
+			return;
+		}
+		t = !0, e(i), clearTimeout(r);
+	};
+	return i.wasCalled = () => t, i;
+}, mr = () => {
+	let e = [], t = (t) => {
+		let n = e.findIndex((e) => e.timerId === t);
+		n === -1 && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find timer"));
+		let [r] = e.splice(n, 1);
+		r.callback();
+	};
+	return {
+		add: (n) => {
+			let r = setTimeout(() => t(r)), i = {
+				timerId: r,
+				callback: n
+			};
+			e.push(i);
+		},
+		flush: () => {
+			if (!e.length) return;
+			let t = [...e];
+			e.length = 0, t.forEach((e) => {
+				clearTimeout(e.timerId), e.callback();
+			});
+		}
+	};
+}, hr = (e, t) => e == null && t == null ? !0 : e == null || t == null ? !1 : e.droppableId === t.droppableId && e.index === t.index, gr = (e, t) => e == null && t == null ? !0 : e == null || t == null ? !1 : e.draggableId === t.draggableId && e.droppableId === t.droppableId, _r = (e, t) => {
+	if (e === t) return !0;
+	let n = e.draggable.id === t.draggable.id && e.draggable.droppableId === t.draggable.droppableId && e.draggable.type === t.draggable.type && e.draggable.index === t.draggable.index, r = e.droppable.id === t.droppable.id && e.droppable.type === t.droppable.type;
+	return n && r;
+}, vr = (e, t) => {
+	dn(), t(), fn();
+}, yr = (e, t) => ({
+	draggableId: e.draggable.id,
+	type: e.droppable.type,
+	source: {
+		droppableId: e.droppable.id,
+		index: e.draggable.index
+	},
+	mode: t
+});
+function br(e, t, n, r) {
+	if (!e) {
+		n(r(t));
+		return;
+	}
+	let i = pr(n);
+	e(t, { announce: i }), i.wasCalled() || n(r(t));
+}
+var xr = (e, t) => {
+	let n = mr(), r = null, i = (t, n) => {
+		r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fire onBeforeCapture as a drag start has already been published")), vr("onBeforeCapture", () => {
+			let r = e().onBeforeCapture;
+			r && r({
+				draggableId: t,
+				mode: n
+			});
+		});
+	}, a = (t, n) => {
+		r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fire onBeforeDragStart as a drag start has already been published")), vr("onBeforeDragStart", () => {
+			let r = e().onBeforeDragStart;
+			r && r(yr(t, n));
+		});
+	}, o = (i, a) => {
+		r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fire onBeforeDragStart as a drag start has already been published"));
+		let o = yr(i, a);
+		r = {
+			mode: a,
+			lastCritical: i,
+			lastLocation: o.source,
+			lastCombine: null
+		}, n.add(() => {
+			vr("onDragStart", () => br(e().onDragStart, o, t, _e.onDragStart));
+		});
+	}, s = (i, a) => {
+		let o = Fe(a), s = Ie(a);
+		!r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fire onDragMove when onDragStart has not been called"));
+		let c = !_r(i, r.lastCritical);
+		c && (r.lastCritical = i);
+		let l = !hr(r.lastLocation, o);
+		l && (r.lastLocation = o);
+		let u = !gr(r.lastCombine, s);
+		if (u && (r.lastCombine = s), !c && !l && !u) return;
+		let d = {
+			...yr(i, r.mode),
+			combine: s,
+			destination: o
+		};
+		n.add(() => {
+			vr("onDragUpdate", () => br(e().onDragUpdate, d, t, _e.onDragUpdate));
+		});
+	}, c = () => {
+		!r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Can only flush responders while dragging")), n.flush();
+	}, l = (n) => {
+		!r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fire onDragEnd when there is no matching onDragStart")), r = null, vr("onDragEnd", () => br(e().onDragEnd, n, t, _e.onDragEnd));
+	};
+	return {
+		beforeCapture: i,
+		beforeStart: a,
+		start: o,
+		update: s,
+		flush: c,
+		drop: l,
+		abort: () => {
+			r && l({
+				...yr(r.lastCritical, r.mode),
+				combine: null,
+				destination: null,
+				reason: "CANCEL"
+			});
+		}
+	};
+}, Sr = (e, t) => {
+	let n = xr(e, t);
+	return (e) => (t) => (r) => {
+		if (Y(r, "BEFORE_INITIAL_CAPTURE")) {
+			n.beforeCapture(r.payload.draggableId, r.payload.movementMode);
+			return;
+		}
+		if (Y(r, "INITIAL_PUBLISH")) {
+			let e = r.payload.critical;
+			n.beforeStart(e, r.payload.movementMode), t(r), n.start(e, r.payload.movementMode);
+			return;
+		}
+		if (Y(r, "DROP_COMPLETE")) {
+			let e = r.payload.completed.result;
+			n.flush(), t(r), n.drop(e);
+			return;
+		}
+		if (t(r), Y(r, "FLUSH")) {
+			n.abort();
+			return;
+		}
+		let i = e.getState();
+		i.phase === "DRAGGING" && n.update(i.critical, i.impact);
+	};
+}, Cr = (e) => (t) => (n) => {
+	if (!Y(n, "DROP_ANIMATION_FINISHED")) {
+		t(n);
+		return;
+	}
+	let r = e.getState();
+	r.phase !== "DROP_ANIMATING" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot finish a drop animating when no drop is occurring")), e.dispatch(zn({ completed: r.completed }));
+}, wr = (e) => {
+	let t = null, n = null;
+	function r() {
+		n &&= (cancelAnimationFrame(n), null), t &&= (t(), null);
+	}
+	return (i) => (a) => {
+		if ((Y(a, "FLUSH") || Y(a, "DROP_COMPLETE") || Y(a, "DROP_ANIMATION_FINISHED")) && r(), i(a), !Y(a, "DROP_ANIMATE")) return;
+		let o = {
+			eventName: "scroll",
+			options: {
+				capture: !0,
+				passive: !1,
+				once: !0
+			},
+			fn: function() {
+				e.getState().phase === "DROP_ANIMATING" && e.dispatch(Hn());
+			}
+		};
+		n = requestAnimationFrame(() => {
+			n = null, t = k(window, [o]);
+		});
+	};
+}, Tr = (e) => () => (t) => (n) => {
+	(Y(n, "DROP_COMPLETE") || Y(n, "FLUSH") || Y(n, "DROP_ANIMATE")) && e.stopPublishing(), t(n);
+}, Er = (e) => {
+	let t = !1;
+	return () => (n) => (r) => {
+		if (Y(r, "INITIAL_PUBLISH")) {
+			t = !0, e.tryRecordFocus(r.payload.critical.draggable.id), n(r), e.tryRestoreFocusRecorded();
+			return;
+		}
+		if (n(r), t) {
+			if (Y(r, "FLUSH")) {
+				t = !1, e.tryRestoreFocusRecorded();
+				return;
+			}
+			if (Y(r, "DROP_COMPLETE")) {
+				t = !1;
+				let n = r.payload.completed.result;
+				n.combine && e.tryShiftRecord(n.draggableId, n.combine.draggableId), e.tryRestoreFocusRecorded();
+			}
+		}
+	};
+}, Dr = (e) => Y(e, "DROP_COMPLETE") || Y(e, "DROP_ANIMATE") || Y(e, "FLUSH"), Or = (e) => (t) => (n) => (r) => {
+	if (Dr(r)) {
+		e.stop(), n(r);
+		return;
+	}
+	if (Y(r, "INITIAL_PUBLISH")) {
+		n(r);
+		let i = t.getState();
+		i.phase !== "DRAGGING" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected phase to be DRAGGING after INITIAL_PUBLISH")), e.start(i);
+		return;
+	}
+	n(r), e.scroll(t.getState());
+}, kr = (e) => (t) => (n) => {
+	if (t(n), !Y(n, "PUBLISH_WHILE_DRAGGING")) return;
+	let r = e.getState();
+	r.phase === "DROP_PENDING" && (r.isWaiting || e.dispatch(Bn({ reason: r.reason })));
+}, Ar = process.env.NODE_ENV !== "production" && typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({ name: "@hello-pangea/dnd" }) : n, jr = ({ dimensionMarshal: t, focusMarshal: n, styleMarshal: i, getResponders: a, announce: o, autoScroller: s }) => r(xn, Ar(e(Kn(i), Tr(t), Gn(t), sr, Cr, wr, kr, Or(s), fr, Er(n), Sr(a, o)))), Mr = () => ({
+	additions: {},
+	removals: {},
+	modified: {}
+});
+function Nr({ registry: e, callbacks: t }) {
+	let n = Mr(), r = null, i = () => {
+		r ||= (t.collectionStarting(), requestAnimationFrame(() => {
+			r = null, dn();
+			let { additions: i, removals: a, modified: o } = n, s = Object.keys(i).map((t) => e.draggable.getById(t).getDimension(N)).sort((e, t) => e.descriptor.index - t.descriptor.index), c = Object.keys(o).map((t) => ({
+				droppableId: t,
+				scroll: e.droppable.getById(t).callbacks.getScrollWhileDragging()
+			})), l = {
+				additions: s,
+				removals: Object.keys(a),
+				modified: c
+			};
+			n = Mr(), fn(), t.publish(l);
+		}));
+	};
+	return {
+		add: (e) => {
+			let t = e.descriptor.id;
+			n.additions[t] = e, n.modified[e.descriptor.droppableId] = !0, n.removals[t] && delete n.removals[t], i();
+		},
+		remove: (e) => {
+			let t = e.descriptor;
+			n.removals[t.id] = !0, n.modified[t.droppableId] = !0, n.additions[t.id] && delete n.additions[t.id], i();
+		},
+		stop: () => {
+			r && (cancelAnimationFrame(r), r = null, n = Mr());
+		}
+	};
+}
+var Pr = ({ scrollHeight: e, scrollWidth: t, height: n, width: r }) => {
+	let i = F({
+		x: t,
+		y: e
+	}, {
+		x: r,
+		y: n
+	});
+	return {
+		x: Math.max(0, i.x),
+		y: Math.max(0, i.y)
+	};
+}, Fr = () => {
+	let e = document.documentElement;
+	return !e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot find document.documentElement")), e;
+}, Ir = () => {
+	let e = Fr();
+	return Pr({
+		scrollHeight: e.scrollHeight,
+		scrollWidth: e.scrollWidth,
+		width: e.clientWidth,
+		height: e.clientHeight
+	});
+}, Lr = () => {
+	let e = cr(), t = Ir(), n = e.y, r = e.x, i = Fr(), a = i.clientWidth, o = i.clientHeight;
+	return {
+		frame: u({
+			top: n,
+			left: r,
+			right: r + a,
+			bottom: n + o
+		}),
+		scroll: {
+			initial: e,
+			current: e,
+			max: t,
+			diff: {
+				value: N,
+				displacement: N
+			}
+		}
+	};
+}, Rr = ({ critical: e, scrollOptions: t, registry: n }) => {
+	dn();
+	let r = Lr(), i = r.scroll.current, a = e.droppable, o = n.droppable.getAllByType(a.type).map((e) => e.callbacks.getDimensionAndWatchScroll(i, t)), s = {
+		draggables: Me(n.draggable.getAllByType(e.draggable.type).map((e) => e.getDimension(i))),
+		droppables: je(o)
+	};
+	return fn(), {
+		dimensions: s,
+		critical: e,
+		viewport: r
+	};
+};
+function zr(e, t, n) {
+	return n.descriptor.id === t.id || n.descriptor.type !== t.type ? !1 : e.droppable.getById(n.descriptor.droppableId).descriptor.mode === "virtual" ? !0 : (process.env.NODE_ENV !== "production" && D(`
+      You are attempting to add or remove a Draggable [id: ${n.descriptor.id}]
+      while a drag is occurring. This is only supported for virtual lists.
+
+      See https://github.com/hello-pangea/dnd/blob/main/docs/patterns/virtual-lists.md
+    `), !1);
+}
+var Br = (e, t) => {
+	let n = null, r = Nr({
+		callbacks: {
+			publish: t.publishWhileDragging,
+			collectionStarting: t.collectionStarting
+		},
+		registry: e
+	}), i = (r, i) => {
+		!e.droppable.exists(r) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot update is enabled flag of Droppable ${r} as it is not registered`)), n && t.updateDroppableIsEnabled({
+			id: r,
+			isEnabled: i
+		});
+	}, a = (r, i) => {
+		n && (!e.droppable.exists(r) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot update isCombineEnabled flag of Droppable ${r} as it is not registered`)), t.updateDroppableIsCombineEnabled({
+			id: r,
+			isCombineEnabled: i
+		}));
+	}, o = (r, i) => {
+		n && (!e.droppable.exists(r) && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot update the scroll on Droppable ${r} as it is not registered`)), t.updateDroppableScroll({
+			id: r,
+			newScroll: i
+		}));
+	}, s = (t, r) => {
+		n && e.droppable.getById(t).callbacks.scroll(r);
+	}, c = () => {
+		if (!n) return;
+		r.stop();
+		let t = n.critical.droppable;
+		e.droppable.getAllByType(t.type).forEach((e) => e.callbacks.dragStopped()), n.unsubscribe(), n = null;
+	}, l = (t) => {
+		!n && (process.env.NODE_ENV === "production" ? A() : A(!1, "Should only be subscribed when a collection is occurring"));
+		let i = n.critical.draggable;
+		t.type === "ADDITION" && zr(e, i, t.value) && r.add(t.value), t.type === "REMOVAL" && zr(e, i, t.value) && r.remove(t.value);
+	};
+	return {
+		updateDroppableIsEnabled: i,
+		updateDroppableIsCombineEnabled: a,
+		scrollDroppable: s,
+		updateDroppableScroll: o,
+		startPublishing: (t) => {
+			n && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot start capturing critical dimensions as there is already a collection"));
+			let r = e.draggable.getById(t.draggableId), i = e.droppable.getById(r.descriptor.droppableId), a = {
+				draggable: r.descriptor,
+				droppable: i.descriptor
+			};
+			return n = {
+				critical: a,
+				unsubscribe: e.subscribe(l)
+			}, Rr({
+				critical: a,
+				registry: e,
+				scrollOptions: t.scrollOptions
+			});
+		},
+		stopPublishing: c
+	};
+}, Vr = (e, t) => e.phase === "IDLE" ? !0 : e.phase !== "DROP_ANIMATING" || e.completed.result.draggableId === t ? !1 : e.completed.result.reason === "DROP", Hr = (e) => {
+	window.scrollBy(e.x, e.y);
+}, Ur = B((e) => Ne(e).filter((e) => !(!e.isEnabled || !e.frame))), Wr = (e, t) => Ur(t).find((t) => (!t.frame && (process.env.NODE_ENV === "production" ? A() : A(!1, "Invalid result")), Vt(t.frame.pageMarginBox)(e))) || null, Gr = ({ center: e, destination: t, droppables: n }) => {
+	if (t) {
+		let e = n[t];
+		return e.frame ? e : null;
+	}
+	return Wr(e, n);
+}, Kr = {
+	startFromPercentage: .25,
+	maxScrollAtPercentage: .05,
+	maxPixelScroll: 28,
+	ease: (e) => e ** 2,
+	durationDampening: {
+		stopDampeningAt: 1200,
+		accelerateAt: 360
+	},
+	disabled: !1
+}, qr = (e, t, n = () => Kr) => {
+	let r = n();
+	return {
+		startScrollingFrom: e[t.size] * r.startFromPercentage,
+		maxScrollValueAt: e[t.size] * r.maxScrollAtPercentage
+	};
+}, Jr = ({ startOfRange: e, endOfRange: t, current: n }) => {
+	let r = t - e;
+	return r === 0 ? (process.env.NODE_ENV !== "production" && D("\n      Detected distance range of 0 in the fluid auto scroller\n      This is unexpected and would cause a divide by 0 issue.\n      Not allowing an auto scroll\n    "), 0) : (n - e) / r;
+}, Yr = 1, Xr = (e, t, n = () => Kr) => {
+	let r = n();
+	if (e > t.startScrollingFrom) return 0;
+	if (e <= t.maxScrollValueAt) return r.maxPixelScroll;
+	if (e === t.startScrollingFrom) return Yr;
+	let i = 1 - Jr({
+		startOfRange: t.maxScrollValueAt,
+		endOfRange: t.startScrollingFrom,
+		current: e
+	}), a = r.maxPixelScroll * r.ease(i);
+	return Math.ceil(a);
+}, Zr = (e, t, n) => {
+	let r = n(), i = r.durationDampening.accelerateAt, a = r.durationDampening.stopDampeningAt, o = t, s = a, c = Date.now() - o;
+	if (c >= a) return e;
+	if (c < i) return Yr;
+	let l = Jr({
+		startOfRange: i,
+		endOfRange: s,
+		current: c
+	}), u = e * r.ease(l);
+	return Math.ceil(u);
+}, Qr = ({ distanceToEdge: e, thresholds: t, dragStartTime: n, shouldUseTimeDampening: r, getAutoScrollerOptions: i }) => {
+	let a = Xr(e, t, i);
+	return a === 0 ? 0 : r ? Math.max(Zr(a, n, i), Yr) : a;
+}, $r = ({ container: e, distanceToEdges: t, dragStartTime: n, axis: r, shouldUseTimeDampening: i, getAutoScrollerOptions: a }) => {
+	let o = qr(e, r, a);
+	return t[r.end] < t[r.start] ? Qr({
+		distanceToEdge: t[r.end],
+		thresholds: o,
+		dragStartTime: n,
+		shouldUseTimeDampening: i,
+		getAutoScrollerOptions: a
+	}) : -1 * Qr({
+		distanceToEdge: t[r.start],
+		thresholds: o,
+		dragStartTime: n,
+		shouldUseTimeDampening: i,
+		getAutoScrollerOptions: a
+	});
+}, ei = ({ container: e, subject: t, proposedScroll: n }) => {
+	let r = t.height > e.height, i = t.width > e.width;
+	return !i && !r ? n : i && r ? null : {
+		x: i ? 0 : n.x,
+		y: r ? 0 : n.y
+	};
+}, ti = Se((e) => e === 0 ? 0 : e), ni = ({ dragStartTime: e, container: t, subject: n, center: r, shouldUseTimeDampening: i, getAutoScrollerOptions: a }) => {
+	let o = {
+		top: r.y - t.top,
+		right: t.right - r.x,
+		bottom: t.bottom - r.y,
+		left: r.x - t.left
+	}, s = $r({
+		container: t,
+		distanceToEdges: o,
+		dragStartTime: e,
+		axis: Ue,
+		shouldUseTimeDampening: i,
+		getAutoScrollerOptions: a
+	}), c = ti({
+		x: $r({
+			container: t,
+			distanceToEdges: o,
+			dragStartTime: e,
+			axis: We,
+			shouldUseTimeDampening: i,
+			getAutoScrollerOptions: a
+		}),
+		y: s
+	});
+	if (I(c, N)) return null;
+	let l = ei({
+		container: t,
+		subject: n,
+		proposedScroll: c
+	});
+	return l ? I(l, N) ? null : l : null;
+}, ri = Se((e) => e === 0 ? 0 : e > 0 ? 1 : -1), ii = (() => {
+	let e = (e, t) => e < 0 ? e : e > t ? e - t : 0;
+	return ({ current: t, max: n, change: r }) => {
+		let i = P(t, r), a = {
+			x: e(i.x, n.x),
+			y: e(i.y, n.y)
+		};
+		return I(a, N) ? null : a;
+	};
+})(), ai = ({ max: e, current: t, change: n }) => {
+	let r = {
+		x: Math.max(t.x, e.x),
+		y: Math.max(t.y, e.y)
+	}, i = ri(n), a = ii({
+		max: r,
+		current: t,
+		change: i
+	});
+	return !a || i.x !== 0 && a.x === 0 || i.y !== 0 && a.y === 0;
+}, oi = (e, t) => ai({
+	current: e.scroll.current,
+	max: e.scroll.max,
+	change: t
+}), si = (e, t) => {
+	if (!oi(e, t)) return null;
+	let n = e.scroll.max, r = e.scroll.current;
+	return ii({
+		current: r,
+		max: n,
+		change: t
+	});
+}, ci = (e, t) => {
+	let n = e.frame;
+	return n ? ai({
+		current: n.scroll.current,
+		max: n.scroll.max,
+		change: t
+	}) : !1;
+}, li = (e, t) => {
+	let n = e.frame;
+	return !n || !ci(e, t) ? null : ii({
+		current: n.scroll.current,
+		max: n.scroll.max,
+		change: t
+	});
+}, ui = ({ viewport: e, subject: t, center: n, dragStartTime: r, shouldUseTimeDampening: i, getAutoScrollerOptions: a }) => {
+	let o = ni({
+		dragStartTime: r,
+		container: e.frame,
+		subject: t,
+		center: n,
+		shouldUseTimeDampening: i,
+		getAutoScrollerOptions: a
+	});
+	return o && oi(e, o) ? o : null;
+}, di = ({ droppable: e, subject: t, center: n, dragStartTime: r, shouldUseTimeDampening: i, getAutoScrollerOptions: a }) => {
+	let o = e.frame;
+	if (!o) return null;
+	let s = ni({
+		dragStartTime: r,
+		container: o.pageMarginBox,
+		subject: t,
+		center: n,
+		shouldUseTimeDampening: i,
+		getAutoScrollerOptions: a
+	});
+	return s && ci(e, s) ? s : null;
+}, fi = ({ state: e, dragStartTime: t, shouldUseTimeDampening: n, scrollWindow: r, scrollDroppable: i, getAutoScrollerOptions: a }) => {
+	let o = e.current.page.borderBoxCenter, s = e.dimensions.draggables[e.critical.draggable.id].page.marginBox;
+	if (e.isWindowScrollAllowed) {
+		let i = e.viewport, c = ui({
+			dragStartTime: t,
+			viewport: i,
+			subject: s,
+			center: o,
+			shouldUseTimeDampening: n,
+			getAutoScrollerOptions: a
+		});
+		if (c) {
+			r(c);
+			return;
+		}
+	}
+	let c = Gr({
+		center: o,
+		destination: q(e.impact),
+		droppables: e.dimensions.droppables
+	});
+	if (!c) return;
+	let l = di({
+		dragStartTime: t,
+		droppable: c,
+		subject: s,
+		center: o,
+		shouldUseTimeDampening: n,
+		getAutoScrollerOptions: a
+	});
+	l && i(c.descriptor.id, l);
+}, pi = ({ scrollWindow: e, scrollDroppable: t, getAutoScrollerOptions: n = () => Kr }) => {
+	let r = p(e), i = p(t), a = null, o = (e) => {
+		!a && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot fluid scroll if not dragging"));
+		let { shouldUseTimeDampening: t, dragStartTime: o } = a;
+		fi({
+			state: e,
+			scrollWindow: r,
+			scrollDroppable: i,
+			dragStartTime: o,
+			shouldUseTimeDampening: t,
+			getAutoScrollerOptions: n
+		});
+	};
+	return {
+		start: (e) => {
+			dn(), a && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot start auto scrolling when already started"));
+			let t = Date.now(), r = !1, i = () => {
+				r = !0;
+			};
+			fi({
+				state: e,
+				dragStartTime: 0,
+				shouldUseTimeDampening: !1,
+				scrollWindow: i,
+				scrollDroppable: i,
+				getAutoScrollerOptions: n
+			}), a = {
+				dragStartTime: t,
+				shouldUseTimeDampening: r
+			}, fn(), r && o(e);
+		},
+		stop: () => {
+			a &&= (r.cancel(), i.cancel(), null);
+		},
+		scroll: o
+	};
+}, mi = ({ move: e, scrollDroppable: t, scrollWindow: n }) => {
+	let r = (t, n) => {
+		e({ client: P(t.current.client.selection, n) });
+	}, i = (e, n) => {
+		if (!ci(e, n)) return n;
+		let r = li(e, n);
+		if (!r) return t(e.descriptor.id, n), null;
+		let i = F(n, r);
+		return t(e.descriptor.id, i), F(n, i);
+	}, a = (e, t, r) => {
+		if (!e || !oi(t, r)) return r;
+		let i = si(t, r);
+		if (!i) return n(r), null;
+		let a = F(r, i);
+		return n(a), F(r, a);
+	};
+	return (e) => {
+		let t = e.scrollJumpRequest;
+		if (!t) return;
+		let n = q(e.impact);
+		!n && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot perform a jump scroll when there is no destination"));
+		let o = i(e.dimensions.droppables[n], t);
+		if (!o) return;
+		let s = e.viewport, c = a(e.isWindowScrollAllowed, s, o);
+		c && r(e, c);
+	};
+}, hi = ({ scrollDroppable: e, scrollWindow: t, move: n, getAutoScrollerOptions: r }) => {
+	let i = pi({
+		scrollWindow: t,
+		scrollDroppable: e,
+		getAutoScrollerOptions: r
+	}), a = mi({
+		move: n,
+		scrollWindow: t,
+		scrollDroppable: e
+	});
+	return {
+		scroll: (e) => {
+			if (!(r().disabled || e.phase !== "DRAGGING")) {
+				if (e.movementMode === "FLUID") {
+					i.scroll(e);
+					return;
+				}
+				e.scrollJumpRequest && a(e);
+			}
+		},
+		start: i.start,
+		stop: i.stop
+	};
+}, Z = "data-rfd", Q = (() => {
+	let e = `${Z}-drag-handle`;
+	return {
+		base: e,
+		draggableId: `${e}-draggable-id`,
+		contextId: `${e}-context-id`
+	};
+})(), gi = (() => {
+	let e = `${Z}-draggable`;
+	return {
+		base: e,
+		contextId: `${e}-context-id`,
+		id: `${e}-id`
+	};
+})(), _i = (() => {
+	let e = `${Z}-droppable`;
+	return {
+		base: e,
+		contextId: `${e}-context-id`,
+		id: `${e}-id`
+	};
+})(), vi = { contextId: `${Z}-scroll-container-context-id` }, yi = (e) => (t) => `[${t}="${e}"]`, bi = (e, t) => e.map((e) => {
+	let n = e.styles[t];
+	return n ? `${e.selector} { ${n} }` : "";
+}).join(" "), xi = "pointer-events: none;", Si = (e) => {
+	let t = yi(e), n = (() => {
+		let e = "\n      cursor: -webkit-grab;\n      cursor: grab;\n    ";
+		return {
+			selector: t(Q.contextId),
+			styles: {
+				always: "\n          -webkit-touch-callout: none;\n          -webkit-tap-highlight-color: rgba(0,0,0,0);\n          touch-action: manipulation;\n        ",
+				resting: e,
+				dragging: xi,
+				dropAnimating: e
+			}
+		};
+	})(), r = [
+		(() => {
+			let e = `
+      transition: ${Xn.outOfTheWay};
+    `;
+			return {
+				selector: t(gi.contextId),
+				styles: {
+					dragging: e,
+					dropAnimating: e,
+					userCancel: e
+				}
+			};
+		})(),
+		n,
+		{
+			selector: t(_i.contextId),
+			styles: { always: "overflow-anchor: none;" }
+		},
+		{
+			selector: "body",
+			styles: { dragging: "\n        cursor: grabbing;\n        cursor: -webkit-grabbing;\n        user-select: none;\n        -webkit-user-select: none;\n        -moz-user-select: none;\n        -ms-user-select: none;\n        overflow-anchor: none;\n      " }
+		}
+	];
+	return {
+		always: bi(r, "always"),
+		resting: bi(r, "resting"),
+		dragging: bi(r, "dragging"),
+		dropAnimating: bi(r, "dropAnimating"),
+		userCancel: bi(r, "userCancel")
+	};
+}, $ = typeof window < "u" && window.document !== void 0 && window.document.createElement !== void 0 ? v : _, Ci = () => {
+	let e = document.querySelector("head");
+	return !e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot find the head to append a style to")), e;
+}, wi = (e) => {
+	let t = document.createElement("style");
+	return e && t.setAttribute("nonce", e), t.type = "text/css", t;
+};
+function Ti(e, t) {
+	let n = j(() => Si(e), [e]), r = y(null), i = y(null), a = M(B((e) => {
+		let t = i.current;
+		!t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot set dynamic style element if it is not set")), t.textContent = e;
+	}), []), o = M((e) => {
+		let t = r.current;
+		!t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot set dynamic style element if it is not set")), t.textContent = e;
+	}, []);
+	$(() => {
+		!(!r.current && !i.current) && (process.env.NODE_ENV === "production" ? A() : A(!1, "style elements already mounted"));
+		let s = wi(t), c = wi(t);
+		return r.current = s, i.current = c, s.setAttribute(`${Z}-always`, e), c.setAttribute(`${Z}-dynamic`, e), Ci().appendChild(s), Ci().appendChild(c), o(n.always), a(n.resting), () => {
+			let e = (e) => {
+				let t = e.current;
+				!t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot unmount ref as it is not set")), Ci().removeChild(t), e.current = null;
+			};
+			e(r), e(i);
+		};
+	}, [
+		t,
+		o,
+		a,
+		n.always,
+		n.resting,
+		e
+	]);
+	let s = M(() => a(n.dragging), [a, n.dragging]), c = M((e) => {
+		if (e === "DROP") {
+			a(n.dropAnimating);
+			return;
+		}
+		a(n.userCancel);
+	}, [
+		a,
+		n.dropAnimating,
+		n.userCancel
+	]), l = M(() => {
+		i.current && a(n.resting);
+	}, [a, n.resting]);
+	return j(() => ({
+		dragging: s,
+		dropping: c,
+		resting: l
+	}), [
+		s,
+		c,
+		l
+	]);
+}
+function Ei(e, t) {
+	return Array.from(e.querySelectorAll(t));
+}
+var Di = (e) => e && e.ownerDocument && e.ownerDocument.defaultView ? e.ownerDocument.defaultView : window;
+function Oi(e) {
+	return e instanceof Di(e).HTMLElement;
+}
+function ki(e, t) {
+	let n = `[${Q.contextId}="${e}"]`, r = Ei(document, n);
+	if (!r.length) return process.env.NODE_ENV !== "production" && D(`Unable to find any drag handles in the context "${e}"`), null;
+	let i = r.find((e) => e.getAttribute(Q.draggableId) === t);
+	return i ? Oi(i) ? i : (process.env.NODE_ENV !== "production" && D("drag handle needs to be a HTMLElement"), null) : (process.env.NODE_ENV !== "production" && D(`Unable to find drag handle with id "${t}" as no handle with a matching id was found`), null);
+}
+function Ai(e) {
+	let t = y({}), n = y(null), r = y(null), i = y(!1), a = M(function(e, n) {
+		let r = {
+			id: e,
+			focus: n
+		};
+		return t.current[e] = r, function() {
+			let n = t.current;
+			n[e] !== r && delete n[e];
+		};
+	}, []), o = M(function(t) {
+		let n = ki(e, t);
+		n && n !== document.activeElement && n.focus();
+	}, [e]), s = M(function(e, t) {
+		n.current === e && (n.current = t);
+	}, []), c = M(function() {
+		r.current || i.current && (r.current = requestAnimationFrame(() => {
+			r.current = null;
+			let e = n.current;
+			e && o(e);
+		}));
+	}, [o]), l = M(function(e) {
+		n.current = null;
+		let t = document.activeElement;
+		t && t.getAttribute(Q.draggableId) === e && (n.current = e);
+	}, []);
+	return $(() => (i.current = !0, function() {
+		i.current = !1;
+		let e = r.current;
+		e && cancelAnimationFrame(e);
+	}), []), j(() => ({
+		register: a,
+		tryRecordFocus: l,
+		tryRestoreFocusRecorded: c,
+		tryShiftRecord: s
+	}), [
+		a,
+		l,
+		c,
+		s
+	]);
+}
+function ji() {
+	let e = {
+		draggables: {},
+		droppables: {}
+	}, t = [];
+	function n(e) {
+		return t.push(e), function() {
+			let n = t.indexOf(e);
+			n !== -1 && t.splice(n, 1);
+		};
+	}
+	function r(e) {
+		t.length && t.forEach((t) => t(e));
+	}
+	function i(t) {
+		return e.draggables[t] || null;
+	}
+	function a(e) {
+		let t = i(e);
+		return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot find draggable entry with id [${e}]`)), t;
+	}
+	let o = {
+		register: (t) => {
+			e.draggables[t.descriptor.id] = t, r({
+				type: "ADDITION",
+				value: t
+			});
+		},
+		update: (t, n) => {
+			let r = e.draggables[n.descriptor.id];
+			r && r.uniqueId === t.uniqueId && (delete e.draggables[n.descriptor.id], e.draggables[t.descriptor.id] = t);
+		},
+		unregister: (t) => {
+			let n = t.descriptor.id, a = i(n);
+			a && t.uniqueId === a.uniqueId && (delete e.draggables[n], e.droppables[t.descriptor.droppableId] && r({
+				type: "REMOVAL",
+				value: t
+			}));
+		},
+		getById: a,
+		findById: i,
+		exists: (e) => !!i(e),
+		getAllByType: (t) => Object.values(e.draggables).filter((e) => e.descriptor.type === t)
+	};
+	function s(t) {
+		return e.droppables[t] || null;
+	}
+	function c(e) {
+		let t = s(e);
+		return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot find droppable entry with id [${e}]`)), t;
+	}
+	let l = {
+		register: (t) => {
+			e.droppables[t.descriptor.id] = t;
+		},
+		unregister: (t) => {
+			let n = s(t.descriptor.id);
+			n && t.uniqueId === n.uniqueId && delete e.droppables[t.descriptor.id];
+		},
+		getById: c,
+		findById: s,
+		exists: (e) => !!s(e),
+		getAllByType: (t) => Object.values(e.droppables).filter((e) => e.descriptor.type === t)
+	};
+	function u() {
+		e.draggables = {}, e.droppables = {}, t.length = 0;
+	}
+	return {
+		draggable: o,
+		droppable: l,
+		subscribe: n,
+		clean: u
+	};
+}
+function Mi() {
+	let e = j(ji, []);
+	return _(() => function() {
+		e.clean();
+	}, [e]), e;
+}
+var Ni = h.createContext(null), Pi = () => {
+	let e = document.body;
+	return !e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot find document.body")), e;
+}, Fi = {
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	border: "0",
+	padding: "0",
+	overflow: "hidden",
+	clip: "rect(0 0 0 0)",
+	"clip-path": "inset(100%)"
+}, Ii = (e) => `rfd-announcement-${e}`;
+function Li(e) {
+	let t = j(() => Ii(e), [e]), n = y(null);
+	return _(function() {
+		let e = document.createElement("div");
+		return n.current = e, e.id = t, e.setAttribute("aria-live", "assertive"), e.setAttribute("aria-atomic", "true"), m(e.style, Fi), Pi().appendChild(e), function() {
+			setTimeout(function() {
+				let t = Pi();
+				t.contains(e) && t.removeChild(e), e === n.current && (n.current = null);
+			});
+		};
+	}, [t]), M((e) => {
+		let t = n.current;
+		if (t) {
+			t.textContent = e;
+			return;
+		}
+		process.env.NODE_ENV !== "production" && D(`
+      A screen reader message was trying to be announced but it was unable to do so.
+      This can occur if you unmount your <DragDropContext /> in your onDragEnd.
+      Consider calling provided.announce() before the unmount so that the instruction will
+      not be lost for users relying on a screen reader.
+
+      Message not passed to screen reader:
+
+      "${e}"
+    `);
+	}, []);
+}
+var Ri = { separator: "::" };
+function zi(e, t = Ri) {
+	let n = h.useId();
+	return j(() => `${e}${t.separator}${n}`, [
+		t.separator,
+		e,
+		n
+	]);
+}
+function Bi({ contextId: e, uniqueId: t }) {
+	return `rfd-hidden-text-${e}-${t}`;
+}
+function Vi({ contextId: e, text: t }) {
+	let n = zi("hidden-text", { separator: "-" }), r = j(() => Bi({
+		contextId: e,
+		uniqueId: n
+	}), [n, e]);
+	return _(function() {
+		let e = document.createElement("div");
+		return e.id = r, e.textContent = t, e.style.display = "none", Pi().appendChild(e), function() {
+			let t = Pi();
+			t.contains(e) && t.removeChild(e);
+		};
+	}, [r, t]), r;
+}
+var Hi = h.createContext(null), Ui = { react: "^18.0.0 || ^19.0.0" }, Wi = /(\d+)\.(\d+)\.(\d+)/, Gi = (e) => {
+	let t = Wi.exec(e);
+	return t ?? (process.env.NODE_ENV === "production" ? A() : A(!1, `Unable to parse React version ${e}`)), {
+		major: Number(t[1]),
+		minor: Number(t[2]),
+		patch: Number(t[3]),
+		raw: e
+	};
+}, Ki = (e, t) => t.major > e.major ? !0 : t.major < e.major ? !1 : t.minor > e.minor ? !0 : t.minor < e.minor ? !1 : t.patch >= e.patch, qi = (e, t) => {
+	let n = Gi(e), r = Gi(t);
+	Ki(n, r) || process.env.NODE_ENV !== "production" && D(`
+    React version: [${r.raw}]
+    does not satisfy expected peer dependency version: [${n.raw}]
+
+    This can result in run time bugs, and even fatal crashes
+  `);
+}, Ji = "\n  We expect a html5 doctype: <!doctype html>\n  This is to ensure consistent browser layout and measurement\n\n  More information: https://github.com/hello-pangea/dnd/blob/main/docs/guides/doctype.md\n", Yi = (e) => {
+	let t = e.doctype;
+	if (!t) {
+		process.env.NODE_ENV !== "production" && D(`
+      No <!doctype html> found.
+
+      ${Ji}
+    `);
+		return;
+	}
+	t.name.toLowerCase() !== "html" && process.env.NODE_ENV !== "production" && D(`
+      Unexpected <!doctype> found: (${t.name})
+
+      ${Ji}
+    `), t.publicId !== "" && process.env.NODE_ENV !== "production" && D(`
+      Unexpected <!doctype> publicId found: (${t.publicId})
+      A html5 doctype does not have a publicId
+
+      ${Ji}
+    `);
+};
+function Xi(e) {
+	process.env.NODE_ENV !== "production" && e();
+}
+function Zi(e, t) {
+	Xi(() => {
+		_(() => {
+			try {
+				e();
+			} catch (e) {
+				ie(`
+          A setup problem was encountered.
+
+          > ${e.message}
+        `);
+			}
+		}, t);
+	});
+}
+function Qi() {
+	Zi(() => {
+		qi(Ui.react, h.version), Yi(document);
+	}, []);
+}
+function $i(e) {
+	let t = y(e);
+	return _(() => {
+		t.current = e;
+	}), t;
+}
+function ea() {
+	let e = null;
+	function t() {
+		return !!e;
+	}
+	function n(t) {
+		return t === e;
+	}
+	function r(t) {
+		e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot claim lock as it is already claimed"));
+		let n = { abandon: t };
+		return e = n, n;
+	}
+	function i() {
+		!e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot release lock when there is no lock")), e = null;
+	}
+	function a() {
+		e && (e.abandon(), i());
+	}
+	return {
+		isClaimed: t,
+		isActive: n,
+		claim: r,
+		release: i,
+		tryAbandon: a
+	};
+}
+function ta(e) {
+	return e.phase === "IDLE" || e.phase === "DROP_ANIMATING" ? !1 : e.isDragging;
+}
+var na = 9, ra = 13, ia = 27, aa = 32, oa = 33, sa = 34, ca = 35, la = 36, ua = 37, da = 38, fa = 39, pa = 40, ma = {
+	[ra]: !0,
+	[na]: !0
+}, ha = (e) => {
+	ma[e.keyCode] && e.preventDefault();
+}, ga = (() => {
+	let e = "visibilitychange";
+	return typeof document > "u" ? e : [
+		e,
+		`ms${e}`,
+		`webkit${e}`,
+		`moz${e}`,
+		`o${e}`
+	].find((e) => `on${e}` in document) || e;
+})(), _a = 0, va = 5;
+function ya(e, t) {
+	return Math.abs(t.x - e.x) >= va || Math.abs(t.y - e.y) >= va;
+}
+var ba = { type: "IDLE" };
+function xa({ cancel: e, completed: t, getPhase: n, setPhase: r }) {
+	return [
+		{
+			eventName: "mousemove",
+			fn: (e) => {
+				let { button: t, clientX: i, clientY: a } = e;
+				if (t !== _a) return;
+				let o = {
+					x: i,
+					y: a
+				}, s = n();
+				if (s.type === "DRAGGING") {
+					e.preventDefault(), s.actions.move(o);
+					return;
+				}
+				s.type !== "PENDING" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot be IDLE"));
+				let c = s.point;
+				ya(c, o) && (e.preventDefault(), r({
+					type: "DRAGGING",
+					actions: s.actions.fluidLift(o)
+				}));
+			}
+		},
+		{
+			eventName: "mouseup",
+			fn: (r) => {
+				let i = n();
+				if (i.type !== "DRAGGING") {
+					e();
+					return;
+				}
+				r.preventDefault(), i.actions.drop({ shouldBlockNextClick: !0 }), t();
+			}
+		},
+		{
+			eventName: "mousedown",
+			fn: (t) => {
+				n().type === "DRAGGING" && t.preventDefault(), e();
+			}
+		},
+		{
+			eventName: "keydown",
+			fn: (t) => {
+				if (n().type === "PENDING") {
+					e();
+					return;
+				}
+				if (t.keyCode === ia) {
+					t.preventDefault(), e();
+					return;
+				}
+				ha(t);
+			}
+		},
+		{
+			eventName: "resize",
+			fn: e
+		},
+		{
+			eventName: "scroll",
+			options: {
+				passive: !0,
+				capture: !1
+			},
+			fn: () => {
+				n().type === "PENDING" && e();
+			}
+		},
+		{
+			eventName: "webkitmouseforcedown",
+			fn: (t) => {
+				let r = n();
+				if (r.type === "IDLE" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Unexpected phase")), r.actions.shouldRespectForcePress()) {
+					e();
+					return;
+				}
+				t.preventDefault();
+			}
+		},
+		{
+			eventName: ga,
+			fn: e
+		}
+	];
+}
+function Sa(e) {
+	let t = y(ba), n = y(O), r = j(() => ({
+		eventName: "mousedown",
+		fn: function(t) {
+			if (t.defaultPrevented || t.button !== _a || t.ctrlKey || t.metaKey || t.shiftKey || t.altKey) return;
+			let r = e.findClosestDraggableId(t);
+			if (!r) return;
+			let i = e.tryGetLock(r, o, { sourceEvent: t });
+			if (!i) return;
+			t.preventDefault();
+			let a = {
+				x: t.clientX,
+				y: t.clientY
+			};
+			n.current(), l(i, a);
+		}
+	}), [e]), i = j(() => ({
+		eventName: "webkitmouseforcewillbegin",
+		fn: (t) => {
+			if (t.defaultPrevented) return;
+			let n = e.findClosestDraggableId(t);
+			if (!n) return;
+			let r = e.findOptionsForDraggable(n);
+			r && (r.shouldRespectForcePress || e.canGetLock(n) && t.preventDefault());
+		}
+	}), [e]), a = M(function() {
+		n.current = k(window, [i, r], {
+			passive: !1,
+			capture: !0
+		});
+	}, [i, r]), o = M(() => {
+		t.current.type !== "IDLE" && (t.current = ba, n.current(), a());
+	}, [a]), s = M(() => {
+		let e = t.current;
+		o(), e.type === "DRAGGING" && e.actions.cancel({ shouldBlockNextClick: !0 }), e.type === "PENDING" && e.actions.abort();
+	}, [o]), c = M(function() {
+		let e = {
+			capture: !0,
+			passive: !1
+		}, r = xa({
+			cancel: s,
+			completed: o,
+			getPhase: () => t.current,
+			setPhase: (e) => {
+				t.current = e;
+			}
+		});
+		n.current = k(window, r, e);
+	}, [s, o]), l = M(function(e, n) {
+		t.current.type !== "IDLE" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected to move from IDLE to PENDING drag")), t.current = {
+			type: "PENDING",
+			point: n,
+			actions: e
+		}, c();
+	}, [c]);
+	$(function() {
+		return a(), function() {
+			n.current();
+		};
+	}, [a]);
+}
+function Ca() {}
+var wa = {
+	[sa]: !0,
+	[oa]: !0,
+	[la]: !0,
+	[ca]: !0
+};
+function Ta(e, t) {
+	function n() {
+		t(), e.cancel();
+	}
+	function r() {
+		t(), e.drop();
+	}
+	return [
+		{
+			eventName: "keydown",
+			fn: (t) => {
+				if (t.keyCode === ia) {
+					t.preventDefault(), n();
+					return;
+				}
+				if (t.keyCode === aa) {
+					t.preventDefault(), r();
+					return;
+				}
+				if (t.keyCode === pa) {
+					t.preventDefault(), e.moveDown();
+					return;
+				}
+				if (t.keyCode === da) {
+					t.preventDefault(), e.moveUp();
+					return;
+				}
+				if (t.keyCode === fa) {
+					t.preventDefault(), e.moveRight();
+					return;
+				}
+				if (t.keyCode === ua) {
+					t.preventDefault(), e.moveLeft();
+					return;
+				}
+				if (wa[t.keyCode]) {
+					t.preventDefault();
+					return;
+				}
+				ha(t);
+			}
+		},
+		{
+			eventName: "mousedown",
+			fn: n
+		},
+		{
+			eventName: "mouseup",
+			fn: n
+		},
+		{
+			eventName: "click",
+			fn: n
+		},
+		{
+			eventName: "touchstart",
+			fn: n
+		},
+		{
+			eventName: "resize",
+			fn: n
+		},
+		{
+			eventName: "wheel",
+			fn: n,
+			options: { passive: !0 }
+		},
+		{
+			eventName: ga,
+			fn: n
+		}
+	];
+}
+function Ea(e) {
+	let t = y(Ca), n = j(() => ({
+		eventName: "keydown",
+		fn: function(n) {
+			if (n.defaultPrevented || n.keyCode !== aa) return;
+			let i = e.findClosestDraggableId(n);
+			if (!i) return;
+			let a = e.tryGetLock(i, c, { sourceEvent: n });
+			if (!a) return;
+			n.preventDefault();
+			let o = !0, s = a.snapLift();
+			t.current();
+			function c() {
+				!o && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot stop capturing a keyboard drag when not capturing")), o = !1, t.current(), r();
+			}
+			t.current = k(window, Ta(s, c), {
+				capture: !0,
+				passive: !1
+			});
+		}
+	}), [e]), r = M(function() {
+		t.current = k(window, [n], {
+			passive: !1,
+			capture: !0
+		});
+	}, [n]);
+	$(function() {
+		return r(), function() {
+			t.current();
+		};
+	}, [r]);
+}
+var Da = { type: "IDLE" }, Oa = 120, ka = .15;
+function Aa({ cancel: e, getPhase: t }) {
+	return [
+		{
+			eventName: "orientationchange",
+			fn: e
+		},
+		{
+			eventName: "resize",
+			fn: e
+		},
+		{
+			eventName: "contextmenu",
+			fn: (e) => {
+				e.preventDefault();
+			}
+		},
+		{
+			eventName: "keydown",
+			fn: (n) => {
+				if (t().type !== "DRAGGING") {
+					e();
+					return;
+				}
+				n.keyCode === ia && n.preventDefault(), e();
+			}
+		},
+		{
+			eventName: ga,
+			fn: e
+		}
+	];
+}
+function ja({ cancel: e, completed: t, getPhase: n }) {
+	return [
+		{
+			eventName: "touchmove",
+			options: { capture: !1 },
+			fn: (t) => {
+				let r = n();
+				if (r.type !== "DRAGGING") {
+					e();
+					return;
+				}
+				r.hasMoved = !0;
+				let { clientX: i, clientY: a } = t.touches[0], o = {
+					x: i,
+					y: a
+				};
+				t.preventDefault(), r.actions.move(o);
+			}
+		},
+		{
+			eventName: "touchend",
+			fn: (r) => {
+				let i = n();
+				if (i.type !== "DRAGGING") {
+					e();
+					return;
+				}
+				r.preventDefault(), i.actions.drop({ shouldBlockNextClick: !0 }), t();
+			}
+		},
+		{
+			eventName: "touchcancel",
+			fn: (t) => {
+				if (n().type !== "DRAGGING") {
+					e();
+					return;
+				}
+				t.preventDefault(), e();
+			}
+		},
+		{
+			eventName: "touchforcechange",
+			fn: (t) => {
+				let r = n();
+				r.type === "IDLE" && (process.env.NODE_ENV, A());
+				let i = t.touches[0];
+				if (!i || !(i.force >= ka)) return;
+				let a = r.actions.shouldRespectForcePress();
+				if (r.type === "PENDING") {
+					a && e();
+					return;
+				}
+				if (a) {
+					if (r.hasMoved) {
+						t.preventDefault();
+						return;
+					}
+					e();
+					return;
+				}
+				t.preventDefault();
+			}
+		},
+		{
+			eventName: ga,
+			fn: e
+		}
+	];
+}
+function Ma(e) {
+	let t = y(Da), n = y(O), r = M(function() {
+		return t.current;
+	}, []), i = M(function(e) {
+		t.current = e;
+	}, []), a = j(() => ({
+		eventName: "touchstart",
+		fn: function(t) {
+			if (t.defaultPrevented) return;
+			let r = e.findClosestDraggableId(t);
+			if (!r) return;
+			let i = e.tryGetLock(r, s, { sourceEvent: t });
+			if (!i) return;
+			let { clientX: a, clientY: o } = t.touches[0], c = {
+				x: a,
+				y: o
+			};
+			n.current(), d(i, c);
+		}
+	}), [e]), o = M(function() {
+		n.current = k(window, [a], {
+			capture: !0,
+			passive: !1
+		});
+	}, [a]), s = M(() => {
+		let e = t.current;
+		e.type !== "IDLE" && (e.type === "PENDING" && clearTimeout(e.longPressTimerId), i(Da), n.current(), o());
+	}, [o, i]), c = M(() => {
+		let e = t.current;
+		s(), e.type === "DRAGGING" && e.actions.cancel({ shouldBlockNextClick: !0 }), e.type === "PENDING" && e.actions.abort();
+	}, [s]), l = M(function() {
+		let e = {
+			capture: !0,
+			passive: !1
+		}, t = {
+			cancel: c,
+			completed: s,
+			getPhase: r
+		}, i = k(window, ja(t), e), a = k(window, Aa(t), e);
+		n.current = function() {
+			i(), a();
+		};
+	}, [
+		c,
+		r,
+		s
+	]), u = M(function() {
+		let e = r();
+		e.type !== "PENDING" && (process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot start dragging from phase ${e.type}`)), i({
+			type: "DRAGGING",
+			actions: e.actions.fluidLift(e.point),
+			hasMoved: !1
+		});
+	}, [r, i]), d = M(function(e, t) {
+		r().type !== "IDLE" && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected to move from IDLE to PENDING drag")), i({
+			type: "PENDING",
+			point: t,
+			actions: e,
+			longPressTimerId: setTimeout(u, Oa)
+		}), l();
+	}, [
+		l,
+		r,
+		i,
+		u
+	]);
+	$(function() {
+		return o(), function() {
+			n.current();
+			let e = r();
+			e.type === "PENDING" && (clearTimeout(e.longPressTimerId), i(Da));
+		};
+	}, [
+		r,
+		o,
+		i
+	]), $(function() {
+		return k(window, [{
+			eventName: "touchmove",
+			fn: () => {},
+			options: {
+				capture: !1,
+				passive: !1
+			}
+		}]);
+	}, []);
+}
+function Na(e) {
+	Xi(() => {
+		let t = $i(e);
+		Zi(() => {
+			t.current.length !== e.length && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, "Cannot change the amount of sensor hooks after mounting"));
+		});
+	});
+}
+var Pa = [
+	"input",
+	"button",
+	"textarea",
+	"select",
+	"option",
+	"optgroup",
+	"video",
+	"audio"
+];
+function Fa(e, t) {
+	if (t == null) return !1;
+	if (Pa.includes(t.tagName.toLowerCase())) return !0;
+	let n = t.getAttribute("contenteditable");
+	return n === "true" || n === "" ? !0 : t === e ? !1 : Fa(e, t.parentElement);
+}
+function Ia(e, t) {
+	let n = t.target;
+	return Oi(n) ? Fa(e, n) : !1;
+}
+var La = (e) => u(e.getBoundingClientRect()).center;
+function Ra(e) {
+	return e instanceof Di(e).Element;
+}
+var za = (() => {
+	let e = "matches";
+	return typeof document > "u" ? e : [
+		e,
+		"msMatchesSelector",
+		"webkitMatchesSelector"
+	].find((e) => e in Element.prototype) || e;
+})();
+function Ba(e, t) {
+	return e == null ? null : e[za](t) ? e : Ba(e.parentElement, t);
+}
+function Va(e, t) {
+	return e.closest ? e.closest(t) : Ba(e, t);
+}
+function Ha(e) {
+	return `[${Q.contextId}="${e}"]`;
+}
+function Ua(e, t) {
+	let n = t.target;
+	if (!Ra(n)) return process.env.NODE_ENV !== "production" && D("event.target must be a Element"), null;
+	let r = Va(n, Ha(e));
+	return r ? Oi(r) ? r : (process.env.NODE_ENV !== "production" && D("drag handle must be a HTMLElement"), null) : null;
+}
+function Wa(e, t) {
+	let n = Ua(e, t);
+	return n ? n.getAttribute(Q.draggableId) : null;
+}
+function Ga(e, t) {
+	let n = `[${gi.contextId}="${e}"]`, r = Ei(document, n).find((e) => e.getAttribute(gi.id) === t);
+	return r ? Oi(r) ? r : (process.env.NODE_ENV !== "production" && D("Draggable element is not a HTMLElement"), null) : null;
+}
+function Ka(e) {
+	e.preventDefault();
+}
+function qa({ expected: e, phase: t, isLockActive: n, shouldWarn: r }) {
+	return n() ? e === t ? !0 : (r && process.env.NODE_ENV !== "production" && D(`
+        Cannot perform action.
+        The actions you used belong to an outdated phase
+
+        Current phase: ${e}
+        You called an action from outdated phase: ${t}
+
+        Tips:
+
+        - Do not use preDragActions actions after calling preDragActions.lift()
+      `), !1) : (r && process.env.NODE_ENV !== "production" && D("\n        Cannot perform action.\n        The sensor no longer has an action lock.\n\n        Tips:\n\n        - Throw away your action handlers when forceStop() is called\n        - Check actions.isActive() if you really need to\n      "), !1);
+}
+function Ja({ lockAPI: e, store: t, registry: n, draggableId: r }) {
+	if (e.isClaimed()) return !1;
+	let i = n.draggable.findById(r);
+	return i ? !(!i.options.isEnabled || !Vr(t.getState(), r)) : (process.env.NODE_ENV !== "production" && D(`Unable to find draggable with id: ${r}`), !1);
+}
+function Ya({ lockAPI: e, contextId: t, store: n, registry: r, draggableId: i, forceSensorStop: a, sourceEvent: o }) {
+	if (!Ja({
+		lockAPI: e,
+		store: n,
+		registry: r,
+		draggableId: i
+	})) return null;
+	let s = r.draggable.getById(i), c = Ga(t, s.descriptor.id);
+	if (!c) return process.env.NODE_ENV !== "production" && D(`Unable to find draggable element with id: ${i}`), null;
+	if (o && !s.options.canDragInteractiveElements && Ia(c, o)) return null;
+	let l = e.claim(a || O), u = "PRE_DRAG";
+	function d() {
+		return s.options.shouldRespectForcePress;
+	}
+	function f() {
+		return e.isActive(l);
+	}
+	function m(e, t) {
+		qa({
+			expected: e,
+			phase: u,
+			isLockActive: f,
+			shouldWarn: !0
+		}) && n.dispatch(t());
+	}
+	let h = m.bind(null, "DRAGGING");
+	function g(t) {
+		function r() {
+			e.release(), u = "COMPLETED";
+		}
+		u !== "PRE_DRAG" && (r(), process.env.NODE_ENV === "production" ? A() : A(!1, `Cannot lift in phase ${u}`)), n.dispatch(Cn(t.liftActionArgs)), u = "DRAGGING";
+		function i(e, i = { shouldBlockNextClick: !1 }) {
+			if (t.cleanup(), i.shouldBlockNextClick) {
+				let e = k(window, [{
+					eventName: "click",
+					fn: Ka,
+					options: {
+						once: !0,
+						passive: !1,
+						capture: !0
+					}
+				}]);
+				setTimeout(e);
+			}
+			r(), n.dispatch(Bn({ reason: e }));
+		}
+		return {
+			isActive: () => qa({
+				expected: "DRAGGING",
+				phase: u,
+				isLockActive: f,
+				shouldWarn: !1
+			}),
+			shouldRespectForcePress: d,
+			drop: (e) => i("DROP", e),
+			cancel: (e) => i("CANCEL", e),
+			...t.actions
+		};
+	}
+	function _(e) {
+		let t = p((e) => {
+			h(() => An({ client: e }));
+		});
+		return {
+			...g({
+				liftActionArgs: {
+					id: i,
+					clientSelection: e,
+					movementMode: "FLUID"
+				},
+				cleanup: () => t.cancel(),
+				actions: { move: t }
+			}),
+			move: t
+		};
+	}
+	function v() {
+		return g({
+			liftActionArgs: {
+				id: i,
+				clientSelection: La(c),
+				movementMode: "SNAP"
+			},
+			cleanup: O,
+			actions: {
+				moveUp: () => h(Nn),
+				moveRight: () => h(Fn),
+				moveDown: () => h(Pn),
+				moveLeft: () => h(In)
+			}
+		});
+	}
+	function y() {
+		qa({
+			expected: "PRE_DRAG",
+			phase: u,
+			isLockActive: f,
+			shouldWarn: !0
+		}) && e.release();
+	}
+	return {
+		isActive: () => qa({
+			expected: "PRE_DRAG",
+			phase: u,
+			isLockActive: f,
+			shouldWarn: !1
+		}),
+		shouldRespectForcePress: d,
+		fluidLift: _,
+		snapLift: v,
+		abort: y
+	};
+}
+var Xa = [
+	Sa,
+	Ea,
+	Ma
+];
+function Za({ contextId: e, store: t, registry: n, customSensors: r, enableDefaultSensors: i }) {
+	let a = [...i ? Xa : [], ...r || []], o = b(() => ea())[0], s = M(function(e, t) {
+		ta(e) && !ta(t) && o.tryAbandon();
+	}, [o]);
+	$(function() {
+		let e = t.getState();
+		return t.subscribe(() => {
+			let n = t.getState();
+			s(e, n), e = n;
+		});
+	}, [
+		o,
+		t,
+		s
+	]), $(() => o.tryAbandon, [o.tryAbandon]);
+	let c = M((e) => Ja({
+		lockAPI: o,
+		registry: n,
+		store: t,
+		draggableId: e
+	}), [
+		o,
+		n,
+		t
+	]), l = M((r, i, a) => Ya({
+		lockAPI: o,
+		registry: n,
+		contextId: e,
+		store: t,
+		draggableId: r,
+		forceSensorStop: i || null,
+		sourceEvent: a && a.sourceEvent ? a.sourceEvent : null
+	}), [
+		e,
+		o,
+		n,
+		t
+	]), u = M((t) => Wa(e, t), [e]), d = M((e) => {
+		let t = n.draggable.findById(e);
+		return t ? t.options : null;
+	}, [n.draggable]), f = M(function() {
+		o.isClaimed() && (o.tryAbandon(), t.getState().phase !== "IDLE" && t.dispatch(Ln()));
+	}, [o, t]), p = M(() => o.isClaimed(), [o]), m = j(() => ({
+		canGetLock: c,
+		tryGetLock: l,
+		findClosestDraggableId: u,
+		findOptionsForDraggable: d,
+		tryReleaseLock: f,
+		isLockClaimed: p
+	}), [
+		c,
+		l,
+		u,
+		d,
+		f,
+		p
+	]);
+	Na(a);
+	for (let e = 0; e < a.length; e++) a[e](m);
+}
+var Qa = (e) => ({
+	onBeforeCapture: (t) => {
+		S(() => {
+			e.onBeforeCapture && e.onBeforeCapture(t);
+		});
+	},
+	onBeforeDragStart: e.onBeforeDragStart,
+	onDragStart: e.onDragStart,
+	onDragEnd: e.onDragEnd,
+	onDragUpdate: e.onDragUpdate
+}), $a = (e) => ({
+	...Kr,
+	...e.autoScrollerOptions,
+	durationDampening: {
+		...Kr.durationDampening,
+		...e.autoScrollerOptions
+	}
+});
+function eo(e) {
+	return !e.current && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find store from lazy ref")), e.current;
+}
+function to(e) {
+	let { contextId: n, setCallbacks: r, sensors: a, nonce: o, dragHandleUsageInstructions: s } = e, c = y(null);
+	Qi();
+	let l = $i(e), u = M(() => Qa(l.current), [l]), d = M(() => $a(l.current), [l]), f = Li(n), p = Vi({
+		contextId: n,
+		text: s
+	}), m = Ti(n, o), g = M((e) => {
+		eo(c).dispatch(e);
+	}, []), v = j(() => t({
+		publishWhileDragging: Tn,
+		updateDroppableScroll: Dn,
+		updateDroppableIsEnabled: On,
+		updateDroppableIsCombineEnabled: kn,
+		collectionStarting: En
+	}, g), [g]), b = Mi(), x = j(() => Br(b, v), [b, v]), S = j(() => hi({
+		scrollWindow: Hr,
+		scrollDroppable: x.scrollDroppable,
+		getAutoScrollerOptions: d,
+		...t({ move: An }, g)
+	}), [
+		x.scrollDroppable,
+		g,
+		d
+	]), C = Ai(n), w = j(() => jr({
+		announce: f,
+		autoScroller: S,
+		dimensionMarshal: x,
+		focusMarshal: C,
+		getResponders: u,
+		styleMarshal: m
+	}), [
+		f,
+		S,
+		x,
+		C,
+		u,
+		m
+	]);
+	process.env.NODE_ENV !== "production" && c.current && c.current !== w && process.env.NODE_ENV !== "production" && D("unexpected store change"), c.current = w;
+	let T = M(() => {
+		let e = eo(c);
+		e.getState().phase !== "IDLE" && e.dispatch(Ln());
+	}, []), E = M(() => {
+		let e = eo(c).getState();
+		return e.phase === "DROP_ANIMATING" ? !0 : e.phase === "IDLE" ? !1 : e.isDragging;
+	}, []);
+	r(j(() => ({
+		isDragging: E,
+		tryAbort: T
+	}), [E, T]));
+	let ee = M((e) => Vr(eo(c).getState(), e), []), te = M(() => J(eo(c).getState()), []), ne = j(() => ({
+		marshal: x,
+		focus: C,
+		contextId: n,
+		canLift: ee,
+		isMovementAllowed: te,
+		dragHandleUsageInstructionsId: p,
+		registry: b
+	}), [
+		n,
+		x,
+		p,
+		C,
+		ee,
+		te,
+		b
+	]);
+	return Za({
+		contextId: n,
+		store: w,
+		registry: b,
+		customSensors: a || null,
+		enableDefaultSensors: e.enableDefaultSensors !== !1
+	}), _(() => T, [T]), h.createElement(Hi.Provider, { value: ne }, h.createElement(i, {
+		context: Ni,
+		store: w
+	}, e.children));
+}
+function no() {
+	return h.useId();
+}
+function ro(e) {
+	let t = no(), n = e.dragHandleUsageInstructions || _e.dragHandleUsageInstructions;
+	return h.createElement(le, null, (r) => h.createElement(to, {
+		nonce: e.nonce,
+		contextId: t,
+		setCallbacks: r,
+		dragHandleUsageInstructions: n,
+		enableDefaultSensors: e.enableDefaultSensors,
+		sensors: e.sensors,
+		onBeforeCapture: e.onBeforeCapture,
+		onBeforeDragStart: e.onBeforeDragStart,
+		onDragStart: e.onDragStart,
+		onDragUpdate: e.onDragUpdate,
+		onDragEnd: e.onDragEnd,
+		autoScrollerOptions: e.autoScrollerOptions
+	}, e.children));
+}
+var io = {
+	dragging: 5e3,
+	dropAnimating: 4500
+}, ao = (e, t) => t ? Xn.drop(t.duration) : e ? Xn.snap : Xn.fluid, oo = (e, t) => {
+	if (e) return t ? Jn.opacity.drop : Jn.opacity.combining;
+}, so = (e) => e.forceShouldAnimate == null ? e.mode === "SNAP" : e.forceShouldAnimate;
+function co(e) {
+	let t = e.dimension.client, { offset: n, combineWith: r, dropping: i } = e, a = !!r, o = so(e), s = !!i, c = s ? Qn.drop(n, a) : Qn.moveTo(n);
+	return {
+		position: "fixed",
+		top: t.marginBox.top,
+		left: t.marginBox.left,
+		boxSizing: "border-box",
+		width: t.borderBox.width,
+		height: t.borderBox.height,
+		transition: ao(o, i),
+		transform: c,
+		opacity: oo(a, s),
+		zIndex: s ? io.dropAnimating : io.dragging,
+		pointerEvents: "none"
+	};
+}
+function lo(e) {
+	return {
+		transform: Qn.moveTo(e.offset),
+		transition: e.shouldAnimateDisplacement ? void 0 : "none"
+	};
+}
+function uo(e) {
+	return e.type === "DRAGGING" ? co(e) : lo(e);
+}
+function fo(e, t, n = N) {
+	let r = window.getComputedStyle(t), i = o(t.getBoundingClientRect(), r), a = f(i, n);
+	return {
+		descriptor: e,
+		placeholder: {
+			client: i,
+			tagName: t.tagName.toLowerCase(),
+			display: r.display
+		},
+		displaceBy: {
+			x: i.marginBox.width,
+			y: i.marginBox.height
+		},
+		client: i,
+		page: a
+	};
+}
+function po(e) {
+	let t = zi("draggable"), { descriptor: n, registry: r, getDraggableRef: i, canDragInteractiveElements: a, shouldRespectForcePress: o, isEnabled: s } = e, c = j(() => ({
+		canDragInteractiveElements: a,
+		shouldRespectForcePress: o,
+		isEnabled: s
+	}), [
+		a,
+		s,
+		o
+	]), l = M((e) => {
+		let t = i();
+		return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot get dimension when no ref is set")), fo(n, t, e);
+	}, [n, i]), u = j(() => ({
+		uniqueId: t,
+		descriptor: n,
+		options: c,
+		getDimension: l
+	}), [
+		n,
+		l,
+		c,
+		t
+	]), d = y(u), f = y(!0);
+	$(() => (r.draggable.register(d.current), () => r.draggable.unregister(d.current)), [r.draggable]), $(() => {
+		if (f.current) {
+			f.current = !1;
+			return;
+		}
+		let e = d.current;
+		d.current = u, r.draggable.update(u, e);
+	}, [u, r.draggable]);
+}
+var mo = h.createContext(null);
+function ho(e) {
+	!(e && Oi(e)) && (process.env.NODE_ENV === "production" ? A() : A(!1, "\n    provided.innerRef has not been provided with a HTMLElement.\n\n    You can find a guide on using the innerRef callback functions at:\n    https://github.com/hello-pangea/dnd/blob/main/docs/guides/using-inner-ref.md\n  "));
+}
+function go(e, t, n) {
+	Zi(() => {
+		function r(e) {
+			return `Draggable[id: ${e}]: `;
+		}
+		let i = e.draggableId;
+		!i && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, "Draggable requires a draggableId")), typeof i != "string" && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, `Draggable requires a [string] draggableId.
+      Provided: [type: ${typeof i}] (value: ${i})`)), !Number.isInteger(e.index) && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, `${r(i)} requires an integer index prop`)), e.mapped.type !== "DRAGGING" && (ho(n()), e.isEnabled && !ki(t, i) && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, `${r(i)} Unable to find drag handle`)));
+	});
+}
+function _o(e) {
+	Xi(() => {
+		let t = y(e);
+		Zi(() => {
+			e !== t.current && (process.env.NODE_ENV === "production" ? A(!1) : A(!1, "Draggable isClone prop value changed during component life"));
+		}, [e]);
+	});
+}
+function vo(e) {
+	let t = g(e);
+	return !t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find required context")), t;
+}
+function yo(e) {
+	e.preventDefault();
+}
+var bo = (e) => {
+	let t = y(null), n = M((e = null) => {
+		t.current = e;
+	}, []), r = M(() => t.current, []), { contextId: i, dragHandleUsageInstructionsId: a, registry: o } = vo(Hi), { type: s, droppableId: c } = vo(mo), l = j(() => ({
+		id: e.draggableId,
+		index: e.index,
+		type: s,
+		droppableId: c
+	}), [
+		e.draggableId,
+		e.index,
+		s,
+		c
+	]), { children: u, draggableId: d, isEnabled: f, shouldRespectForcePress: p, canDragInteractiveElements: m, isClone: g, mapped: _, dropAnimationFinished: v } = e;
+	go(e, i, r), _o(g), g || po(j(() => ({
+		descriptor: l,
+		registry: o,
+		getDraggableRef: r,
+		canDragInteractiveElements: m,
+		shouldRespectForcePress: p,
+		isEnabled: f
+	}), [
+		l,
+		o,
+		r,
+		m,
+		p,
+		f
+	]));
+	let b = j(() => f ? {
+		tabIndex: 0,
+		role: "button",
+		"aria-describedby": a,
+		"data-rfd-drag-handle-draggable-id": d,
+		"data-rfd-drag-handle-context-id": i,
+		draggable: !1,
+		onDragStart: yo
+	} : null, [
+		i,
+		a,
+		d,
+		f
+	]), x = M((e) => {
+		_.type === "DRAGGING" && _.dropping && e.propertyName === "transform" && S(v);
+	}, [v, _]), C = j(() => ({
+		innerRef: n,
+		draggableProps: {
+			"data-rfd-draggable-context-id": i,
+			"data-rfd-draggable-id": d,
+			style: uo(_),
+			onTransitionEnd: _.type === "DRAGGING" && _.dropping ? x : void 0
+		},
+		dragHandleProps: b
+	}), [
+		i,
+		b,
+		d,
+		_,
+		x,
+		n
+	]), w = j(() => ({
+		draggableId: l.id,
+		type: l.type,
+		source: {
+			index: l.index,
+			droppableId: l.droppableId
+		}
+	}), [
+		l.droppableId,
+		l.id,
+		l.index,
+		l.type
+	]);
+	return h.createElement(h.Fragment, null, u(C, _.snapshot, w));
+}, xo = (e, t) => e === t, So = (e) => {
+	let { combine: t, destination: n } = e;
+	return n ? n.droppableId : t ? t.droppableId : null;
+}, Co = (e) => e.combine ? e.combine.draggableId : null, wo = (e) => e.at && e.at.type === "COMBINE" ? e.at.combine.draggableId : null;
+function To() {
+	let e = B((e, t) => ({
+		x: e,
+		y: t
+	})), t = B((e, t, n = null, r = null, i = null) => ({
+		isDragging: !0,
+		isClone: t,
+		isDropAnimating: !!i,
+		dropAnimation: i,
+		mode: e,
+		draggingOver: n,
+		combineWith: r,
+		combineTargetFor: null
+	})), n = B((e, n, r, i, a = null, o = null, s = null) => ({ mapped: {
+		type: "DRAGGING",
+		dropping: null,
+		draggingOver: a,
+		combineWith: o,
+		mode: n,
+		offset: e,
+		dimension: r,
+		forceShouldAnimate: s,
+		snapshot: t(n, i, a, o, null)
+	} }));
+	return (r, i) => {
+		if (ta(r)) {
+			if (r.critical.draggable.id !== i.draggableId) return null;
+			let t = r.current.client.offset, a = r.dimensions.draggables[i.draggableId], o = q(r.impact), s = wo(r.impact), c = r.forceShouldAnimate;
+			return n(e(t.x, t.y), r.movementMode, a, i.isClone, o, s, c);
+		}
+		if (r.phase === "DROP_ANIMATING") {
+			let e = r.completed;
+			if (e.result.draggableId !== i.draggableId) return null;
+			let n = i.isClone, a = r.dimensions.draggables[i.draggableId], o = e.result, s = o.mode, c = So(o), l = Co(o), u = {
+				duration: r.dropDuration,
+				curve: qn.drop,
+				moveTo: r.newHomeClientOffset,
+				opacity: l ? Jn.opacity.drop : null,
+				scale: l ? Jn.scale.drop : null
+			};
+			return { mapped: {
+				type: "DRAGGING",
+				offset: r.newHomeClientOffset,
+				dimension: a,
+				dropping: u,
+				draggingOver: c,
+				combineWith: l,
+				mode: s,
+				forceShouldAnimate: null,
+				snapshot: t(s, n, c, l, u)
+			} };
+		}
+		return null;
+	};
+}
+function Eo(e = null) {
+	return {
+		isDragging: !1,
+		isDropAnimating: !1,
+		isClone: !1,
+		dropAnimation: null,
+		mode: null,
+		draggingOver: null,
+		combineTargetFor: e,
+		combineWith: null
+	};
+}
+var Do = { mapped: {
+	type: "SECONDARY",
+	offset: N,
+	combineTargetFor: null,
+	shouldAnimateDisplacement: !0,
+	snapshot: Eo(null)
+} };
+function Oo() {
+	let e = B((e, t) => ({
+		x: e,
+		y: t
+	})), t = B(Eo), n = B((e, n = null, r) => ({ mapped: {
+		type: "SECONDARY",
+		offset: e,
+		combineTargetFor: n,
+		shouldAnimateDisplacement: r,
+		snapshot: t(n)
+	} })), r = (e) => e ? n(N, e, !0) : null, i = (t, i, a, o) => {
+		let s = a.displaced.visible[t], c = !!(o.inVirtualList && o.effected[t]), l = Ie(a), u = l && l.draggableId === t ? i : null;
+		if (!s) {
+			if (!c) return r(u);
+			if (a.displaced.invisible[t]) return null;
+			let i = L(o.displacedBy.point);
+			return n(e(i.x, i.y), u, !0);
+		}
+		if (c) return r(u);
+		let d = a.displacedBy.point;
+		return n(e(d.x, d.y), u, s.shouldAnimate);
+	};
+	return (e, t) => {
+		if (ta(e)) return e.critical.draggable.id === t.draggableId ? null : i(t.draggableId, e.critical.draggable.id, e.impact, e.afterCritical);
+		if (e.phase === "DROP_ANIMATING") {
+			let n = e.completed;
+			return n.result.draggableId === t.draggableId ? null : i(t.draggableId, n.result.draggableId, n.impact, n.afterCritical);
+		}
+		return null;
+	};
+}
+var ko = a(() => {
+	let e = To(), t = Oo();
+	return (n, r) => e(n, r) || t(n, r) || Do;
+}, { dropAnimationFinished: Hn }, null, {
+	context: Ni,
+	areStatePropsEqual: xo
+})(bo);
+function Ao(e) {
+	return vo(mo).isUsingCloneFor === e.draggableId && !e.isClone ? null : h.createElement(ko, e);
+}
+function jo(e) {
+	let t = typeof e.isDragDisabled == "boolean" ? !e.isDragDisabled : !0, n = !!e.disableInteractiveElementBlocking, r = !!e.shouldRespectForcePress;
+	return h.createElement(Ao, m({}, e, {
+		isClone: !1,
+		isEnabled: t,
+		canDragInteractiveElements: n,
+		shouldRespectForcePress: r
+	}));
+}
+var Mo = (e) => (t) => e === t, No = Mo("scroll"), Po = Mo("auto"), Fo = Mo("visible"), Io = (e, t) => t(e.overflowX) || t(e.overflowY), Lo = (e, t) => t(e.overflowX) && t(e.overflowY), Ro = (e) => {
+	let t = window.getComputedStyle(e), n = {
+		overflowX: t.overflowX,
+		overflowY: t.overflowY
+	};
+	return Io(n, No) || Io(n, Po);
+}, zo = () => {
+	if (process.env.NODE_ENV === "production") return !1;
+	let e = Pi(), t = document.documentElement;
+	if (!t && (process.env.NODE_ENV, A()), !Ro(e)) return !1;
+	let n = window.getComputedStyle(t);
+	return Lo({
+		overflowX: n.overflowX,
+		overflowY: n.overflowY
+	}, Fo) || process.env.NODE_ENV !== "production" && D("\n    We have detected that your <body> element might be a scroll container.\n    We have found no reliable way of detecting whether the <body> element is a scroll container.\n    Under most circumstances a <body> scroll bar will be on the <html> element (document.documentElement)\n\n    Because we cannot determine if the <body> is a scroll container, and generally it is not one,\n    we will be treating the <body> as *not* a scroll container\n\n    More information: https://github.com/hello-pangea/dnd/blob/main/docs/guides/how-we-detect-scroll-containers.md\n  "), !1;
+}, Bo = (e) => e == null ? null : e === document.body ? zo() ? e : null : e === document.documentElement ? null : Ro(e) ? e : Bo(e.parentElement), Vo = (e) => {
+	e && Bo(e.parentElement) && process.env.NODE_ENV !== "production" && D("\n    Droppable: unsupported nested scroll container detected.\n    A Droppable can only have one scroll parent (which can be itself)\n    Nested scroll containers are currently not supported.\n\n    We hope to support nested scroll containers soon: https://github.com/atlassian/react-beautiful-dnd/issues/131\n  ");
+}, Ho = (e) => ({
+	x: e.scrollLeft,
+	y: e.scrollTop
+}), Uo = (e) => e ? window.getComputedStyle(e).position === "fixed" ? !0 : Uo(e.parentElement) : !1, Wo = (e) => ({
+	closestScrollable: Bo(e),
+	isFixedOnPage: Uo(e)
+}), Go = ({ descriptor: e, isEnabled: t, isCombineEnabled: n, isFixedOnPage: r, direction: i, client: a, page: o, closest: s }) => {
+	let c = (() => {
+		if (!s) return null;
+		let { scrollSize: e, client: t } = s, n = Pr({
+			scrollHeight: e.scrollHeight,
+			scrollWidth: e.scrollWidth,
+			height: t.paddingBox.height,
+			width: t.paddingBox.width
+		});
+		return {
+			pageMarginBox: s.page.marginBox,
+			frameClient: t,
+			scrollSize: e,
+			shouldClipSubject: s.shouldClipSubject,
+			scroll: {
+				initial: s.scroll,
+				current: s.scroll,
+				max: n,
+				diff: {
+					value: N,
+					displacement: N
+				}
+			}
+		};
+	})(), l = i === "vertical" ? Ue : We;
+	return {
+		descriptor: e,
+		isCombineEnabled: n,
+		isFixedOnPage: r,
+		axis: l,
+		isEnabled: t,
+		client: a,
+		page: o,
+		frame: c,
+		subject: z({
+			page: o,
+			withPlaceholder: null,
+			axis: l,
+			frame: c
+		})
+	};
+}, Ko = (e, t) => {
+	let n = l(e);
+	if (!t || e !== t) return n;
+	let r = n.paddingBox.top - t.scrollTop, i = n.paddingBox.left - t.scrollLeft, a = r + t.scrollHeight;
+	return s({
+		borderBox: c({
+			top: r,
+			right: i + t.scrollWidth,
+			bottom: a,
+			left: i
+		}, n.border),
+		margin: n.margin,
+		border: n.border,
+		padding: n.padding
+	});
+}, qo = ({ ref: e, descriptor: t, env: n, windowScroll: r, direction: i, isDropDisabled: a, isCombineEnabled: o, shouldClipSubject: s }) => {
+	let c = n.closestScrollable, u = Ko(e, c), d = f(u, r), p = (() => {
+		if (!c) return null;
+		let e = l(c), t = {
+			scrollHeight: c.scrollHeight,
+			scrollWidth: c.scrollWidth
+		};
+		return {
+			client: e,
+			page: f(e, r),
+			scroll: Ho(c),
+			scrollSize: t,
+			shouldClipSubject: s
+		};
+	})();
+	return Go({
+		descriptor: t,
+		isEnabled: !a,
+		isCombineEnabled: o,
+		isFixedOnPage: n.isFixedOnPage,
+		direction: i,
+		client: u,
+		page: d,
+		closest: p
+	});
+}, Jo = { passive: !1 }, Yo = { passive: !0 }, Xo = (e) => e.shouldPublishImmediately ? Jo : Yo, Zo = (e) => e && e.env.closestScrollable || null;
+function Qo(e) {
+	let t = y(null), n = vo(Hi), r = zi("droppable"), { registry: i, marshal: a } = n, o = $i(e), s = j(() => ({
+		id: e.droppableId,
+		type: e.type,
+		mode: e.mode
+	}), [
+		e.droppableId,
+		e.mode,
+		e.type
+	]), c = y(s), l = j(() => B((e, n) => {
+		!t.current && (process.env.NODE_ENV === "production" ? A() : A(!1, "Can only update scroll when dragging"));
+		let r = {
+			x: e,
+			y: n
+		};
+		a.updateDroppableScroll(s.id, r);
+	}), [s.id, a]), u = M(() => {
+		let e = t.current;
+		return !e || !e.env.closestScrollable ? N : Ho(e.env.closestScrollable);
+	}, []), d = M(() => {
+		let e = u();
+		l(e.x, e.y);
+	}, [u, l]), f = j(() => p(d), [d]), m = M(() => {
+		let e = t.current, n = Zo(e);
+		if (!(e && n) && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find scroll options while scrolling")), e.scrollOptions.shouldPublishImmediately) {
+			d();
+			return;
+		}
+		f();
+	}, [f, d]), h = M((e, r) => {
+		t.current && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot collect a droppable while a drag is occurring"));
+		let i = o.current, a = i.getDroppableRef();
+		!a && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot collect without a droppable ref"));
+		let c = Wo(a), l = {
+			ref: a,
+			descriptor: s,
+			env: c,
+			scrollOptions: r
+		};
+		t.current = l;
+		let u = qo({
+			ref: a,
+			descriptor: s,
+			env: c,
+			windowScroll: e,
+			direction: i.direction,
+			isDropDisabled: i.isDropDisabled,
+			isCombineEnabled: i.isCombineEnabled,
+			shouldClipSubject: !i.ignoreContainerClipping
+		}), d = c.closestScrollable;
+		return d && (d.setAttribute(vi.contextId, n.contextId), d.addEventListener("scroll", m, Xo(l.scrollOptions)), process.env.NODE_ENV !== "production" && Vo(d)), u;
+	}, [
+		n.contextId,
+		s,
+		m,
+		o
+	]), g = M(() => {
+		let e = t.current, n = Zo(e);
+		return !(e && n) && (process.env.NODE_ENV === "production" ? A() : A(!1, "Can only recollect Droppable client for Droppables that have a scroll container")), Ho(n);
+	}, []), _ = M(() => {
+		let e = t.current;
+		!e && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot stop drag when no active drag"));
+		let n = Zo(e);
+		t.current = null, n && (f.cancel(), n.removeAttribute(vi.contextId), n.removeEventListener("scroll", m, Xo(e.scrollOptions)));
+	}, [m, f]), v = M((e) => {
+		let n = t.current;
+		!n && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot scroll when there is no drag"));
+		let r = Zo(n);
+		!r && (process.env.NODE_ENV === "production" ? A() : A(!1, "Cannot scroll a droppable with no closest scrollable")), r.scrollTop += e.y, r.scrollLeft += e.x;
+	}, []), b = j(() => ({
+		getDimensionAndWatchScroll: h,
+		getScrollWhileDragging: g,
+		dragStopped: _,
+		scroll: v
+	}), [
+		_,
+		h,
+		g,
+		v
+	]), x = j(() => ({
+		uniqueId: r,
+		descriptor: s,
+		callbacks: b
+	}), [
+		b,
+		s,
+		r
+	]);
+	$(() => (c.current = x.descriptor, i.droppable.register(x), () => {
+		t.current && (process.env.NODE_ENV !== "production" && D("Unsupported: changing the droppableId or type of a Droppable during a drag"), _()), i.droppable.unregister(x);
+	}), [
+		b,
+		s,
+		_,
+		x,
+		a,
+		i.droppable
+	]), $(() => {
+		t.current && a.updateDroppableIsEnabled(c.current.id, !e.isDropDisabled);
+	}, [e.isDropDisabled, a]), $(() => {
+		t.current && a.updateDroppableIsCombineEnabled(c.current.id, e.isCombineEnabled);
+	}, [e.isCombineEnabled, a]);
+}
+function $o() {}
+var es = {
+	width: 0,
+	height: 0,
+	margin: Ee
+}, ts = ({ isAnimatingOpenOnMount: e, placeholder: t, animate: n }) => e || n === "close" ? es : {
+	height: t.client.borderBox.height,
+	width: t.client.borderBox.width,
+	margin: t.client.margin
+}, ns = ({ isAnimatingOpenOnMount: e, placeholder: t, animate: n }) => {
+	let r = ts({
+		isAnimatingOpenOnMount: e,
+		placeholder: t,
+		animate: n
+	});
+	return {
+		display: t.display,
+		boxSizing: "border-box",
+		width: r.width,
+		height: r.height,
+		marginTop: r.margin.top,
+		marginRight: r.margin.right,
+		marginBottom: r.margin.bottom,
+		marginLeft: r.margin.left,
+		flexShrink: "0",
+		flexGrow: "0",
+		pointerEvents: "none",
+		transition: n === "none" ? null : Xn.placeholder
+	};
+}, rs = h.memo((e) => {
+	let t = y(null), n = M(() => {
+		t.current &&= (clearTimeout(t.current), null);
+	}, []), { animate: r, onTransitionEnd: i, onClose: a, contextId: o } = e, [s, c] = b(e.animate === "open");
+	_(() => s ? r === "open" ? t.current ? $o : (t.current = setTimeout(() => {
+		t.current = null, c(!1);
+	}), n) : (n(), c(!1), $o) : $o, [
+		r,
+		s,
+		n
+	]);
+	let l = M((e) => {
+		e.propertyName === "height" && (i(), r === "close" && a());
+	}, [
+		r,
+		a,
+		i
+	]), u = ns({
+		isAnimatingOpenOnMount: s,
+		animate: e.animate,
+		placeholder: e.placeholder
+	});
+	return h.createElement(e.placeholder.tagName, {
+		style: u,
+		"data-rfd-placeholder-context-id": o,
+		onTransitionEnd: l,
+		ref: e.innerRef
+	});
+});
+function is(e) {
+	return typeof e == "boolean";
+}
+function as(e, t) {
+	t.forEach((t) => t(e));
+}
+var os = [
+	function({ props: e }) {
+		!e.droppableId && (process.env.NODE_ENV === "production" ? A() : A(!1, "A Droppable requires a droppableId prop")), typeof e.droppableId != "string" && (process.env.NODE_ENV === "production" ? A() : A(!1, `A Droppable requires a [string] droppableId. Provided: [${typeof e.droppableId}]`));
+	},
+	function({ props: e }) {
+		!is(e.isDropDisabled) && (process.env.NODE_ENV === "production" ? A() : A(!1, "isDropDisabled must be a boolean")), !is(e.isCombineEnabled) && (process.env.NODE_ENV === "production" ? A() : A(!1, "isCombineEnabled must be a boolean")), !is(e.ignoreContainerClipping) && (process.env.NODE_ENV === "production" ? A() : A(!1, "ignoreContainerClipping must be a boolean"));
+	},
+	function({ getDroppableRef: e }) {
+		ho(e());
+	}
+], ss = [function({ props: e, getPlaceholderRef: t }) {
+	e.placeholder && (t() || process.env.NODE_ENV !== "production" && D(`
+      Droppable setup issue [droppableId: "${e.droppableId}"]:
+      DroppableProvided > placeholder could not be found.
+
+      Please be sure to add the {provided.placeholder} React Node as a child of your Droppable.
+      More information: https://github.com/hello-pangea/dnd/blob/main/docs/api/droppable.md
+    `));
+}], cs = [function({ props: e }) {
+	!e.renderClone && (process.env.NODE_ENV === "production" ? A() : A(!1, "Must provide a clone render function (renderClone) for virtual lists"));
+}, function({ getPlaceholderRef: e }) {
+	e() && (process.env.NODE_ENV === "production" ? A() : A(!1, "Expected virtual list to not have a placeholder"));
+}];
+function ls(e) {
+	Zi(() => {
+		as(e, os), e.props.mode === "standard" && as(e, ss), e.props.mode === "virtual" && as(e, cs);
+	});
+}
+var us = class extends h.PureComponent {
+	constructor(...e) {
+		super(...e), this.state = {
+			isVisible: !!this.props.on,
+			data: this.props.on,
+			animate: this.props.shouldAnimate && this.props.on ? "open" : "none"
+		}, this.onClose = () => {
+			this.state.animate === "close" && this.setState({ isVisible: !1 });
+		};
+	}
+	static getDerivedStateFromProps(e, t) {
+		return e.shouldAnimate ? e.on ? {
+			isVisible: !0,
+			data: e.on,
+			animate: "open"
+		} : t.isVisible ? {
+			isVisible: !0,
+			data: t.data,
+			animate: "close"
+		} : {
+			isVisible: !1,
+			animate: "close",
+			data: null
+		} : {
+			isVisible: !!e.on,
+			data: e.on,
+			animate: "none"
+		};
+	}
+	render() {
+		if (!this.state.isVisible) return null;
+		let e = {
+			onClose: this.onClose,
+			data: this.state.data,
+			animate: this.state.animate
+		};
+		return this.props.children(e);
+	}
+}, ds = (e) => {
+	let t = g(Hi);
+	!t && (process.env.NODE_ENV === "production" ? A() : A(!1, "Could not find app context"));
+	let { contextId: n, isMovementAllowed: r } = t, i = y(null), a = y(null), { children: o, droppableId: s, type: c, mode: l, direction: u, ignoreContainerClipping: d, isDropDisabled: f, isCombineEnabled: p, snapshot: m, useClone: _, updateViewportMaxScroll: v, getContainerForClone: b } = e, S = M(() => i.current, []), C = M((e = null) => {
+		i.current = e;
+	}, []), w = M(() => a.current, []), T = M((e = null) => {
+		a.current = e;
+	}, []);
+	ls({
+		props: e,
+		getDroppableRef: S,
+		getPlaceholderRef: w
+	});
+	let E = M(() => {
+		r() && v({ maxScroll: Ir() });
+	}, [r, v]);
+	Qo({
+		droppableId: s,
+		type: c,
+		mode: l,
+		direction: u,
+		isDropDisabled: f,
+		isCombineEnabled: p,
+		ignoreContainerClipping: d,
+		getDroppableRef: S
+	});
+	let ee = j(() => h.createElement(us, {
+		on: e.placeholder,
+		shouldAnimate: e.shouldAnimatePlaceholder
+	}, ({ onClose: e, data: t, animate: r }) => h.createElement(rs, {
+		placeholder: t,
+		onClose: e,
+		innerRef: T,
+		animate: r,
+		contextId: n,
+		onTransitionEnd: E
+	})), [
+		n,
+		E,
+		e.placeholder,
+		e.shouldAnimatePlaceholder,
+		T
+	]), te = j(() => ({
+		innerRef: C,
+		placeholder: ee,
+		droppableProps: {
+			"data-rfd-droppable-id": s,
+			"data-rfd-droppable-context-id": n
+		}
+	}), [
+		n,
+		s,
+		ee,
+		C
+	]), ne = _ ? _.dragging.draggableId : null, re = j(() => ({
+		droppableId: s,
+		type: c,
+		isUsingCloneFor: ne
+	}), [
+		s,
+		ne,
+		c
+	]);
+	function D() {
+		if (!_) return null;
+		let { dragging: e, render: t } = _, n = h.createElement(Ao, {
+			draggableId: e.draggableId,
+			index: e.source.index,
+			isClone: !0,
+			isEnabled: !0,
+			shouldRespectForcePress: !1,
+			canDragInteractiveElements: !0
+		}, (n, r) => t(n, r, e));
+		return x.createPortal(n, b());
+	}
+	return h.createElement(mo.Provider, { value: re }, o(te, m), D());
+};
+function fs() {
+	return !document.body && (process.env.NODE_ENV === "production" ? A() : A(!1, "document.body is not ready")), document.body;
+}
+var ps = {
+	mode: "standard",
+	type: "DEFAULT",
+	direction: "vertical",
+	isDropDisabled: !1,
+	isCombineEnabled: !1,
+	ignoreContainerClipping: !1,
+	renderClone: null,
+	getContainerForClone: fs
+}, ms = (e) => {
+	let t = { ...e }, n;
+	for (n in ps) e[n] === void 0 && (t = {
+		...t,
+		[n]: ps[n]
+	});
+	return t;
+}, hs = (e, t) => e === t.droppable.type, gs = (e, t) => t.draggables[e.draggable.id], _s = a(() => {
+	let e = {
+		placeholder: null,
+		shouldAnimatePlaceholder: !0,
+		snapshot: {
+			isDraggingOver: !1,
+			draggingOverWith: null,
+			draggingFromThisWith: null,
+			isUsingPlaceholder: !1
+		},
+		useClone: null
+	}, t = {
+		...e,
+		shouldAnimatePlaceholder: !1
+	}, n = B((e) => ({
+		draggableId: e.id,
+		type: e.type,
+		source: {
+			index: e.index,
+			droppableId: e.droppableId
+		}
+	})), r = B((r, i, a, o, s, c) => {
+		let l = s.descriptor.id;
+		if (s.descriptor.droppableId === r) {
+			let e = c ? {
+				render: c,
+				dragging: n(s.descriptor)
+			} : null, t = {
+				isDraggingOver: a,
+				draggingOverWith: a ? l : null,
+				draggingFromThisWith: l,
+				isUsingPlaceholder: !0
+			};
+			return {
+				placeholder: s.placeholder,
+				shouldAnimatePlaceholder: !1,
+				snapshot: t,
+				useClone: e
+			};
+		}
+		if (!i) return t;
+		if (!o) return e;
+		let u = {
+			isDraggingOver: a,
+			draggingOverWith: l,
+			draggingFromThisWith: null,
+			isUsingPlaceholder: !0
+		};
+		return {
+			placeholder: s.placeholder,
+			shouldAnimatePlaceholder: !0,
+			snapshot: u,
+			useClone: null
+		};
+	});
+	return (n, i) => {
+		let a = ms(i), o = a.droppableId, s = a.type, c = !a.isDropDisabled, l = a.renderClone;
+		if (ta(n)) {
+			let e = n.critical;
+			if (!hs(s, e)) return t;
+			let i = gs(e, n.dimensions), a = q(n.impact) === o;
+			return r(o, c, a, a, i, l);
+		}
+		if (n.phase === "DROP_ANIMATING") {
+			let e = n.completed;
+			if (!hs(s, e.critical)) return t;
+			let i = gs(e.critical, n.dimensions);
+			return r(o, c, So(e.result) === o, q(e.impact) === o, i, l);
+		}
+		if (n.phase === "IDLE" && n.completed && !n.shouldFlush) {
+			let r = n.completed;
+			if (!hs(s, r.critical)) return t;
+			let i = q(r.impact) === o, a = !!(r.impact.at && r.impact.at.type === "COMBINE"), c = r.critical.droppable.id === o;
+			return i ? a ? e : t : c ? e : t;
+		}
+		return t;
+	};
+}, { updateViewportMaxScroll: Mn }, (e, t, n) => ({
+	...ms(n),
+	...e,
+	...t
+}), {
+	context: Ni,
+	areStatePropsEqual: xo
+})(ds);
+//#endregion
+export { _s as ConnectedDroppable, ro as DragDropContext, jo as PublicDraggable };