tembro 3.0.0 → 3.1.1

package/dist/node_modules/@dnd-kit/dom/index.js

@@ -0,0 +1,1339 @@
+import { f as e, j as t, n, y as r } from "../../@preact/signals-core/dist/signals-core.module.js";
+import { computed as i, deepEqual as a, derived as o, effects as s, reactive as c } from "../state/dist/index.js";
+import { Axes as l, Point as u, Rectangle as d, exceedsDistance as f } from "../geometry/dist/index.js";
+import { ActivationConstraint as p, ActivationController as m, CorePlugin as h, DragDropManager as g, Draggable as _, Droppable as v, Plugin as y, Sensor as ee, configurator as b, descriptor as x, resolveCustomizable as S } from "../abstract/index.js";
+import { DOMRectangle as C, FrameObserver as te, Listeners as ne, ProxiedElements as w, ScrollDirection as T, Styles as re, animateTransform as ie, canScroll as ae, cloneElement as oe, detectScrollIntent as se, generateUniqueId as ce, getComputedStyles as le, getDocument as ue, getDocuments as de, getElementFromPoint as fe, getEventCoordinates as E, getFinalKeyframe as pe, getFixedPositionOffset as me, getFrameElement as he, getFrameTransform as ge, getInteractiveElement as _e, getRoot as D, getScrollableAncestors as ve, getWindow as ye, isDocument as be, isElement as O, isHTMLElement as xe, isKeyboardEvent as Se, isPointerEvent as Ce, isSafari as we, isShadowRoot as k, isTextInput as Te, parseTransform as Ee, parseTranslate as De, prefersReducedMotion as Oe, scheduler as A, scrollIntoViewIfNeeded as ke, showPopover as Ae, supportsPopover as je, supportsStyle as Me } from "./utilities.js";
+import { defaultCollisionDetection as Ne } from "../collision/dist/index.js";
+//#region node_modules/@dnd-kit/dom/index.js
+var Pe = Object.create, Fe = Object.defineProperty, Ie = Object.defineProperties, Le = Object.getOwnPropertyDescriptor, Re = Object.getOwnPropertyDescriptors, ze = Object.getOwnPropertySymbols, Be = Object.prototype.hasOwnProperty, Ve = Object.prototype.propertyIsEnumerable, j = (e, t) => (t = Symbol[e]) ? t : Symbol.for("Symbol." + e), M = (e) => {
+	throw TypeError(e);
+}, N = (e, t, n) => t in e ? Fe(e, t, {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: n
+}) : e[t] = n, P = (e, t) => {
+	for (var n in t ||= {}) Be.call(t, n) && N(e, n, t[n]);
+	if (ze) for (var n of ze(t)) Ve.call(t, n) && N(e, n, t[n]);
+	return e;
+}, He = (e, t) => Ie(e, Re(t)), Ue = (e, t) => Fe(e, "name", {
+	value: t,
+	configurable: !0
+}), We = (e, t) => {
+	var n = {};
+	for (var r in e) Be.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+	if (e != null && ze) for (var r of ze(e)) t.indexOf(r) < 0 && Ve.call(e, r) && (n[r] = e[r]);
+	return n;
+}, F = (e) => [
+	,
+	,
+	,
+	Pe(e?.[j("metadata")] ?? null)
+], Ge = [
+	"class",
+	"method",
+	"getter",
+	"setter",
+	"accessor",
+	"field",
+	"value",
+	"get",
+	"set"
+], Ke = (e) => e !== void 0 && typeof e != "function" ? M("Function expected") : e, qe = (e, t, n, r, i) => ({
+	kind: Ge[e],
+	name: t,
+	metadata: r,
+	addInitializer: (e) => n._ ? M("Already initialized") : i.push(Ke(e || null))
+}), I = (e, t) => N(t, j("metadata"), e[3]), L = (e, t, n, r) => {
+	for (var i = 0, a = e[t >> 1], o = a && a.length; i < o; i++) t & 1 ? a[i].call(n) : r = a[i].call(n, r);
+	return r;
+}, R = (e, t, n, r, i, a) => {
+	var o, s, c, l, u, d = t & 7, f = !!(t & 8), p = !!(t & 16), m = d > 3 ? e.length + 1 : d ? f ? 1 : 2 : 0, h = Ge[d + 5], g = d > 3 && (e[m - 1] = []), _ = e[m] || (e[m] = []), v = d && (!p && !f && (i = i.prototype), d < 5 && (d > 3 || !p) && Le(d < 4 ? i : {
+		get [n]() {
+			return z(this, a);
+		},
+		set [n](e) {
+			return V(this, a, e);
+		}
+	}, n));
+	d ? p && d < 4 && Ue(a, (d > 2 ? "set " : d > 1 ? "get " : "") + n) : Ue(i, n);
+	for (var y = r.length - 1; y >= 0; y--) l = qe(d, n, c = {}, e[3], _), d && (l.static = f, l.private = p, u = l.access = { has: p ? (e) => Ye(i, e) : (e) => n in e }, d ^ 3 && (u.get = p ? (e) => (d ^ 1 ? z : H)(e, i, d ^ 4 ? a : v.get) : (e) => e[n]), d > 2 && (u.set = p ? (e, t) => V(e, i, t, d ^ 4 ? a : v.set) : (e, t) => e[n] = t)), s = (0, r[y])(d ? d < 4 ? p ? a : v[h] : d > 4 ? void 0 : {
+		get: v.get,
+		set: v.set
+	} : i, l), c._ = 1, d ^ 4 || s === void 0 ? Ke(s) && (d > 4 ? g.unshift(s) : d ? p ? a = s : v[h] = s : i = s) : typeof s != "object" || !s ? M("Object expected") : (Ke(o = s.get) && (v.get = o), Ke(o = s.set) && (v.set = o), Ke(o = s.init) && g.unshift(o));
+	return d || I(e, i), v && Fe(i, n, v), p ? d ^ 4 ? a : v : i;
+}, Je = (e, t, n) => t.has(e) || M("Cannot " + n), Ye = (e, t) => Object(t) === t ? e.has(t) : M("Cannot use the \"in\" operator on this value"), z = (e, t, n) => (Je(e, t, "read from private field"), n ? n.call(e) : t.get(e)), B = (e, t, n) => t.has(e) ? M("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), V = (e, t, n, r) => (Je(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), H = (e, t, n) => (Je(e, t, "access private method"), n), Xe = {
+	role: "button",
+	roleDescription: "draggable"
+}, Ze = "dnd-kit-description", Qe = "dnd-kit-announcement", $e = { draggable: "To pick up a draggable item, press the space bar. While dragging, use the arrow keys to move the item in a given direction. Press space again to drop the item in its new position, or press escape to cancel." }, et = {
+	dragstart({ operation: { source: e } }) {
+		if (e) return `Picked up draggable item ${e.id}.`;
+	},
+	dragover({ operation: { source: e, target: t } }) {
+		if (!(!e || e.id === t?.id)) return t ? `Draggable item ${e.id} was moved over droppable target ${t.id}.` : `Draggable item ${e.id} is no longer over a droppable target.`;
+	},
+	dragend({ operation: { source: e, target: t }, canceled: n }) {
+		if (e) return n ? `Dragging was cancelled. Draggable item ${e.id} was dropped.` : t ? `Draggable item ${e.id} was dropped over droppable target ${t.id}` : `Draggable item ${e.id} was dropped.`;
+	}
+};
+function tt(e) {
+	let t = e.tagName.toLowerCase();
+	return [
+		"input",
+		"select",
+		"textarea",
+		"a",
+		"button"
+	].includes(t);
+}
+function nt(e, t) {
+	let n = document.createElement("div");
+	return n.id = e, n.style.setProperty("display", "none"), n.textContent = t, n;
+}
+function rt(e) {
+	let t = document.createElement("div");
+	return t.id = e, t.setAttribute("role", "status"), t.setAttribute("aria-live", "polite"), t.setAttribute("aria-atomic", "true"), t.style.setProperty("position", "fixed"), t.style.setProperty("width", "1px"), t.style.setProperty("height", "1px"), t.style.setProperty("margin", "-1px"), t.style.setProperty("border", "0"), t.style.setProperty("padding", "0"), t.style.setProperty("overflow", "hidden"), t.style.setProperty("clip", "rect(0 0 0 0)"), t.style.setProperty("clip-path", "inset(100%)"), t.style.setProperty("white-space", "nowrap"), t;
+}
+var it = ["dragover", "dragmove"], at = class extends y {
+	constructor(e, t) {
+		super(e);
+		let { id: n, idPrefix: { description: r = Ze, announcement: i = Qe } = {}, announcements: a = et, screenReaderInstructions: o = $e, debounce: s = 500 } = t ?? {}, c = n ? `${r}-${n}` : ce(r), l = n ? `${i}-${n}` : ce(i), u, d, f, p, m = (e = p) => {
+			!f || !e || f?.nodeValue !== e && (f.nodeValue = e);
+		}, h = () => A.schedule(m), g = ot(h, s), _ = Object.entries(a).map(([e, t]) => this.manager.monitor.addEventListener(e, (n, r) => {
+			let i = f;
+			if (!i) return;
+			let a = t?.(n, r);
+			a && i.nodeValue !== a && (p = a, it.includes(e) ? g() : (h(), g.cancel()));
+		})), v = () => {
+			let e = [];
+			u?.isConnected || (u = nt(c, o.draggable), e.push(u)), d?.isConnected || (d = rt(l), f = document.createTextNode(""), d.appendChild(f), e.push(d)), e.length > 0 && document.body.append(...e);
+		}, y = /* @__PURE__ */ new Set();
+		function ee() {
+			for (let e of y) e();
+		}
+		this.registerEffect(() => {
+			y.clear();
+			for (let e of this.manager.registry.draggables.value) {
+				let t = e.handle ?? e.element;
+				if (t) {
+					(!u || !d) && y.add(v), (!tt(t) || we()) && !t.hasAttribute("tabindex") && y.add(() => t.setAttribute("tabindex", "0")), !t.hasAttribute("role") && t.tagName.toLowerCase() !== "button" && y.add(() => t.setAttribute("role", Xe.role)), t.hasAttribute("aria-roledescription") || y.add(() => t.setAttribute("aria-roledescription", Xe.roleDescription)), t.hasAttribute("aria-describedby") || y.add(() => t.setAttribute("aria-describedby", c));
+					for (let n of ["aria-pressed", "aria-grabbed"]) {
+						let r = String(e.isDragging);
+						t.getAttribute(n) !== r && y.add(() => t.setAttribute(n, r));
+					}
+					let n = String(e.disabled);
+					t.getAttribute("aria-disabled") !== n && y.add(() => t.setAttribute("aria-disabled", n));
+				}
+			}
+			y.size > 0 && A.schedule(ee);
+		}), this.destroy = () => {
+			super.destroy(), u?.remove(), d?.remove(), _.forEach((e) => e());
+		};
+	}
+};
+function ot(e, t) {
+	let n, r = () => {
+		clearTimeout(n), n = setTimeout(e, t);
+	};
+	return r.cancel = () => clearTimeout(n), r;
+}
+var st = /* @__PURE__ */ new Map(), ct, lt, ut, dt, ft, pt, U, mt, W, ht, gt, _t, vt, G = class extends (ft = h, dt = [c], ut = [o], lt = [o], ct = [o], ft) {
+	constructor(e, t) {
+		super(e, t), L(U, 5, this), B(this, W), B(this, pt, /* @__PURE__ */ new Set()), B(this, mt, L(U, 8, this, /* @__PURE__ */ new Set())), L(U, 11, this), this.registerEffect(H(this, W, ht));
+	}
+	register(e) {
+		return z(this, pt).add(e), () => {
+			z(this, pt).delete(e);
+		};
+	}
+	addRoot(t) {
+		return e(() => {
+			let e = new Set(this.additionalRoots);
+			e.add(t), this.additionalRoots = e;
+		}), () => {
+			e(() => {
+				let e = new Set(this.additionalRoots);
+				e.delete(t), this.additionalRoots = e;
+			});
+		};
+	}
+	get sourceRoot() {
+		let { source: e } = this.manager.dragOperation;
+		return D(e?.element ?? null);
+	}
+	get targetRoot() {
+		let { target: e } = this.manager.dragOperation;
+		return D(e?.element ?? null);
+	}
+	get roots() {
+		let { status: e } = this.manager.dragOperation;
+		if (e.initializing || e.initialized) {
+			let e = [this.sourceRoot, this.targetRoot].filter((e) => e != null);
+			return /* @__PURE__ */ new Set([...e, ...this.additionalRoots]);
+		}
+		return /* @__PURE__ */ new Set();
+	}
+};
+U = F(ft), pt = /* @__PURE__ */ new WeakMap(), mt = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new WeakSet(), ht = function() {
+	let { roots: e } = this, t = [];
+	for (let n of e) for (let e of z(this, pt)) t.push(H(this, W, gt).call(this, n, e));
+	return () => {
+		for (let e of t) e();
+	};
+}, gt = function(e, t) {
+	let n = st.get(e);
+	n || (n = /* @__PURE__ */ new Map(), st.set(e, n));
+	let r = n.get(t);
+	if (!r) {
+		let i = be(e) ? H(this, W, _t).call(this, e, n, t) : H(this, W, vt).call(this, e, n, t);
+		if (!i) return () => {};
+		r = i, n.set(t, r);
+	}
+	r.refCount++;
+	let i = !1;
+	return () => {
+		i || (i = !0, r.refCount--, r.refCount === 0 && r.cleanup());
+	};
+}, _t = function(e, t, n) {
+	let r = e.createElement("style"), { nonce: i } = this.options ?? {};
+	i && r.setAttribute("nonce", i), r.textContent = n, e.head.prepend(r);
+	let a = new MutationObserver((t) => {
+		for (let n of t) for (let t of Array.from(n.removedNodes)) if (t === r) {
+			e.head.prepend(r);
+			return;
+		}
+	});
+	return a.observe(e.head, { childList: !0 }), {
+		refCount: 0,
+		cleanup: () => {
+			a.disconnect(), r.remove(), t.delete(n), t.size === 0 && st.delete(e);
+		}
+	};
+}, vt = function(e, t, n) {
+	!("adoptedStyleSheets" in e && Array.isArray(e.adoptedStyleSheets)) && process.env.NODE_ENV !== "production" && console.error("Cannot inject styles: This browser doesn't support adoptedStyleSheets");
+	let { CSSStyleSheet: r } = e.ownerDocument.defaultView ?? {};
+	if (!r) return process.env.NODE_ENV !== "production" && console.error("Cannot inject styles: CSSStyleSheet constructor not available"), null;
+	let i = new r();
+	return i.replaceSync(n), e.adoptedStyleSheets.push(i), {
+		refCount: 0,
+		cleanup: () => {
+			if (k(e) && e.host?.isConnected) {
+				let t = e.adoptedStyleSheets.indexOf(i);
+				t !== -1 && e.adoptedStyleSheets.splice(t, 1);
+			}
+			t.delete(n), t.size === 0 && st.delete(e);
+		}
+	};
+}, R(U, 4, "additionalRoots", dt, G, mt), R(U, 2, "sourceRoot", ut, G), R(U, 2, "targetRoot", lt, G), R(U, 2, "roots", ct, G), I(U, G), G.configure = b(G);
+var yt = G, bt = class extends y {
+	constructor(e, t) {
+		super(e, t), this.manager = e;
+		let { cursor: n = "grabbing" } = t ?? {}, r = e.registry.plugins.get(yt)?.register(`* { cursor: ${n} !important; }`);
+		if (r) {
+			let e = this.destroy.bind(this);
+			this.destroy = () => {
+				r(), e();
+			};
+		}
+	}
+}, xt = "data-dnd-", St = `${xt}dropping`, K = "--dnd-", q = `${xt}dragging`, Ct = `${xt}placeholder`, wt = [
+	q,
+	Ct,
+	"popover",
+	"aria-pressed",
+	"aria-grabbing"
+], Tt = ["view-transition-name"], Et = `
+  :is(:root,:host) [${q}] {
+    position: fixed !important;
+    pointer-events: none !important;
+    touch-action: none;
+    z-index: calc(infinity);
+    will-change: translate;
+    top: var(${K}top, 0px) !important;
+    left: var(${K}left, 0px) !important;
+    right: unset !important;
+    bottom: unset !important;
+    width: var(${K}width, auto);
+    max-width: var(${K}width, auto);
+    height: var(${K}height, auto);
+    max-height: var(${K}height, auto);
+    transform: var(${K}transform, none) !important;
+    transition: var(${K}transition) !important;
+  }
+
+  :is(:root,:host) [${Ct}] {
+    transition: none;
+  }
+
+  :is(:root,:host) [${Ct}='hidden'] {
+    visibility: hidden;
+  }
+
+  [${q}] * {
+    pointer-events: none !important;
+  }
+
+  [${q}]:not([${St}]) {
+    translate: var(${K}translate) !important;
+  }
+
+  [${q}][style*='${K}scale'] {
+    scale: var(${K}scale) !important;
+    transform-origin: var(${K}transform-origin) !important;
+  }
+
+  @layer dnd-kit {
+    :where([${q}][popover]) {
+      overflow: visible;
+      background: unset;
+      border: unset;
+      margin: unset;
+      padding: unset;
+      color: inherit;
+
+      &:is(input, button) {
+        border: revert;
+        background: revert;
+      }
+    }
+  }
+  [${q}]::backdrop, [${xt}overlay]:not([${q}]) {
+    display: none;
+    visibility: hidden;
+  }
+`.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+function Dt(t, n = "hidden") {
+	return e(() => {
+		let { element: e, manager: r } = t;
+		if (!e || !r) return;
+		let i = Ot(e, r.registry.droppables), a = [], o = oe(e), { remove: s } = o;
+		return kt(i, o, a), At(o, n), o.remove = () => {
+			a.forEach((e) => e()), s.call(o);
+		}, o;
+	});
+}
+function Ot(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of t) if (r.element && (e === r.element || e.contains(r.element))) {
+		let e = `${xt}${ce("dom-id")}`;
+		r.element.setAttribute(e, ""), n.set(r, e);
+	}
+	return n;
+}
+function kt(e, t, n) {
+	for (let [r, i] of e) {
+		if (!r.element) continue;
+		let e = `[${i}]`, a = t.matches(e) ? t : t.querySelector(e);
+		if (r.element.removeAttribute(i), !a) continue;
+		let o = r.element;
+		r.proxy = a, a.removeAttribute(i), w.set(o, a), n.push(() => {
+			w.delete(o), r.proxy = void 0;
+		});
+	}
+}
+function At(e, t = "hidden") {
+	e.setAttribute("inert", "true"), e.setAttribute("tab-index", "-1"), e.setAttribute("aria-hidden", "true"), e.setAttribute(Ct, t);
+}
+function jt(e, t) {
+	return e === t ? !0 : he(e) === he(t);
+}
+function Mt(e) {
+	let { target: t } = e;
+	"newState" in e && e.newState === "closed" && O(t) && t.hasAttribute("popover") && requestAnimationFrame(() => Ae(t));
+}
+function Nt(e) {
+	return e.tagName === "TR";
+}
+function Pt(e, t, n) {
+	let r = new MutationObserver((r) => {
+		let i = !1;
+		for (let n of r) {
+			if (n.target !== e) {
+				i = !0;
+				continue;
+			}
+			if (n.type !== "attributes") continue;
+			let r = n.attributeName;
+			if (r.startsWith("aria-") || wt.includes(r)) continue;
+			let a = e.getAttribute(r);
+			if (r === "style") {
+				if (Me(e) && Me(t)) {
+					let n = e.style;
+					for (let e of Array.from(t.style)) n.getPropertyValue(e) === "" && t.style.removeProperty(e);
+					for (let e of Array.from(n)) {
+						if (Tt.includes(e) || e.startsWith(K)) continue;
+						let r = n.getPropertyValue(e);
+						t.style.setProperty(e, r);
+					}
+				}
+			} else a === null ? t.removeAttribute(r) : t.setAttribute(r, a);
+		}
+		i && n && t.replaceChildren(...e.cloneNode(!0).childNodes);
+	});
+	return r.observe(e, {
+		attributes: !0,
+		subtree: !0,
+		childList: !0
+	}), r;
+}
+function Ft(e, t, n) {
+	let r = new MutationObserver((r) => {
+		for (let i of r) if (i.addedNodes.length !== 0) for (let r of Array.from(i.addedNodes)) {
+			if (r.contains(e) && e.nextElementSibling !== t) {
+				e.insertAdjacentElement("afterend", t), Ae(n);
+				return;
+			}
+			if (r.contains(t) && t.previousElementSibling !== e) {
+				t.insertAdjacentElement("beforebegin", e), Ae(n);
+				return;
+			}
+		}
+		e.isConnected && t.isConnected && e.nextElementSibling !== t && (e.insertAdjacentElement("afterend", t), Ae(n));
+	});
+	return r.observe(e.ownerDocument.body, {
+		childList: !0,
+		subtree: !0
+	}), r;
+}
+function It(e) {
+	return new ResizeObserver(() => {
+		var t;
+		let n = new C(e.placeholder, {
+			frameTransform: e.frameTransform,
+			ignoreTransforms: !0
+		}), r = e.transformOrigin ?? {
+			x: 1,
+			y: 1
+		}, i = (e.width - n.width) * r.x + e.delta.x, a = (e.height - n.height) * r.y + e.delta.y, o = me();
+		if (e.styles.set({
+			width: n.width - e.widthOffset,
+			height: n.height - e.heightOffset,
+			top: e.top + a + o.y,
+			left: e.left + i + o.x
+		}, K), (t = e.getElementMutationObserver()) == null || t.takeRecords(), Nt(e.element) && Nt(e.placeholder)) {
+			let t = Array.from(e.element.cells), n = Array.from(e.placeholder.cells);
+			e.getSavedCellWidths() || e.setSavedCellWidths(t.map((e) => e.style.width));
+			for (let [e, r] of t.entries()) {
+				let t = n[e];
+				r.style.width = `${t.getBoundingClientRect().width}px`;
+			}
+		}
+		let s = e.getTranslate() ?? {
+			x: 0,
+			y: 0
+		}, c = e.left + i + o.x + s.x, l = e.top + a + o.y + s.y, u = n.width - e.widthOffset, f = n.height - e.heightOffset, p = e.frameTransform;
+		e.dragOperation.shape = new d(c * p.scaleX + p.x, l * p.scaleY + p.y, u * p.scaleX, f * p.scaleY);
+	});
+}
+var Lt = 250, Rt = "ease";
+function zt(e) {
+	var t;
+	let { animation: n } = e;
+	if (typeof n == "function") {
+		let t = n({
+			source: e.source,
+			element: e.element,
+			feedbackElement: e.feedbackElement,
+			placeholder: e.placeholder,
+			translate: e.translate,
+			moved: e.moved
+		});
+		Promise.resolve(t).then(() => {
+			e.cleanup(), requestAnimationFrame(e.restoreFocus);
+		});
+		return;
+	}
+	let { duration: r = Lt, easing: i = Rt } = n ?? {};
+	Ae(e.feedbackElement);
+	let [, a] = pe(e.feedbackElement, (e) => "translate" in e) ?? [];
+	a?.pause();
+	let o = e.placeholder ?? e.element, s = { frameTransform: jt(e.feedbackElement, o) ? null : void 0 }, c = new C(e.feedbackElement, s), l = De(le(e.feedbackElement).translate) ?? e.translate, u = new C(o, s), f = d.delta(c, u, e.alignment), p = {
+		x: l.x - f.x,
+		y: l.y - f.y
+	}, m = Math.round(c.intrinsicHeight) === Math.round(u.intrinsicHeight) ? {} : {
+		minHeight: [`${c.intrinsicHeight}px`, `${u.intrinsicHeight}px`],
+		maxHeight: [`${c.intrinsicHeight}px`, `${u.intrinsicHeight}px`]
+	}, h = Math.round(c.intrinsicWidth) === Math.round(u.intrinsicWidth) ? {} : {
+		minWidth: [`${c.intrinsicWidth}px`, `${u.intrinsicWidth}px`],
+		maxWidth: [`${c.intrinsicWidth}px`, `${u.intrinsicWidth}px`]
+	};
+	e.styles.set({ transition: e.transition }, K), e.feedbackElement.setAttribute(St, ""), (t = e.getElementMutationObserver()) == null || t.takeRecords(), ie({
+		element: e.feedbackElement,
+		keyframes: He(P(P({}, m), h), { translate: [`${l.x}px ${l.y}px 0`, `${p.x}px ${p.y}px 0`] }),
+		options: {
+			duration: Oe(ye(e.feedbackElement)) ? 0 : e.moved || e.feedbackElement !== e.element ? r : 0,
+			easing: i
+		}
+	}).then(() => {
+		e.feedbackElement.removeAttribute(St), a?.finish(), e.cleanup(), requestAnimationFrame(e.restoreFocus);
+	});
+}
+var Bt, Vt, Ht, Ut, Wt, Gt, Kt, qt = class extends (Vt = y, Bt = [c], Vt) {
+	constructor(e, t) {
+		super(e, t), B(this, Wt), B(this, Ut, L(Ht, 8, this)), L(Ht, 11, this), this.state = {
+			initial: {},
+			current: {}
+		};
+		let n = e.registry.plugins.get(yt), r = n?.register(Et);
+		if (r) {
+			let e = this.destroy.bind(this);
+			this.destroy = () => {
+				r(), e();
+			};
+		}
+		this.registerEffect(H(this, Wt, Gt).bind(this, n)), this.registerEffect(H(this, Wt, Kt));
+	}
+};
+Ht = F(Vt), Ut = /* @__PURE__ */ new WeakMap(), Wt = /* @__PURE__ */ new WeakSet(), Gt = function(e) {
+	let { overlay: t } = this;
+	if (!t || !e) return;
+	let n = D(t);
+	if (n) return e.addRoot(n);
+}, Kt = function() {
+	let { state: t, manager: n, options: r } = this, { dragOperation: i } = n, { position: a, source: o, status: c } = i;
+	if (c.idle) {
+		t.current = {}, t.initial = {};
+		return;
+	}
+	if (!o) return;
+	let { element: l } = o, f = o.pluginConfig(qt), p = f?.feedback ?? r?.feedback ?? "default", m = typeof p == "function" ? p(o, n) : p;
+	if (!l || m === "none" || !c.initialized || c.initializing) return;
+	let { initial: h } = t, g = this.overlay ?? l, _ = ge(g), v = ge(l), y = !jt(l, g), ee = new C(l, {
+		frameTransform: y ? v : null,
+		ignoreTransforms: !y
+	}), b = {
+		x: v.scaleX / _.scaleX,
+		y: v.scaleY / _.scaleY
+	}, { width: x, height: S, top: te, left: ne } = ee;
+	y && (x /= b.x, S /= b.y);
+	let w = new re(g), T = le(l), { transition: ie, translate: ae, boxSizing: oe, paddingBlockStart: se, paddingBlockEnd: ce, paddingInlineStart: ue, paddingInlineEnd: de, borderInlineStartWidth: fe, borderInlineEndWidth: E, borderBlockStartWidth: pe, borderBlockEndWidth: he } = T, _e = ie.split(",").filter((e) => !/^\s*(transform|translate|scale)\b/.test(e)).join(","), D = Ee(T), ve = T.transform, be = m === "clone", O = oe === "content-box", Ce = O ? parseInt(ue) + parseInt(de) + parseInt(fe) + parseInt(E) : 0, we = O ? parseInt(se) + parseInt(ce) + parseInt(pe) + parseInt(he) : 0, k = m !== "move" && !this.overlay ? Dt(o, be ? "clone" : "hidden") : null, Te = e(() => Se(n.dragOperation.activatorEvent));
+	if (!h.translate) {
+		if (this.overlay && D) h.translate = {
+			x: D.x,
+			y: D.y
+		};
+		else if (ae !== "none") {
+			let e = De(ae);
+			e && (h.translate = e);
+		}
+	}
+	if (!h.transformOrigin) {
+		let t = e(() => a.current), n = ne + (D?.x ?? 0), r = te + (D?.y ?? 0);
+		h.transformOrigin = {
+			x: (t.x - n * _.scaleX - _.x) / (x * _.scaleX),
+			y: (t.y - r * _.scaleY - _.y) / (S * _.scaleY)
+		};
+	}
+	let { transformOrigin: A } = h, ke = te * _.scaleY + _.y, Me = ne * _.scaleX + _.x;
+	if (!h.coordinates && (h.coordinates = {
+		x: Me,
+		y: ke
+	}, b.x !== 1 || b.y !== 1)) {
+		let { scaleX: e, scaleY: t } = v, { x: n, y: r } = A;
+		h.coordinates.x += (x * e - x) * n, h.coordinates.y += (S * t - S) * r;
+	}
+	h.dimensions ||= {
+		width: x,
+		height: S
+	}, h.frameTransform ||= _;
+	let Ne = {
+		x: h.coordinates.x - Me,
+		y: h.coordinates.y - ke
+	}, Pe = {
+		width: (h.dimensions.width * h.frameTransform.scaleX - x * _.scaleX) * A.x,
+		height: (h.dimensions.height * h.frameTransform.scaleY - S * _.scaleY) * A.y
+	}, Fe = {
+		x: Ne.x / _.scaleX + Pe.width,
+		y: Ne.y / _.scaleY + Pe.height
+	}, Ie = {
+		left: ne + Fe.x,
+		top: te + Fe.y
+	};
+	g.setAttribute(q, "true");
+	let Le = e(() => i.transform), Re = h.translate ?? {
+		x: 0,
+		y: 0
+	}, ze = Le.x * _.scaleX + Re.x, Be = Le.y * _.scaleY + Re.y, Ve = me();
+	w.set({
+		width: x - Ce,
+		height: S - we,
+		top: Ie.top + Ve.y,
+		left: Ie.left + Ve.x,
+		translate: `${ze}px ${Be}px 0`,
+		transform: this.overlay ? "none" : ve,
+		transition: _e ? `${_e}, translate 0ms linear` : "translate 0ms linear",
+		scale: y ? `${b.x} ${b.y}` : "",
+		"transform-origin": `${A.x * 100}% ${A.y * 100}%`
+	}, K), k && (l.insertAdjacentElement("afterend", k), r?.rootElement && (typeof r.rootElement == "function" ? r.rootElement(o) : r.rootElement).appendChild(l)), je(g) && (g.hasAttribute("popover") || g.setAttribute("popover", "manual"), Ae(g), g.addEventListener("beforetoggle", Mt));
+	let j, M, N, P = It({
+		placeholder: k,
+		element: l,
+		feedbackElement: g,
+		frameTransform: _,
+		transformOrigin: A,
+		width: x,
+		height: S,
+		top: te,
+		left: ne,
+		widthOffset: Ce,
+		heightOffset: we,
+		delta: Fe,
+		styles: w,
+		dragOperation: i,
+		getTranslate: () => t.current.translate,
+		getElementMutationObserver: () => j,
+		getSavedCellWidths: () => N,
+		setSavedCellWidths: (e) => {
+			N = e;
+		}
+	}), He = new C(g);
+	e(() => i.shape = He);
+	let Ue = ye(g), We = (e) => {
+		this.manager.actions.stop({ event: e });
+	}, F = Oe(Ue);
+	Te && Ue.addEventListener("resize", We), e(() => o.status) === "idle" && requestAnimationFrame(() => o.status = "dragging"), k && (P.observe(k), j = Pt(l, k, be), M = Ft(l, k, g));
+	let Ge = n.dragOperation.source?.id, Ke = () => {
+		if (!Te || Ge == null) return;
+		let e = n.registry.draggables.get(Ge), t = e?.handle ?? e?.element;
+		xe(t) && t.focus();
+	}, qe = () => {
+		j?.disconnect(), M?.disconnect(), P.disconnect(), Ue.removeEventListener("resize", We), je(g) && (g.removeEventListener("beforetoggle", Mt), g.removeAttribute("popover")), g.removeAttribute(q), w.reset();
+		let e = () => {
+			if (N && Nt(l)) {
+				let e = Array.from(l.cells);
+				for (let [t, n] of e.entries()) n.style.width = N[t] ?? "";
+			}
+			o.status = "idle";
+			let e = t.current.translate != null, n = i.status.dragging;
+			k && (!n && e || k.parentElement !== g.parentElement) && g.isConnected && k.replaceWith(g), k?.remove();
+		};
+		g === this.overlay ? setTimeout(e, 0) : e();
+	}, I = r?.dropAnimation, L = this, R = s(() => {
+		let { transform: n, status: a } = i;
+		if (!(!n.x && !n.y && !t.current.translate) && a.dragging) {
+			let a = h.translate ?? {
+				x: 0,
+				y: 0
+			}, o = {
+				x: n.x / _.scaleX + a.x,
+				y: n.y / _.scaleY + a.y
+			}, s = t.current.translate, c = e(() => i.modifiers), l = e(() => i.shape?.current), f = r?.keyboardTransition, p = Te && !F && f !== null ? `${f?.duration ?? 250}ms ${f?.easing ?? "cubic-bezier(0.25, 1, 0.5, 1)"}` : "0ms linear";
+			if (w.set({
+				transition: _e ? `${_e}, translate ${p}` : `translate ${p}`,
+				translate: `${o.x}px ${o.y}px 0`
+			}, K), j?.takeRecords(), l && l !== He && s && !c.length) {
+				let e = u.delta(o, s);
+				i.shape = d.from(l.boundingRectangle).translate(e.x * _.scaleX, e.y * _.scaleY);
+			} else i.shape = new C(g);
+			t.current.translate = o;
+		}
+	}, function() {
+		if (i.status.dropped) {
+			this.dispose(), o.status = "dropping";
+			let e = f?.dropAnimation === void 0 ? L.dropAnimation === void 0 ? I : L.dropAnimation : f.dropAnimation, r = t.current.translate, i = r != null;
+			if (!r && l !== g && (r = {
+				x: 0,
+				y: 0
+			}), !r || e === null) {
+				qe();
+				return;
+			}
+			n.renderer.rendering.then(() => {
+				zt({
+					source: o,
+					element: l,
+					feedbackElement: g,
+					placeholder: k,
+					translate: r,
+					moved: i,
+					transition: ie,
+					alignment: o.alignment,
+					styles: w,
+					animation: e ?? void 0,
+					getElementMutationObserver: () => j,
+					cleanup: qe,
+					restoreFocus: Ke
+				});
+			});
+		}
+	});
+	return () => {
+		qe(), R();
+	};
+}, R(Ht, 4, "overlay", Bt, qt, Ut), I(Ht, qt), qt.configure = b(qt);
+var Jt = qt, Yt = !0, Xt = !1, Zt, Qt, $t, en = ($t = [c], T.Forward), J, tn, nn;
+Qt = (Zt = [c], T.Reverse);
+var rn = class {
+	constructor() {
+		B(this, tn, L(J, 8, this, Yt)), L(J, 11, this), B(this, nn, L(J, 12, this, Yt)), L(J, 15, this);
+	}
+	isLocked(e) {
+		return e === T.Idle ? !1 : e == null ? this[T.Forward] === Yt && this[T.Reverse] === Yt : this[e] === Yt;
+	}
+	unlock(e) {
+		e !== T.Idle && (this[e] = Xt);
+	}
+};
+J = F(null), tn = /* @__PURE__ */ new WeakMap(), nn = /* @__PURE__ */ new WeakMap(), R(J, 4, en, $t, rn, tn), R(J, 4, Qt, Zt, rn, nn), I(J, rn);
+var an = [T.Forward, T.Reverse], on = class {
+	constructor() {
+		this.x = new rn(), this.y = new rn();
+	}
+	isLocked() {
+		return this.x.isLocked() && this.y.isLocked();
+	}
+}, sn = class extends y {
+	constructor(e) {
+		super(e);
+		let i = r(new on()), a = null;
+		this.signal = i, t(() => {
+			let { status: t } = e.dragOperation;
+			if (!t.initialized) {
+				a = null, i.value = new on();
+				return;
+			}
+			let { delta: r } = e.dragOperation.position;
+			if (a) {
+				let e = {
+					x: cn(r.x, a.x),
+					y: cn(r.y, a.y)
+				}, t = i.peek();
+				n(() => {
+					for (let n of l) for (let r of an) e[n] === r && t[n].unlock(r);
+					i.value = t;
+				});
+			}
+			a = r;
+		});
+	}
+	get current() {
+		return this.signal.peek();
+	}
+};
+function cn(e, t) {
+	return Math.sign(e - t);
+}
+var ln, un, dn, fn, Y, pn, mn = class extends (un = h, ln = [c], un) {
+	constructor(e) {
+		super(e), B(this, fn, L(dn, 8, this, !1)), L(dn, 11, this), B(this, Y), B(this, pn, () => {
+			if (!z(this, Y)) return;
+			let { element: e, by: t } = z(this, Y);
+			t.y && (e.scrollTop += t.y), t.x && (e.scrollLeft += t.x);
+		}), this.scroll = (e, t) => {
+			if (this.disabled) return !1;
+			let n = this.getScrollableElements();
+			if (!n) return V(this, Y, void 0), !1;
+			let { position: r } = this.manager.dragOperation, i = r?.current;
+			if (i) {
+				let { by: r } = e ?? {}, a = r ? {
+					x: hn(r.x),
+					y: hn(r.y)
+				} : void 0, o = a ? void 0 : this.scrollIntentTracker.current;
+				if (o?.isLocked()) return !1;
+				for (let e of n) {
+					let n = ae(e, r);
+					if (n.x || n.y) {
+						let { speed: n, direction: s } = se(e, i, a, t?.acceleration, t?.threshold);
+						if (o) for (let e of l) o[e].isLocked(s[e]) && (n[e] = 0, s[e] = 0);
+						if (s.x || s.y) {
+							let { x: t, y: i } = r ?? s, a = t * n.x, o = i * n.y;
+							if (a || o) {
+								let t = z(this, Y)?.by;
+								if (this.autoScrolling && t && (t.x && !a || t.y && !o)) continue;
+								return V(this, Y, {
+									element: e,
+									by: {
+										x: a,
+										y: o
+									}
+								}), A.schedule(z(this, pn)), !0;
+							}
+						}
+					}
+				}
+			}
+			return V(this, Y, void 0), !1;
+		};
+		let t = null, n = null, r = i(() => {
+			let { position: n, source: r } = e.dragOperation;
+			if (!n) return null;
+			let i = fe(D(r?.element), n.current);
+			return i && (t = i), i ?? t;
+		}), o = i(() => {
+			let t = r.value, { documentElement: i } = ue(t);
+			if (!t || t === i) {
+				let { target: t } = e.dragOperation, r = t?.element;
+				if (r) {
+					let e = ve(r, { excludeElement: !1 });
+					return n = e, e;
+				}
+			}
+			if (t) {
+				let e = ve(t, { excludeElement: !1 });
+				return this.autoScrolling && n && e.size < n?.size ? n : (n = e, e);
+			}
+			return n = null, null;
+		}, a);
+		this.getScrollableElements = () => o.value, this.scrollIntentTracker = new sn(e), this.destroy = e.monitor.addEventListener("dragmove", (t) => {
+			this.disabled || t.defaultPrevented || !Se(e.dragOperation.activatorEvent) || !t.by || this.scroll({ by: t.by }) && t.preventDefault();
+		});
+	}
+};
+dn = F(un), fn = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ new WeakMap(), pn = /* @__PURE__ */ new WeakMap(), R(dn, 4, "autoScrolling", ln, mn, fn), I(dn, mn);
+function hn(e) {
+	return e > 0 ? T.Forward : e < 0 ? T.Reverse : T.Idle;
+}
+var gn = new class {
+	constructor(e) {
+		this.scheduler = e, this.pending = !1, this.tasks = /* @__PURE__ */ new Set(), this.resolvers = /* @__PURE__ */ new Set(), this.flush = () => {
+			let { tasks: e, resolvers: t } = this;
+			this.pending = !1, this.tasks = /* @__PURE__ */ new Set(), this.resolvers = /* @__PURE__ */ new Set();
+			for (let t of e) t();
+			for (let e of t) e();
+		};
+	}
+	schedule(e) {
+		return this.tasks.add(e), this.pending || (this.pending = !0, this.scheduler(this.flush)), new Promise((e) => this.resolvers.add(e));
+	}
+}((e) => {
+	typeof requestAnimationFrame == "function" ? requestAnimationFrame(e) : e();
+}), _n = 10, vn = class extends y {
+	constructor(e, n) {
+		super(e, n);
+		let r = e.registry.plugins.get(mn);
+		if (!r) throw Error("AutoScroller plugin depends on Scroller plugin");
+		this.destroy = t(() => {
+			if (this.disabled) return;
+			let { position: t, status: n } = e.dragOperation;
+			if (n.dragging) {
+				let e = {
+					acceleration: this.options?.acceleration,
+					threshold: typeof this.options?.threshold == "number" ? {
+						x: this.options.threshold,
+						y: this.options.threshold
+					} : this.options?.threshold
+				};
+				if (r.scroll(void 0, e)) {
+					r.autoScrolling = !0;
+					let t = setInterval(() => gn.schedule(() => r.scroll(void 0, e)), _n);
+					return () => {
+						clearInterval(t);
+					};
+				} else r.autoScrolling = !1;
+			}
+		});
+	}
+};
+vn.configure = b(vn);
+var yn = vn, bn = {
+	capture: !0,
+	passive: !0
+}, xn, Sn = class extends h {
+	constructor(e) {
+		super(e), B(this, xn), this.handleScroll = () => {
+			z(this, xn) ?? V(this, xn, setTimeout(() => {
+				this.manager.collisionObserver.forceUpdate(!1), V(this, xn, void 0);
+			}, 50));
+		};
+		let { dragOperation: n } = this.manager;
+		this.destroy = t(() => {
+			if (n.status.dragging) {
+				let e = n.source?.element?.ownerDocument ?? document;
+				return e.addEventListener("scroll", this.handleScroll, bn), () => {
+					e.removeEventListener("scroll", this.handleScroll, bn);
+				};
+			}
+		});
+	}
+};
+xn = /* @__PURE__ */ new WeakMap();
+var Cn = "* { user-select: none !important; -webkit-user-select: none !important; }", wn = class extends y {
+	constructor(e) {
+		super(e), this.manager = e;
+		let n = e.registry.plugins.get(yt)?.register(Cn);
+		if (this.destroy = t(() => {
+			let { dragOperation: e } = this.manager;
+			if (e.status.initialized) return Tn(), document.addEventListener("selectionchange", Tn, { capture: !0 }), () => {
+				document.removeEventListener("selectionchange", Tn, { capture: !0 });
+			};
+		}), n) {
+			let e = this.destroy.bind(this);
+			this.destroy = () => {
+				n(), e();
+			};
+		}
+	}
+};
+function Tn() {
+	var e;
+	(e = document.getSelection()) == null || e.removeAllRanges();
+}
+var En = Object.freeze({
+	offset: 10,
+	keyboardCodes: {
+		start: ["Space", "Enter"],
+		cancel: ["Escape"],
+		end: [
+			"Space",
+			"Enter",
+			"Tab"
+		],
+		up: ["ArrowUp"],
+		down: ["ArrowDown"],
+		left: ["ArrowLeft"],
+		right: ["ArrowRight"]
+	},
+	preventActivation(e, t) {
+		let n = t.handle ?? t.element;
+		return e.target !== n;
+	}
+}), Dn, On = class extends ee {
+	constructor(e, t) {
+		super(e), this.manager = e, this.options = t, B(this, Dn, []), this.listeners = new ne(), this.handleSourceKeyDown = (e, t, n) => {
+			if (this.disabled || e.defaultPrevented || !O(e.target) || t.disabled) return;
+			let { keyboardCodes: r = En.keyboardCodes, preventActivation: i = En.preventActivation } = n ?? {};
+			r.start.includes(e.code) && this.manager.dragOperation.status.idle && (i?.(e, t) || this.handleStart(e, t, n));
+		};
+	}
+	bind(e, n = this.options) {
+		return t(() => {
+			let t = e.handle ?? e.element, r = (t) => {
+				Se(t) && this.handleSourceKeyDown(t, e, n);
+			};
+			if (t) return t.addEventListener("keydown", r), () => {
+				t.removeEventListener("keydown", r);
+			};
+		});
+	}
+	handleStart(e, t, n) {
+		let { element: r } = t;
+		if (!r) throw Error("Source draggable does not have an associated element");
+		e.preventDefault(), e.stopImmediatePropagation(), ke(r);
+		let { center: i } = new C(r);
+		if (this.manager.actions.start({
+			event: e,
+			coordinates: {
+				x: i.x,
+				y: i.y
+			},
+			source: t
+		}).signal.aborted) return this.cleanup();
+		this.sideEffects();
+		let a = ue(r), o = [this.listeners.bind(a, [{
+			type: "keydown",
+			listener: (e) => this.handleKeyDown(e, t, n),
+			options: { capture: !0 }
+		}])];
+		z(this, Dn).push(...o);
+	}
+	handleKeyDown(e, t, n) {
+		let { keyboardCodes: r = En.keyboardCodes } = n ?? {};
+		if (An(e, [...r.end, ...r.cancel])) {
+			e.preventDefault();
+			let t = An(e, r.cancel);
+			this.handleEnd(e, t);
+			return;
+		}
+		An(e, r.up) ? this.handleMove("up", e) : An(e, r.down) && this.handleMove("down", e), An(e, r.left) ? this.handleMove("left", e) : An(e, r.right) && this.handleMove("right", e);
+	}
+	handleEnd(e, t) {
+		this.manager.actions.stop({
+			event: e,
+			canceled: t
+		}), this.cleanup();
+	}
+	handleMove(e, t) {
+		let { shape: n } = this.manager.dragOperation, r = t.shiftKey ? 5 : 1, i = {
+			x: 0,
+			y: 0
+		}, a = this.options?.offset ?? En.offset;
+		if (typeof a == "number" && (a = {
+			x: a,
+			y: a
+		}), n) {
+			switch (e) {
+				case "up":
+					i = {
+						x: 0,
+						y: -a.y * r
+					};
+					break;
+				case "down":
+					i = {
+						x: 0,
+						y: a.y * r
+					};
+					break;
+				case "left":
+					i = {
+						x: -a.x * r,
+						y: 0
+					};
+					break;
+				case "right":
+					i = {
+						x: a.x * r,
+						y: 0
+					};
+					break;
+			}
+			(i.x || i.y) && (t.preventDefault(), this.manager.actions.move({
+				event: t,
+				by: i
+			}));
+		}
+	}
+	sideEffects() {
+		let e = this.manager.registry.plugins.get(yn);
+		e?.disabled === !1 && (e.disable(), z(this, Dn).push(() => {
+			e.enable();
+		}));
+	}
+	cleanup() {
+		z(this, Dn).forEach((e) => e()), V(this, Dn, []);
+	}
+	destroy() {
+		this.cleanup(), this.listeners.clear();
+	}
+};
+Dn = /* @__PURE__ */ new WeakMap(), On.configure = b(On), On.defaults = En;
+var kn = On;
+function An(e, t) {
+	return t.includes(e.code);
+}
+var X, jn = class extends p {
+	constructor() {
+		super(...arguments), B(this, X);
+	}
+	onEvent(e) {
+		switch (e.type) {
+			case "pointerdown":
+				V(this, X, E(e));
+				break;
+			case "pointermove":
+				if (!z(this, X)) return;
+				let { x: t, y: n } = E(e), r = {
+					x: t - z(this, X).x,
+					y: n - z(this, X).y
+				}, { tolerance: i } = this.options;
+				if (i && f(r, i)) {
+					this.abort();
+					return;
+				}
+				f(r, this.options.value) && this.activate(e);
+				break;
+			case "pointerup":
+				this.abort();
+				break;
+		}
+	}
+	abort() {
+		V(this, X, void 0);
+	}
+};
+X = /* @__PURE__ */ new WeakMap();
+var Mn, Z, Nn = class extends p {
+	constructor() {
+		super(...arguments), B(this, Mn), B(this, Z);
+	}
+	onEvent(e) {
+		switch (e.type) {
+			case "pointerdown":
+				V(this, Z, E(e)), V(this, Mn, setTimeout(() => this.activate(e), this.options.value));
+				break;
+			case "pointermove":
+				if (!z(this, Z)) return;
+				let { x: t, y: n } = E(e);
+				f({
+					x: t - z(this, Z).x,
+					y: n - z(this, Z).y
+				}, this.options.tolerance) && this.abort();
+				break;
+			case "pointerup":
+				this.abort();
+				break;
+		}
+	}
+	abort() {
+		z(this, Mn) && (clearTimeout(z(this, Mn)), V(this, Z, void 0), V(this, Mn, void 0));
+	}
+};
+Mn = /* @__PURE__ */ new WeakMap(), Z = /* @__PURE__ */ new WeakMap();
+var Pn = class {};
+Pn.Delay = Nn, Pn.Distance = jn;
+var Fn = Object.freeze({
+	activationConstraints(e, t) {
+		let { pointerType: n, target: r } = e;
+		if (!(n === "mouse" && O(r) && (t.handle === r || t.handle?.contains(r)))) return n === "touch" ? [new Pn.Delay({
+			value: 250,
+			tolerance: 5
+		})] : Te(r) && !e.defaultPrevented ? [new Pn.Delay({
+			value: 200,
+			tolerance: 0
+		})] : [new Pn.Delay({
+			value: 200,
+			tolerance: 10
+		}), new Pn.Distance({ value: 5 })];
+	},
+	preventActivation(e, t) {
+		let { target: n } = e;
+		if (n === t.element || n === t.handle || !O(n) || t.handle?.contains(n)) return !1;
+		let r = _e(n);
+		return r === t.element ? !1 : !!r;
+	}
+}), In, Ln = class extends ee {
+	constructor(e, t) {
+		super(e), this.manager = e, this.options = t, B(this, In, /* @__PURE__ */ new Set()), this.listeners = new ne(), this.latest = {
+			event: void 0,
+			coordinates: void 0
+		}, this.handleMove = () => {
+			let { event: e, coordinates: t } = this.latest;
+			!e || !t || this.manager.actions.move({
+				event: e,
+				to: t
+			});
+		}, this.handleCancel = this.handleCancel.bind(this), this.handlePointerUp = this.handlePointerUp.bind(this), this.handleKeyDown = this.handleKeyDown.bind(this);
+	}
+	activationConstraints(e, t, n = this.options) {
+		let { activationConstraints: r = Fn.activationConstraints } = n ?? {};
+		return typeof r == "function" ? r(e, t) : r;
+	}
+	bind(e, n = this.options) {
+		return t(() => {
+			let t = new AbortController(), { signal: r } = t, i = (t) => {
+				Ce(t) && this.handlePointerDown(t, e, n);
+			}, a = [e.handle ?? e.element];
+			n?.activatorElements && (a = Array.isArray(n.activatorElements) ? n.activatorElements : n.activatorElements(e));
+			for (let e of a) e && (Un(e.ownerDocument.defaultView), e.addEventListener("pointerdown", i, { signal: r }));
+			return () => t.abort();
+		});
+	}
+	handlePointerDown(e, t, n) {
+		if (this.disabled || !e.isPrimary || e.button !== 0 || !O(e.target) || t.disabled || zn(e) || !this.manager.dragOperation.status.idle) return;
+		let { preventActivation: r = Fn.preventActivation } = n ?? {};
+		if (r?.(e, t)) return;
+		let { target: i } = e, a = xe(i) && i.draggable && i.getAttribute("draggable") === "true", o = ge(t.element), { x: s, y: c } = E(e);
+		this.initialCoordinates = {
+			x: s * o.scaleX + o.x,
+			y: c * o.scaleY + o.y
+		};
+		let l = this.activationConstraints(e, t, n);
+		e.sensor = this;
+		let u = new m(l, (e) => this.handleStart(t, e));
+		u.signal.onabort = () => this.handleCancel(e), u.onEvent(e), this.controller = u;
+		let d = de(), f = this.listeners.bind(d, [
+			{
+				type: "pointermove",
+				listener: (e) => this.handlePointerMove(e, t)
+			},
+			{
+				type: "pointerup",
+				listener: this.handlePointerUp,
+				options: { capture: !0 }
+			},
+			{
+				type: "pointercancel",
+				listener: this.handleCancel
+			},
+			{
+				type: "dragstart",
+				listener: a ? this.handleCancel : Bn,
+				options: { capture: !0 }
+			}
+		]);
+		z(this, In).add(() => {
+			f(), this.initialCoordinates = void 0;
+		});
+	}
+	handlePointerMove(e, t) {
+		var n;
+		if (this.controller?.activated === !1) {
+			(n = this.controller) == null || n.onEvent(e);
+			return;
+		}
+		if (this.manager.dragOperation.status.dragging) {
+			let n = E(e), r = ge(t.element);
+			n.x = n.x * r.scaleX + r.x, n.y = n.y * r.scaleY + r.y, e.preventDefault(), e.stopPropagation(), this.latest.event = e, this.latest.coordinates = n, A.schedule(this.handleMove);
+		}
+	}
+	handlePointerUp(e) {
+		let { status: t } = this.manager.dragOperation;
+		if (!t.idle) {
+			e.preventDefault(), e.stopPropagation();
+			let n = !t.initialized;
+			this.manager.actions.stop({
+				event: e,
+				canceled: n
+			});
+		}
+		this.cleanup();
+	}
+	handleKeyDown(e) {
+		e.key === "Escape" && (e.preventDefault(), this.handleCancel(e));
+	}
+	handleStart(e, t) {
+		let { manager: n, initialCoordinates: r } = this;
+		if (!r || !n.dragOperation.status.idle || t.defaultPrevented) return;
+		if (n.actions.start({
+			coordinates: r,
+			event: t,
+			source: e
+		}).signal.aborted) return this.cleanup();
+		t.preventDefault();
+		let i = ue(t.target).body;
+		try {
+			i.setPointerCapture(t.pointerId);
+		} catch {
+			this.handleCancel(t);
+			return;
+		}
+		let a = O(t.target) ? [t.target, i] : i, o = this.listeners.bind(a, [
+			{
+				type: "touchmove",
+				listener: Bn,
+				options: { passive: !1 }
+			},
+			{
+				type: "click",
+				listener: Bn
+			},
+			{
+				type: "contextmenu",
+				listener: Bn
+			},
+			{
+				type: "keydown",
+				listener: this.handleKeyDown
+			}
+		]);
+		z(this, In).add(o);
+	}
+	handleCancel(e) {
+		let { dragOperation: t } = this.manager;
+		t.status.initialized && this.manager.actions.stop({
+			event: e,
+			canceled: !0
+		}), this.cleanup();
+	}
+	cleanup() {
+		let { controller: e } = this;
+		this.controller = void 0, e && !e.signal.aborted && e.abort(), this.latest = {
+			event: void 0,
+			coordinates: void 0
+		}, z(this, In).forEach((e) => e()), z(this, In).clear();
+	}
+	destroy() {
+		this.cleanup(), this.listeners.clear();
+	}
+};
+In = /* @__PURE__ */ new WeakMap(), Ln.configure = b(Ln), Ln.defaults = Fn;
+var Rn = Ln;
+function zn(e) {
+	return "sensor" in e;
+}
+function Bn(e) {
+	e.preventDefault();
+}
+function Vn() {}
+var Hn = /* @__PURE__ */ new WeakSet();
+function Un(e) {
+	!e || Hn.has(e) || (e.addEventListener("touchmove", Vn, {
+		capture: !1,
+		passive: !1
+	}), Hn.add(e));
+}
+var Wn = {
+	modifiers: [],
+	plugins: [
+		at,
+		yn,
+		bt,
+		Jt,
+		wn
+	],
+	sensors: [Rn, kn]
+}, Gn = class extends g {
+	constructor(e = {}) {
+		let t = S(e.plugins, Wn.plugins), n = S(e.sensors, Wn.sensors), r = S(e.modifiers, Wn.modifiers);
+		super(He(P({}, e), {
+			plugins: [
+				Sn,
+				mn,
+				yt,
+				...t
+			],
+			sensors: n,
+			modifiers: r
+		}));
+	}
+}, Kn, qn, Jn, Q, Yn, Xn, Zn = class extends (Jn = _, qn = [c], Kn = [c], Jn) {
+	constructor(e, t) {
+		var n = e, { element: r, effects: i = () => [], handle: a } = n, o = We(n, [
+			"element",
+			"effects",
+			"handle"
+		]);
+		super(P({ effects: () => [...i(), () => {
+			let { manager: e } = this;
+			if (!e) return;
+			let t = (this.sensors?.map(x) ?? [...e.sensors]).map((t) => {
+				let n = t instanceof ee ? t : e.registry.register(t.plugin), r = t instanceof ee ? void 0 : t.options;
+				return n.bind(this, r);
+			});
+			return function() {
+				t.forEach((e) => e());
+			};
+		}] }, o), t), B(this, Yn, L(Q, 8, this)), L(Q, 11, this), B(this, Xn, L(Q, 12, this)), L(Q, 15, this), this.element = r, this.handle = a;
+	}
+};
+Q = F(Jn), Yn = /* @__PURE__ */ new WeakMap(), Xn = /* @__PURE__ */ new WeakMap(), R(Q, 4, "handle", qn, Zn, Yn), R(Q, 4, "element", Kn, Zn, Xn), I(Q, Zn);
+var Qn, $n, er, $, tr, nr, rr, ir, ar, or, sr = class extends (er = v, $n = [c], Qn = [c], er) {
+	constructor(t, n) {
+		var i = t, { element: a, effects: o = () => [] } = i, s = We(i, ["element", "effects"]);
+		let { collisionDetector: c = Ne } = s, l = (t) => {
+			let { manager: n, element: r } = this;
+			if (!r || t === null) {
+				this.shape = void 0;
+				return;
+			}
+			if (!n) return;
+			let i = new C(r), a = e(() => this.shape);
+			return i && a?.equals(i) ? a : (this.shape = i, i);
+		}, u = r(!1);
+		super(He(P({}, s), {
+			collisionDetector: c,
+			effects: () => [
+				...o(),
+				() => {
+					let { element: e, manager: t } = this;
+					if (!t) return;
+					let { dragOperation: n } = t, { source: r } = n;
+					u.value = !!(r && n.status.initialized && e && !this.disabled && this.accepts(r));
+				},
+				() => {
+					let { element: e } = this;
+					if (u.value && e) {
+						let t = new te(e, l);
+						return () => {
+							t.disconnect(), this.shape = void 0;
+						};
+					}
+				},
+				() => {
+					if (this.manager?.dragOperation.status.initialized) return () => {
+						this.shape = void 0;
+					};
+				}
+			]
+		}), n), B(this, ar), B(this, tr, L($, 8, this)), L($, 11, this), B(this, or, L($, 12, this)), L($, 15, this), this.element = a, this.refreshShape = () => l();
+	}
+	set element(e) {
+		V(this, ar, e, ir);
+	}
+	get element() {
+		return this.proxy ?? z(this, ar, rr);
+	}
+};
+$ = F(er), tr = /* @__PURE__ */ new WeakMap(), ar = /* @__PURE__ */ new WeakSet(), or = /* @__PURE__ */ new WeakMap(), nr = R($, 20, "#element", $n, ar, tr), rr = nr.get, ir = nr.set, R($, 4, "proxy", Qn, sr, or), I($, sr);
+//#endregion
+export { Gn as DragDropManager, Zn as Draggable, sr as Droppable, Jt as Feedback, kn as KeyboardSensor, Rn as PointerSensor, mn as Scroller, Wn as defaultPreset };