tembro 3.0.0 → 3.1.5

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

@@ -0,0 +1,673 @@
+import { f as e, j as t, n, y as r } from "../../@preact/signals-core/dist/signals-core.module.js";
+import { ValueHistory as i, derived as a, effects as o, reactive as s, snapshot as c } from "../state/dist/index.js";
+import { Position as l } from "../geometry/dist/index.js";
+//#region node_modules/@dnd-kit/abstract/index.js
+var u = Object.create, ee = Object.defineProperty, d = Object.defineProperties, te = Object.getOwnPropertyDescriptor, f = Object.getOwnPropertyDescriptors, p = Object.getOwnPropertySymbols, m = Object.prototype.hasOwnProperty, h = Object.prototype.propertyIsEnumerable, g = (e, t) => (t = Symbol[e]) ? t : Symbol.for("Symbol." + e), _ = (e) => {
+	throw TypeError(e);
+}, v = (e, t, n) => t in e ? ee(e, t, {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: n
+}) : e[t] = n, y = (e, t) => {
+	for (var n in t ||= {}) m.call(t, n) && v(e, n, t[n]);
+	if (p) for (var n of p(t)) h.call(t, n) && v(e, n, t[n]);
+	return e;
+}, b = (e, t) => d(e, f(t)), ne = (e, t) => ee(e, "name", {
+	value: t,
+	configurable: !0
+}), re = (e, t) => {
+	var n = {};
+	for (var r in e) m.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+	if (e != null && p) for (var r of p(e)) t.indexOf(r) < 0 && h.call(e, r) && (n[r] = e[r]);
+	return n;
+}, x = (e) => [
+	,
+	,
+	,
+	u(e?.[g("metadata")] ?? null)
+], ie = [
+	"class",
+	"method",
+	"getter",
+	"setter",
+	"accessor",
+	"field",
+	"value",
+	"get",
+	"set"
+], S = (e) => e !== void 0 && typeof e != "function" ? _("Function expected") : e, ae = (e, t, n, r, i) => ({
+	kind: ie[e],
+	name: t,
+	metadata: r,
+	addInitializer: (e) => n._ ? _("Already initialized") : i.push(S(e || null))
+}), C = (e, t) => v(t, g("metadata"), e[3]), w = (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;
+}, T = (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 = ie[d + 5], g = d > 3 && (e[m - 1] = []), v = e[m] || (e[m] = []), y = d && (!p && !f && (i = i.prototype), d < 5 && (d > 3 || !p) && te(d < 4 ? i : {
+		get [n]() {
+			return E(this, a);
+		},
+		set [n](e) {
+			return O(this, a, e);
+		}
+	}, n));
+	d ? p && d < 4 && ne(a, (d > 2 ? "set " : d > 1 ? "get " : "") + n) : ne(i, n);
+	for (var b = r.length - 1; b >= 0; b--) l = ae(d, n, c = {}, e[3], v), d && (l.static = f, l.private = p, u = l.access = { has: p ? (e) => se(i, e) : (e) => n in e }, d ^ 3 && (u.get = p ? (e) => (d ^ 1 ? E : ce)(e, i, d ^ 4 ? a : y.get) : (e) => e[n]), d > 2 && (u.set = p ? (e, t) => O(e, i, t, d ^ 4 ? a : y.set) : (e, t) => e[n] = t)), s = (0, r[b])(d ? d < 4 ? p ? a : y[h] : d > 4 ? void 0 : {
+		get: y.get,
+		set: y.set
+	} : i, l), c._ = 1, d ^ 4 || s === void 0 ? S(s) && (d > 4 ? g.unshift(s) : d ? p ? a = s : y[h] = s : i = s) : typeof s != "object" || !s ? _("Object expected") : (S(o = s.get) && (y.get = o), S(o = s.set) && (y.set = o), S(o = s.init) && g.unshift(o));
+	return d || C(e, i), y && ee(i, n, y), p ? d ^ 4 ? a : y : i;
+}, oe = (e, t, n) => t.has(e) || _("Cannot " + n), se = (e, t) => Object(t) === t ? e.has(t) : _("Cannot use the \"in\" operator on this value"), E = (e, t, n) => (oe(e, t, "read from private field"), n ? n.call(e) : t.get(e)), D = (e, t, n) => t.has(e) ? _("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), O = (e, t, n, r) => (oe(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), ce = (e, t, n) => (oe(e, t, "access private method"), n);
+function le(e, t) {
+	return {
+		plugin: e,
+		options: t
+	};
+}
+function ue(e) {
+	return (t) => le(e, t);
+}
+function k(e) {
+	return typeof e == "function" ? {
+		plugin: e,
+		options: void 0
+	} : e;
+}
+var de = [s], A, fe, pe, j = class {
+	constructor(e, t) {
+		this.manager = e, this.options = t, D(this, fe, w(A, 8, this, !1)), w(A, 11, this), D(this, pe, /* @__PURE__ */ new Set());
+	}
+	enable() {
+		this.disabled = !1;
+	}
+	disable() {
+		this.disabled = !0;
+	}
+	isDisabled() {
+		return e(() => this.disabled);
+	}
+	configure(e) {
+		this.options = e;
+	}
+	registerEffect(e) {
+		let n = t(e.bind(this));
+		return E(this, pe).add(n), n;
+	}
+	destroy() {
+		E(this, pe).forEach((e) => e());
+	}
+	static configure(e) {
+		return le(this, e);
+	}
+};
+A = x(null), fe = /* @__PURE__ */ new WeakMap(), pe = /* @__PURE__ */ new WeakMap(), T(A, 4, "disabled", de, j, fe), C(A, j);
+var me = class extends j {}, M, he = class {
+	constructor(e) {
+		this.manager = e, this.instances = /* @__PURE__ */ new Map(), D(this, M, []);
+	}
+	get values() {
+		return Array.from(this.instances.values());
+	}
+	set values(e) {
+		let t = e.map(k).reduce((e, t) => {
+			let n = e.find(({ plugin: e }) => e === t.plugin);
+			return n ? (n.options = t.options, e) : [...e, t];
+		}, []), n = t.map(({ plugin: e }) => e);
+		for (let e of E(this, M)) if (!n.includes(e)) {
+			if (e.prototype instanceof me) continue;
+			this.unregister(e);
+		}
+		for (let { plugin: e, options: n } of t) this.register(e, n);
+		O(this, M, n);
+	}
+	get(e) {
+		return this.instances.get(e);
+	}
+	register(e, t) {
+		let n = this.instances.get(e);
+		if (n) return n.options !== t && (n.options = t), n;
+		let r = new e(this.manager, t);
+		return this.instances.set(e, r), r;
+	}
+	unregister(e) {
+		let t = this.instances.get(e);
+		t && (t.destroy(), this.instances.delete(e));
+	}
+	destroy() {
+		for (let e of this.instances.values()) e.destroy();
+		this.instances.clear();
+	}
+};
+M = /* @__PURE__ */ new WeakMap();
+function ge(e, t) {
+	return e.priority === t.priority ? e.type === t.type ? t.value - e.value : t.type - e.type : t.priority - e.priority;
+}
+var N = [], P, F, _e = class extends j {
+	constructor(t) {
+		super(t), D(this, P), D(this, F), this.computeCollisions = this.computeCollisions.bind(this), O(this, F, r(N)), this.destroy = o(() => {
+			let t = this.computeCollisions(), n = e(() => this.manager.dragOperation.position.current);
+			if (t !== N) {
+				let e = E(this, P);
+				if (O(this, P, n), e && n.x == e.x && n.y == e.y) return;
+			} else O(this, P, void 0);
+			E(this, F).value = t;
+		}, () => {
+			let { dragOperation: e } = this.manager;
+			e.status.initialized && this.forceUpdate();
+		});
+	}
+	forceUpdate(t = !0) {
+		e(() => {
+			t ? E(this, F).value = this.computeCollisions() : O(this, P, void 0);
+		});
+	}
+	computeCollisions(t, n) {
+		let { registry: r, dragOperation: i } = this.manager, { source: a, shape: o, status: s } = i;
+		if (!s.initialized || !o) return N;
+		let c = [], l = [];
+		for (let o of t ?? r.droppables) {
+			if (o.disabled || a && !o.accepts(a)) continue;
+			let t = n ?? o.collisionDetector;
+			if (!t) continue;
+			l.push(o), o.shape;
+			let r = e(() => t({
+				droppable: o,
+				dragOperation: i
+			}));
+			r && (o.collisionPriority != null && (r.priority = o.collisionPriority), c.push(r));
+		}
+		return l.length === 0 ? N : (c.sort(ge), c);
+	}
+	get collisions() {
+		return E(this, F).value;
+	}
+};
+P = /* @__PURE__ */ new WeakMap(), F = /* @__PURE__ */ new WeakMap();
+var ve, ye, be = [s], xe, Se, I, Ce, L, we, Te;
+ye = [s], ve = [s];
+var R = class e {
+	constructor(e, t) {
+		D(this, Ce, w(I, 8, this)), w(I, 11, this), D(this, L), D(this, we, w(I, 12, this)), w(I, 15, this), D(this, Te, w(I, 16, this)), w(I, 19, this);
+		let { effects: n, id: i, data: a = {}, disabled: o = !1, register: s = !0 } = e, c = i;
+		O(this, L, r(i)), this.manager = t, this.data = a, this.disabled = o, this.effects = () => [() => {
+			let { id: e, manager: t } = this;
+			if (e !== c) return c = e, t?.registry.register(this), () => t?.registry.unregister(this);
+		}, ...n?.() ?? []], this.register = this.register.bind(this), this.unregister = this.unregister.bind(this), this.destroy = this.destroy.bind(this), t && s && queueMicrotask(this.register);
+	}
+	get id() {
+		let t = E(this, L).value;
+		return e.pendingIdChanges?.get(this) ?? t;
+	}
+	set id(t) {
+		t !== (e.pendingIdChanges?.get(this) ?? E(this, L).peek()) && (e.pendingIdChanges || (e.pendingIdChanges = /* @__PURE__ */ new Map(), queueMicrotask(() => {
+			var t;
+			return ce(t = e, xe, Se).call(t);
+		})), e.pendingIdChanges.set(this, t));
+	}
+	register() {
+		return this.manager?.registry.register(this);
+	}
+	unregister() {
+		var e;
+		(e = this.manager) == null || e.registry.unregister(this);
+	}
+	destroy() {
+		var e;
+		(e = this.manager) == null || e.registry.unregister(this);
+	}
+};
+I = x(null), xe = /* @__PURE__ */ new WeakSet(), Se = function() {
+	let e = R.pendingIdChanges;
+	R.pendingIdChanges = null, e && n(() => {
+		for (let [t, n] of e) E(t, L).value = n;
+	});
+}, Ce = /* @__PURE__ */ new WeakMap(), L = /* @__PURE__ */ new WeakMap(), we = /* @__PURE__ */ new WeakMap(), Te = /* @__PURE__ */ new WeakMap(), T(I, 4, "manager", be, R, Ce), T(I, 4, "data", ye, R, we), T(I, 4, "disabled", ve, R, Te), D(R, xe), C(I, R), R.pendingIdChanges = null;
+var z = R, Ee = class {
+	constructor() {
+		this.map = r(/* @__PURE__ */ new Map()), this.cleanupFunctions = /* @__PURE__ */ new WeakMap(), this.register = (e, t) => {
+			let n = this.map.peek(), r = n.get(e), i = () => this.unregister(e, t);
+			if (r === t) return i;
+			r && r.id === e && (this.cleanupFunctions.get(r)?.(), this.cleanupFunctions.delete(r));
+			let a = new Map(n);
+			for (let [r, i] of n) if (i === t && r !== e) {
+				a.delete(r);
+				break;
+			}
+			a.set(e, t), this.map.value = a;
+			let s = o(...t.effects());
+			return this.cleanupFunctions.set(t, s), i;
+		}, this.unregister = (e, t) => {
+			let n = this.map.peek();
+			if (n.get(e) !== t) return;
+			this.cleanupFunctions.get(t)?.(), this.cleanupFunctions.delete(t);
+			let r = new Map(n);
+			r.delete(e), this.map.value = r;
+		};
+	}
+	[Symbol.iterator]() {
+		return this.map.peek().values();
+	}
+	get value() {
+		return this.map.value.values();
+	}
+	has(e) {
+		return this.map.value.has(e);
+	}
+	get(e) {
+		return this.map.value.get(e);
+	}
+	destroy() {
+		for (let e of this) this.cleanupFunctions.get(e)?.(), e.destroy();
+		this.map.value = /* @__PURE__ */ new Map();
+	}
+}, De, Oe, ke, Ae, je, Me, Ne, B, Pe, Fe, Ie, V = class extends (Ne = z, Me = [s], je = [s], Ae = [s], ke = [a], Oe = [a], De = [a], Ne) {
+	constructor(e, t) {
+		var n = e, { modifiers: r, type: i, sensors: a, plugins: o, effects: s } = n, c = re(n, [
+			"modifiers",
+			"type",
+			"sensors",
+			"plugins",
+			"effects"
+		]);
+		super(b(y({}, c), { effects: () => [...s?.() ?? [], () => {
+			let { manager: e, plugins: t } = this;
+			if (!(!e || !t)) for (let n of t) {
+				let { plugin: t } = k(n);
+				e.registry.plugins.register(t);
+			}
+		}] }), t), w(B, 5, this), D(this, Pe, w(B, 8, this)), w(B, 11, this), D(this, Fe, w(B, 12, this)), w(B, 15, this), D(this, Ie, w(B, 16, this, this.isDragSource ? "dragging" : "idle")), w(B, 19, this), this.type = i, this.sensors = a, this.modifiers = r, this.alignment = c.alignment, this.plugins = o;
+	}
+	pluginConfig(e) {
+		if (this.plugins) for (let t of this.plugins) {
+			let n = k(t);
+			if (n.plugin === e) return n.options;
+		}
+	}
+	get isDropping() {
+		return this.status === "dropping" && this.isDragSource;
+	}
+	get isDragging() {
+		return this.status === "dragging" && this.isDragSource;
+	}
+	get isDragSource() {
+		return this.manager?.dragOperation.source?.id === this.id;
+	}
+};
+B = x(Ne), Pe = /* @__PURE__ */ new WeakMap(), Fe = /* @__PURE__ */ new WeakMap(), Ie = /* @__PURE__ */ new WeakMap(), T(B, 4, "type", Me, V, Pe), T(B, 4, "modifiers", je, V, Fe), T(B, 4, "status", Ae, V, Ie), T(B, 2, "isDropping", ke, V), T(B, 2, "isDragging", Oe, V), T(B, 2, "isDragSource", De, V), C(B, V);
+var Le, Re, ze, Be, Ve, He, Ue, H, We, Ge, Ke, qe, Je, U = class extends (Ue = z, He = [s], Ve = [s], Be = [s], ze = [s], Re = [s], Le = [a], Ue) {
+	constructor(e, t) {
+		var n = e, { accept: r, collisionDetector: i, collisionPriority: a, type: o } = n, s = re(n, [
+			"accept",
+			"collisionDetector",
+			"collisionPriority",
+			"type"
+		]);
+		super(s, t), w(H, 5, this), D(this, We, w(H, 8, this)), w(H, 11, this), D(this, Ge, w(H, 12, this)), w(H, 15, this), D(this, Ke, w(H, 16, this)), w(H, 19, this), D(this, qe, w(H, 20, this)), w(H, 23, this), D(this, Je, w(H, 24, this)), w(H, 27, this), this.accept = r, this.collisionDetector = i, this.collisionPriority = a, this.type = o;
+	}
+	accepts(e) {
+		let { accept: t } = this;
+		return t ? typeof t == "function" ? t(e) : e.type ? Array.isArray(t) ? t.includes(e.type) : e.type === t : !1 : !0;
+	}
+	get isDropTarget() {
+		return this.manager?.dragOperation.target?.id === this.id;
+	}
+};
+H = x(Ue), We = /* @__PURE__ */ new WeakMap(), Ge = /* @__PURE__ */ new WeakMap(), Ke = /* @__PURE__ */ new WeakMap(), qe = /* @__PURE__ */ new WeakMap(), Je = /* @__PURE__ */ new WeakMap(), T(H, 4, "accept", He, U, We), T(H, 4, "type", Ve, U, Ge), T(H, 4, "collisionDetector", Be, U, Ke), T(H, 4, "collisionPriority", ze, U, qe), T(H, 4, "shape", Re, U, Je), T(H, 2, "isDropTarget", Le, U), C(H, U);
+var Ye = class {
+	constructor() {
+		this.registry = /* @__PURE__ */ new Map();
+	}
+	addEventListener(e, t) {
+		let { registry: n } = this, r = new Set(n.get(e));
+		return r.add(t), n.set(e, r), () => this.removeEventListener(e, t);
+	}
+	removeEventListener(e, t) {
+		let { registry: n } = this, r = new Set(n.get(e));
+		r.delete(t), n.set(e, r);
+	}
+	dispatch(e, ...t) {
+		let { registry: n } = this, r = n.get(e);
+		if (r) for (let e of r) e(...t);
+	}
+}, Xe = class extends Ye {
+	constructor(e) {
+		super(), this.manager = e;
+	}
+	dispatch(e, t) {
+		let n = [t, this.manager];
+		super.dispatch(e, ...n);
+	}
+};
+function W(e, t = !0) {
+	let n = !1;
+	return b(y({}, e), {
+		cancelable: t,
+		get defaultPrevented() {
+			return n;
+		},
+		preventDefault() {
+			t && (n = !0);
+		}
+	});
+}
+var Ze = class extends me {
+	constructor(t) {
+		super(t);
+		let n = (e, t) => e.map(({ id: e }) => e).join("") === t.map(({ id: e }) => e).join(""), r = [];
+		this.destroy = o(() => {
+			let { dragOperation: e, collisionObserver: n } = t;
+			e.status.initializing && (r = [], n.enable());
+		}, () => {
+			let { collisionObserver: i, monitor: a } = t, { collisions: o } = i;
+			if (i.isDisabled() || z.pendingIdChanges) return;
+			let s = W({ collisions: o });
+			if (a.dispatch("collision", s), s.defaultPrevented || n(o, r)) return;
+			r = o;
+			let [c] = o;
+			e(() => {
+				c?.id !== t.dragOperation.target?.id && (i.disable(), t.actions.setDropTarget(c?.id).then(() => {
+					i.enable();
+				}));
+			});
+		});
+	}
+}, Qe = /* @__PURE__ */ ((e) => (e[e.Lowest = 0] = "Lowest", e[e.Low = 1] = "Low", e[e.Normal = 2] = "Normal", e[e.High = 3] = "High", e[e.Highest = 4] = "Highest", e))(Qe || {}), $e = /* @__PURE__ */ ((e) => (e[e.Collision = 0] = "Collision", e[e.ShapeIntersection = 1] = "ShapeIntersection", e[e.PointerIntersection = 2] = "PointerIntersection", e))($e || {}), et, tt, nt, rt, it, at, ot = [s], G, st;
+at = [a], it = [a], rt = [a], nt = [a], tt = [a], et = [a];
+var K = class {
+	constructor() {
+		w(G, 5, this), D(this, st, w(G, 8, this, "idle")), w(G, 11, this);
+	}
+	get current() {
+		return this.value;
+	}
+	get idle() {
+		return this.value === "idle";
+	}
+	get initializing() {
+		return this.value === "initializing";
+	}
+	get initialized() {
+		let { value: e } = this;
+		return e !== "idle" && e !== "initialization-pending";
+	}
+	get dragging() {
+		return this.value === "dragging";
+	}
+	get dropped() {
+		return this.value === "dropped";
+	}
+	set(e) {
+		this.value = e;
+	}
+};
+G = x(null), st = /* @__PURE__ */ new WeakMap(), T(G, 4, "value", ot, K, st), T(G, 2, "current", at, K), T(G, 2, "idle", it, K), T(G, 2, "initializing", rt, K), T(G, 2, "initialized", nt, K), T(G, 2, "dragging", tt, K), T(G, 2, "dropped", et, K), C(G, K);
+var ct = class {
+	constructor(e) {
+		this.manager = e;
+	}
+	setDragSource(e) {
+		let { dragOperation: t } = this.manager;
+		t.sourceIdentifier = typeof e == "string" || typeof e == "number" ? e : e.id;
+	}
+	setDropTarget(t) {
+		return e(() => {
+			let { dragOperation: e } = this.manager, n = t ?? null;
+			if (e.targetIdentifier === n) return Promise.resolve(!1);
+			e.targetIdentifier = n;
+			let r = W({ operation: e.snapshot() });
+			return e.status.dragging && this.manager.monitor.dispatch("dragover", r), this.manager.renderer.rendering.then(() => r.defaultPrevented);
+		});
+	}
+	start(t) {
+		return e(() => {
+			let { dragOperation: e } = this.manager;
+			if (t.source != null && this.setDragSource(t.source), !e.source) throw Error("Cannot start a drag operation without a drag source");
+			if (!e.status.idle) throw Error("Cannot start a drag operation while another is active");
+			let r = new AbortController(), { event: i, coordinates: a } = t;
+			n(() => {
+				e.status.set("initialization-pending"), e.shape = null, e.canceled = !1, e.activatorEvent = i ?? null, e.position.reset(a);
+			});
+			let o = W({ operation: e.snapshot() });
+			return this.manager.monitor.dispatch("beforedragstart", o), o.defaultPrevented ? (e.reset(), r.abort(), r) : (e.status.set("initializing"), e.controller = r, this.manager.renderer.rendering.then(() => {
+				if (r.signal.aborted) return;
+				let { status: t } = e;
+				t.current === "initializing" && n(() => {
+					e.status.set("dragging"), this.manager.monitor.dispatch("dragstart", {
+						nativeEvent: i,
+						operation: e.snapshot(),
+						cancelable: !1
+					});
+				});
+			}), r);
+		});
+	}
+	move(t) {
+		return e(() => {
+			let { dragOperation: e } = this.manager, { status: n, controller: r } = e;
+			if (!n.dragging || !r || r.signal.aborted) return;
+			let i = W({
+				nativeEvent: t.event,
+				operation: e.snapshot(),
+				by: t.by,
+				to: t.to
+			}, t.cancelable ?? !0);
+			(t.propagate ?? !0) && this.manager.monitor.dispatch("dragmove", i), queueMicrotask(() => {
+				if (i.defaultPrevented) return;
+				let n = t.to ?? {
+					x: e.position.current.x + (t.by?.x ?? 0),
+					y: e.position.current.y + (t.by?.y ?? 0)
+				};
+				e.position.current = n;
+			});
+		});
+	}
+	stop(n = {}) {
+		return e(() => {
+			let { dragOperation: r } = this.manager, { controller: i } = r;
+			if (!i || i.signal.aborted) return;
+			let a, o = () => {
+				let e = {
+					resume: () => {},
+					abort: () => {}
+				};
+				return a = new Promise((t, n) => {
+					e.resume = t, e.abort = n;
+				}), e;
+			};
+			i.abort();
+			let s = () => {
+				this.manager.renderer.rendering.then(() => {
+					r.status.set("dropped");
+					let n = e(() => r.source?.status === "dropping"), a = () => {
+						r.controller === i && (r.controller = void 0), r.reset();
+					};
+					if (n) {
+						let { source: e } = r, n = t(() => {
+							e?.status === "idle" && (n(), a());
+						});
+					} else this.manager.renderer.rendering.then(a);
+				});
+			};
+			r.canceled = n.canceled ?? !1, this.manager.monitor.dispatch("dragend", {
+				nativeEvent: n.event,
+				operation: r.snapshot(),
+				canceled: n.canceled ?? !1,
+				suspend: o
+			}), a ? a.then(s).catch(() => r.reset()) : s();
+		});
+	}
+}, lt = class extends j {
+	constructor(e, t) {
+		super(e, t), this.manager = e, this.options = t;
+	}
+}, ut = class extends AbortController {
+	constructor(e, t) {
+		super(), this.constraints = e, this.onActivate = t, this.activated = !1;
+		for (let t of e ?? []) t.controller = this;
+	}
+	onEvent(e) {
+		if (!this.activated) if (this.constraints?.length) for (let t of this.constraints) t.onEvent(e);
+		else this.activate(e);
+	}
+	activate(e) {
+		this.activated || (this.activated = !0, this.onActivate(e));
+	}
+	abort(e) {
+		this.activated = !1, super.abort(e);
+	}
+}, q, dt = class {
+	constructor(e) {
+		this.options = e, D(this, q);
+	}
+	set controller(e) {
+		O(this, q, e), e.signal.addEventListener("abort", () => this.abort());
+	}
+	activate(e) {
+		var t;
+		(t = E(this, q)) == null || t.activate(e);
+	}
+};
+q = /* @__PURE__ */ new WeakMap();
+var ft = class extends j {
+	constructor(e, t) {
+		super(e, t), this.manager = e, this.options = t;
+	}
+	apply(e) {
+		return e.transform;
+	}
+}, pt = class {
+	constructor(e) {
+		this.draggables = new Ee(), this.droppables = new Ee(), this.plugins = new he(e), this.sensors = new he(e), this.modifiers = new he(e);
+	}
+	register(e, t) {
+		if (e instanceof V) return this.draggables.register(e.id, e);
+		if (e instanceof U) return this.droppables.register(e.id, e);
+		if (e.prototype instanceof ft) return this.modifiers.register(e, t);
+		if (e.prototype instanceof lt) return this.sensors.register(e, t);
+		if (e.prototype instanceof j) return this.plugins.register(e, t);
+		throw Error("Invalid instance type");
+	}
+	unregister(e) {
+		if (e instanceof z) return e instanceof V ? this.draggables.unregister(e.id, e) : e instanceof U ? this.droppables.unregister(e.id, e) : () => {};
+		if (e.prototype instanceof ft) return this.modifiers.unregister(e);
+		if (e.prototype instanceof lt) return this.sensors.unregister(e);
+		if (e.prototype instanceof j) return this.plugins.unregister(e);
+		throw Error("Invalid instance type");
+	}
+	destroy() {
+		this.draggables.destroy(), this.droppables.destroy(), this.plugins.destroy(), this.sensors.destroy(), this.modifiers.destroy();
+	}
+}, mt, ht, gt, _t, vt, yt, bt, xt, St = [a], J, Y, X, Z, Ct, wt, Tt, Et, Dt, Q;
+xt = [s], bt = [s], yt = [s], vt = [s], _t = [s], gt = [a], ht = [a], mt = [a];
+var $ = class {
+	constructor(e) {
+		w(Z, 5, this), D(this, J), D(this, Y), D(this, X, new i(void 0, (e, t) => e && t ? e.equals(t) : e === t)), this.status = new K(), D(this, Ct, w(Z, 8, this, !1)), w(Z, 11, this), D(this, wt, w(Z, 12, this, null)), w(Z, 15, this), D(this, Tt, w(Z, 16, this, null)), w(Z, 19, this), D(this, Et, w(Z, 20, this, null)), w(Z, 23, this), D(this, Dt, w(Z, 24, this, [])), w(Z, 27, this), this.position = new l({
+			x: 0,
+			y: 0
+		}), D(this, Q, {
+			x: 0,
+			y: 0
+		}), O(this, J, e);
+	}
+	get shape() {
+		let { current: e, initial: t, previous: n } = E(this, X);
+		return !e || !t ? null : {
+			current: e,
+			initial: t,
+			previous: n
+		};
+	}
+	set shape(e) {
+		e ? E(this, X).current = e : E(this, X).reset();
+	}
+	get source() {
+		let e = this.sourceIdentifier;
+		if (e == null) return null;
+		let t = E(this, J).registry.draggables.get(e);
+		return t && O(this, Y, t), t ?? E(this, Y) ?? null;
+	}
+	get target() {
+		let e = this.targetIdentifier;
+		return e == null ? null : E(this, J).registry.droppables.get(e) ?? null;
+	}
+	get transform() {
+		let { x: e, y: t } = this.position.delta, n = {
+			x: e,
+			y: t
+		};
+		for (let e of this.modifiers) n = e.apply(b(y({}, this.snapshot()), { transform: n }));
+		return O(this, Q, n), n;
+	}
+	snapshot() {
+		return e(() => ({
+			source: this.source,
+			target: this.target,
+			activatorEvent: this.activatorEvent,
+			transform: E(this, Q),
+			shape: this.shape ? c(this.shape) : null,
+			position: c(this.position),
+			status: c(this.status),
+			canceled: this.canceled
+		}));
+	}
+	reset() {
+		n(() => {
+			this.status.set("idle"), this.sourceIdentifier = null, this.targetIdentifier = null, E(this, X).reset(), this.position.reset({
+				x: 0,
+				y: 0
+			}), O(this, Q, {
+				x: 0,
+				y: 0
+			}), this.modifiers = [];
+		});
+	}
+};
+Z = x(null), J = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ new WeakMap(), X = /* @__PURE__ */ new WeakMap(), Ct = /* @__PURE__ */ new WeakMap(), wt = /* @__PURE__ */ new WeakMap(), Tt = /* @__PURE__ */ new WeakMap(), Et = /* @__PURE__ */ new WeakMap(), Dt = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), T(Z, 2, "shape", St, $), T(Z, 4, "canceled", xt, $, Ct), T(Z, 4, "activatorEvent", bt, $, wt), T(Z, 4, "sourceIdentifier", yt, $, Tt), T(Z, 4, "targetIdentifier", vt, $, Et), T(Z, 4, "modifiers", _t, $, Dt), T(Z, 2, "source", gt, $), T(Z, 2, "target", ht, $), T(Z, 2, "transform", mt, $), C(Z, $);
+var Ot = { get rendering() {
+	return Promise.resolve();
+} };
+function kt(e, t) {
+	return typeof e == "function" ? e(t) : e ?? t;
+}
+var At = class {
+	constructor(t) {
+		this.destroy = () => {
+			this.dragOperation.status.idle || this.actions.stop({ canceled: !0 }), this.dragOperation.modifiers.forEach((e) => e.destroy()), this.registry.destroy(), this.collisionObserver.destroy();
+		};
+		let n = t ?? {}, r = kt(n.plugins, []), i = kt(n.sensors, []), a = kt(n.modifiers, []), s = n.renderer ?? Ot, c = new Xe(this), l = new pt(this);
+		this.registry = l, this.monitor = c, this.renderer = s, this.actions = new ct(this), this.dragOperation = new $(this), this.collisionObserver = new _e(this), this.plugins = [Ze, ...r], this.modifiers = a, this.sensors = i;
+		let { destroy: u } = this, ee = o(() => {
+			let t = e(() => this.dragOperation.modifiers), n = this.modifiers;
+			for (let e of t) n.includes(e) || e.destroy();
+			this.dragOperation.modifiers = (this.dragOperation.source?.modifiers)?.map((e) => {
+				let { plugin: t, options: n } = k(e);
+				return new t(this, n);
+			}) ?? n;
+		});
+		this.destroy = () => {
+			ee(), u();
+		};
+	}
+	get plugins() {
+		return this.registry.plugins.values;
+	}
+	set plugins(e) {
+		this.registry.plugins.values = e;
+	}
+	get modifiers() {
+		return this.registry.modifiers.values;
+	}
+	set modifiers(e) {
+		this.registry.modifiers.values = e;
+	}
+	get sensors() {
+		return this.registry.sensors.values;
+	}
+	set sensors(e) {
+		this.registry.sensors.values = e;
+	}
+};
+//#endregion
+export { dt as ActivationConstraint, ut as ActivationController, Qe as CollisionPriority, $e as CollisionType, me as CorePlugin, At as DragDropManager, V as Draggable, U as Droppable, j as Plugin, lt as Sensor, ue as configurator, k as descriptor, kt as resolveCustomizable };

package/dist/node_modules/@dnd-kit/collision/dist/index.cjs

@@ -0,0 +1 @@
+const e=require("../../geometry/dist/index.cjs"),t=require("../../abstract/index.cjs");var n=({dragOperation:n,droppable:r})=>{let i=n.position.current;if(!i)return null;let{id:a}=r;return r.shape&&r.shape.containsPoint(i)?{id:a,value:1/e.Point.distance(r.shape.center,i),type:t.CollisionType.PointerIntersection,priority:t.CollisionPriority.High}:null},r=({dragOperation:n,droppable:r})=>{let{shape:i}=n;if(!r.shape||!i?.current)return null;let a=i.current.intersectionArea(r.shape);if(a){let{position:o}=n,s=e.Point.distance(r.shape.center,o.current),c=a/(i.current.area+r.shape.area-a)/s;return{id:r.id,value:c,type:t.CollisionType.ShapeIntersection,priority:t.CollisionPriority.Normal}}return null},i=e=>n(e)??r(e),a=n=>{let{dragOperation:r,droppable:i}=n,{shape:a,position:o}=r;if(!i.shape)return null;let s=a?e.Rectangle.from(a.current.boundingRectangle).corners:void 0,c=e.Rectangle.from(i.shape.boundingRectangle).corners.reduce((t,n,r)=>t+e.Point.distance(e.Point.from(n),s?.[r]??o.current),0)/4;return{id:i.id,value:1/c,type:t.CollisionType.Collision,priority:t.CollisionPriority.Normal}};exports.closestCorners=a,exports.defaultCollisionDetection=i;