@caspeco/casper-ui-library 8.2.2 → 8.4.0

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

@@ -0,0 +1,1142 @@
+import { effects as rt, ValueHistory as Ie, snapshot as nt, reactive as _, derived as b } from "../state/dist/index.js";
+import { Position as Pe } from "../geometry/dist/index.js";
+import { untracked as k, effect as Lt, batch as Rt, signal as jt } from "../../@preact/signals-core/dist/signals-core.module.js";
+var Se = Object.create, dt = Object.defineProperty, xe = Object.defineProperties, ze = Object.getOwnPropertyDescriptor, Ce = Object.getOwnPropertyDescriptors, st = Object.getOwnPropertySymbols, Ht = Object.prototype.hasOwnProperty, Vt = Object.prototype.propertyIsEnumerable, qt = (t, e) => (e = Symbol[t]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + t), q = (t) => {
+  throw TypeError(t);
+}, ct = (t, e, s) => e in t ? dt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, Nt = (t, e) => {
+  for (var s in e || (e = {}))
+    Ht.call(e, s) && ct(t, s, e[s]);
+  if (st)
+    for (var s of st(e))
+      Vt.call(e, s) && ct(t, s, e[s]);
+  return t;
+}, Ut = (t, e) => xe(t, Ce(e)), zt = (t, e) => dt(t, "name", { value: e, configurable: !0 }), Tt = (t, e) => {
+  var s = {};
+  for (var r in t)
+    Ht.call(t, r) && e.indexOf(r) < 0 && (s[r] = t[r]);
+  if (t != null && st)
+    for (var r of st(t))
+      e.indexOf(r) < 0 && Vt.call(t, r) && (s[r] = t[r]);
+  return s;
+}, N = (t) => {
+  var e;
+  return [, , , Se((e = t?.[qt("metadata")]) != null ? e : null)];
+}, $t = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], $ = (t) => t !== void 0 && typeof t != "function" ? q("Function expected") : t, Ae = (t, e, s, r, i) => ({ kind: $t[t], name: e, metadata: r, addInitializer: (n) => s._ ? q("Already initialized") : i.push($(n || null)) }), F = (t, e) => ct(e, qt("metadata"), t[3]), a = (t, e, s, r) => {
+  for (var i = 0, n = t[e >> 1], u = n && n.length; i < u; i++) e & 1 ? n[i].call(s) : r = n[i].call(s, r);
+  return r;
+}, l = (t, e, s, r, i, n) => {
+  var u, o, p, h, g, c = e & 7, P = !!(e & 8), D = !!(e & 16), L = c > 3 ? t.length + 1 : c ? P ? 1 : 2 : 0, K = $t[c + 5], U = c > 3 && (t[L - 1] = []), R = t[L] || (t[L] = []), M = c && (!D && !P && (i = i.prototype), c < 5 && (c > 3 || !D) && ze(c < 4 ? i : { get [s]() {
+    return m(this, n);
+  }, set [s](O) {
+    return E(this, n, O);
+  } }, s));
+  c ? D && c < 4 && zt(n, (c > 2 ? "set " : c > 1 ? "get " : "") + s) : zt(i, s);
+  for (var T = r.length - 1; T >= 0; T--)
+    h = Ae(c, s, p = {}, t[3], R), c && (h.static = P, h.private = D, g = h.access = { has: D ? (O) => Fe(i, O) : (O) => s in O }, c ^ 3 && (g.get = D ? (O) => (c ^ 1 ? m : Le)(O, i, c ^ 4 ? n : M.get) : (O) => O[s]), c > 2 && (g.set = D ? (O, it) => E(O, i, it, c ^ 4 ? n : M.set) : (O, it) => O[s] = it)), o = (0, r[T])(c ? c < 4 ? D ? n : M[K] : c > 4 ? void 0 : { get: M.get, set: M.set } : i, h), p._ = 1, c ^ 4 || o === void 0 ? $(o) && (c > 4 ? U.unshift(o) : c ? D ? n = o : M[K] = o : i = o) : typeof o != "object" || o === null ? q("Object expected") : ($(u = o.get) && (M.get = u), $(u = o.set) && (M.set = u), $(u = o.init) && U.unshift(u));
+  return c || F(t, i), M && dt(i, s, M), D ? c ^ 4 ? n : M : i;
+}, ht = (t, e, s) => e.has(t) || q("Cannot " + s), Fe = (t, e) => Object(e) !== e ? q('Cannot use the "in" operator on this value') : t.has(e), m = (t, e, s) => (ht(t, e, "read from private field"), s ? s.call(t) : e.get(t)), d = (t, e, s) => e.has(t) ? q("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), E = (t, e, s, r) => (ht(t, e, "write to private field"), r ? r.call(t, s) : e.set(t, s), s), Le = (t, e, s) => (ht(t, e, "access private method"), s);
+function Gt(t, e) {
+  return {
+    plugin: t,
+    options: e
+  };
+}
+function Qe(t) {
+  return (e) => Gt(t, e);
+}
+function Bt(t) {
+  return typeof t == "function" ? {
+    plugin: t,
+    options: void 0
+  } : t;
+}
+var Jt, J, pt, X;
+Jt = [_];
+var C = class {
+  /**
+   * Creates a new plugin instance.
+   *
+   * @param manager - The drag and drop manager that owns this plugin
+   * @param options - Optional configuration for the plugin
+   */
+  constructor(t, e) {
+    this.manager = t, this.options = e, d(this, pt, a(J, 8, this, !1)), a(J, 11, this), d(this, X, /* @__PURE__ */ new Set());
+  }
+  /**
+   * Enables a disabled plugin instance.
+   *
+   * @remarks
+   * This method triggers effects when called.
+   */
+  enable() {
+    this.disabled = !1;
+  }
+  /**
+   * Disables an enabled plugin instance.
+   *
+   * @remarks
+   * This method triggers effects when called.
+   */
+  disable() {
+    this.disabled = !0;
+  }
+  /**
+   * Checks if the plugin instance is disabled.
+   *
+   * @returns true if the plugin is disabled
+   * @remarks
+   * This method does not trigger effects when accessed.
+   */
+  isDisabled() {
+    return k(() => this.disabled);
+  }
+  /**
+   * Configures a plugin instance with new options.
+   *
+   * @param options - The new options to apply
+   */
+  configure(t) {
+    this.options = t;
+  }
+  /**
+   * Registers an effect that will be cleaned up when the plugin is destroyed.
+   *
+   * @param callback - The effect callback to register
+   * @returns A function to dispose of the effect
+   */
+  registerEffect(t) {
+    const e = Lt(t.bind(this));
+    return m(this, X).add(e), e;
+  }
+  /**
+   * Destroys a plugin instance and cleans up its resources.
+   *
+   * @remarks
+   * This method:
+   * - Calls all registered cleanup functions
+   * - Should be overridden by subclasses to clean up additional resources
+   */
+  destroy() {
+    m(this, X).forEach((t) => t());
+  }
+  /**
+   * Configures a plugin constructor with options.
+   *
+   * @param options - The options to configure the constructor with
+   * @returns The configured plugin constructor
+   *
+   * @remarks
+   * This method is used to configure the options that the
+   * plugin constructor will use to create plugin instances.
+   */
+  static configure(t) {
+    return Gt(this, t);
+  }
+};
+J = N(null);
+pt = /* @__PURE__ */ new WeakMap();
+X = /* @__PURE__ */ new WeakMap();
+l(J, 4, "disabled", Jt, C, pt);
+F(J, C);
+var Kt = class extends C {
+}, Y, at = class {
+  /**
+   * Creates a new plugin registry.
+   *
+   * @param manager - The drag and drop manager that owns this registry
+   */
+  constructor(t) {
+    this.manager = t, this.instances = /* @__PURE__ */ new Map(), d(this, Y, []);
+  }
+  /**
+   * Gets all registered plugin instances.
+   *
+   * @returns An array of all active plugin instances
+   */
+  get values() {
+    return Array.from(this.instances.values());
+  }
+  /**
+   * Sets the list of plugins to be used by the registry.
+   *
+   * @param entries - Array of plugin constructors or descriptors
+   * @remarks
+   * This method:
+   * - Filters out duplicate plugins
+   * - Unregisters plugins that are no longer in use
+   * - Registers new plugins with their options
+   */
+  set values(t) {
+    const e = t.map(Bt).reduceRight((r, i) => r.some(({ plugin: n }) => n === i.plugin) ? r : [i, ...r], []), s = e.map(({ plugin: r }) => r);
+    for (const r of m(this, Y))
+      if (!s.includes(r)) {
+        if (r.prototype instanceof Kt)
+          continue;
+        this.unregister(r);
+      }
+    for (const { plugin: r, options: i } of e)
+      this.register(r, i);
+    E(this, Y, s);
+  }
+  /**
+   * Gets a plugin instance by its constructor.
+   *
+   * @param plugin - The plugin constructor to look up
+   * @returns The plugin instance or undefined if not found
+   */
+  get(t) {
+    return this.instances.get(t);
+  }
+  /**
+   * Registers a new plugin instance.
+   *
+   * @param plugin - The plugin constructor to register
+   * @param options - Optional configuration for the plugin
+   * @returns The registered plugin instance
+   * @remarks
+   * If the plugin is already registered, its options will be updated
+   * and the existing instance will be returned.
+   */
+  register(t, e) {
+    const s = this.instances.get(t);
+    if (s)
+      return s.options !== e && (s.options = e), s;
+    const r = new t(this.manager, e);
+    return this.instances.set(t, r), r;
+  }
+  /**
+   * Unregisters a plugin instance.
+   *
+   * @param plugin - The plugin constructor to unregister
+   * @remarks
+   * This method:
+   * - Destroys the plugin instance
+   * - Removes it from the registry
+   */
+  unregister(t) {
+    const e = this.instances.get(t);
+    e && (e.destroy(), this.instances.delete(t));
+  }
+  /**
+   * Destroys all registered plugin instances.
+   *
+   * @remarks
+   * This method:
+   * - Calls destroy() on all plugin instances
+   * - Clears the registry
+   */
+  destroy() {
+    for (const t of this.instances.values())
+      t.destroy();
+    this.instances.clear();
+  }
+};
+Y = /* @__PURE__ */ new WeakMap();
+function Re(t, e) {
+  return t.priority === e.priority ? t.type === e.type ? e.value - t.value : e.type - t.type : e.priority - t.priority;
+}
+var Q = [], j, H, je = class extends C {
+  /**
+   * Creates a new CollisionObserver instance.
+   *
+   * @param manager - The drag drop manager instance
+   */
+  constructor(t) {
+    super(t), d(this, j), d(this, H), this.computeCollisions = this.computeCollisions.bind(this), E(this, H, jt(Q)), this.destroy = rt(
+      () => {
+        const e = this.computeCollisions(), s = k(
+          () => this.manager.dragOperation.position.current
+        );
+        if (e !== Q) {
+          const r = m(this, j);
+          if (E(this, j, s), r && s.x == r.x && s.y == r.y)
+            return;
+        } else
+          E(this, j, void 0);
+        m(this, H).value = e;
+      },
+      () => {
+        const { dragOperation: e } = this.manager;
+        e.status.initialized && this.forceUpdate();
+      }
+    );
+  }
+  /**
+   * Forces an immediate update of collision detection.
+   *
+   * @param immediate - If true, updates collisions immediately. If false, resets previous coordinates.
+   */
+  forceUpdate(t = !0) {
+    k(() => {
+      t ? m(this, H).value = this.computeCollisions() : E(this, j, void 0);
+    });
+  }
+  /**
+   * Computes collisions between draggable and droppable elements.
+   *
+   * @param entries - Optional array of droppable elements to check. If not provided, uses all registered droppables.
+   * @param collisionDetector - Optional custom collision detector function
+   * @returns Array of detected collisions, sorted by priority
+   */
+  computeCollisions(t, e) {
+    const { registry: s, dragOperation: r } = this.manager, { source: i, shape: n, status: u } = r;
+    if (!u.initialized || !n)
+      return Q;
+    const o = [], p = [];
+    for (const h of t ?? s.droppables) {
+      if (h.disabled || i && !h.accepts(i))
+        continue;
+      const g = e ?? h.collisionDetector;
+      if (!g)
+        continue;
+      p.push(h), h.shape;
+      const c = k(
+        () => g({
+          droppable: h,
+          dragOperation: r
+        })
+      );
+      c && (h.collisionPriority != null && (c.priority = h.collisionPriority), o.push(c));
+    }
+    return p.length === 0 ? Q : (o.sort(Re), o);
+  }
+  /**
+   * Gets the current collisions signal value.
+   */
+  get collisions() {
+    return m(this, H).value;
+  }
+};
+j = /* @__PURE__ */ new WeakMap();
+H = /* @__PURE__ */ new WeakMap();
+var He = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds an event listener for the specified event type.
+   *
+   * @param name - The name of the event to listen for
+   * @param handler - The function to call when the event occurs
+   * @returns A function to remove the event listener
+   */
+  addEventListener(t, e) {
+    const { registry: s } = this, r = new Set(s.get(t));
+    return r.add(e), s.set(t, r), () => this.removeEventListener(t, e);
+  }
+  /**
+   * Removes an event listener for the specified event type.
+   *
+   * @param name - The name of the event
+   * @param handler - The function to remove
+   */
+  removeEventListener(t, e) {
+    const { registry: s } = this, r = new Set(s.get(t));
+    r.delete(e), s.set(t, r);
+  }
+  /**
+   * Dispatches an event to all registered listeners.
+   *
+   * @param name - The name of the event to dispatch
+   * @param args - Arguments to pass to the event handlers
+   */
+  dispatch(t, ...e) {
+    const { registry: s } = this, r = s.get(t);
+    if (r)
+      for (const i of r)
+        i(...e);
+  }
+}, Ve = class extends He {
+  /**
+   * Creates a new drag and drop monitor.
+   *
+   * @param manager - The drag and drop manager to monitor
+   */
+  constructor(t) {
+    super(), this.manager = t;
+  }
+  /**
+   * Dispatches a drag and drop event.
+   *
+   * @param type - The type of event to dispatch
+   * @param event - The event data to dispatch
+   */
+  dispatch(t, e) {
+    const s = [e, this.manager];
+    super.dispatch(t, ...s);
+  }
+};
+function Z(t, e = !0) {
+  let s = !1;
+  return Ut(Nt({}, t), {
+    cancelable: e,
+    get defaultPrevented() {
+      return s;
+    },
+    preventDefault() {
+      e && (s = !0);
+    }
+  });
+}
+var qe = class extends Kt {
+  constructor(t) {
+    super(t);
+    const e = (r, i) => r.map(({ id: n }) => n).join("") === i.map(({ id: n }) => n).join("");
+    let s = [];
+    this.destroy = rt(
+      () => {
+        const { dragOperation: r, collisionObserver: i } = t;
+        r.status.initializing && (s = [], i.enable());
+      },
+      () => {
+        const { collisionObserver: r, monitor: i } = t, { collisions: n } = r;
+        if (r.isDisabled())
+          return;
+        const u = Z({
+          collisions: n
+        });
+        if (i.dispatch("collision", u), u.defaultPrevented || e(n, s))
+          return;
+        s = n;
+        const [o] = n;
+        k(() => {
+          var p;
+          o?.id !== ((p = t.dragOperation.target) == null ? void 0 : p.id) && (r.disable(), t.actions.setDropTarget(o?.id).then(() => {
+            r.enable();
+          }));
+        });
+      }
+    );
+  }
+}, Ne = /* @__PURE__ */ ((t) => (t[t.Lowest = 0] = "Lowest", t[t.Low = 1] = "Low", t[t.Normal = 2] = "Normal", t[t.High = 3] = "High", t[t.Highest = 4] = "Highest", t))(Ne || {}), Ue = /* @__PURE__ */ ((t) => (t[t.Collision = 0] = "Collision", t[t.ShapeIntersection = 1] = "ShapeIntersection", t[t.PointerIntersection = 2] = "PointerIntersection", t))(Ue || {}), Qt, Xt, Yt, Zt, te, ee, se, W, gt;
+se = [_], ee = [b], te = [b], Zt = [b], Yt = [b], Xt = [b], Qt = [b];
+var z = class {
+  constructor() {
+    a(W, 5, this), d(this, gt, a(
+      W,
+      8,
+      this,
+      "idle"
+      /* Idle */
+    )), a(W, 11, this);
+  }
+  get current() {
+    return this.value;
+  }
+  get idle() {
+    return this.value === "idle";
+  }
+  get initializing() {
+    return this.value === "initializing";
+  }
+  get initialized() {
+    const { value: t } = this;
+    return t !== "idle" && t !== "initialization-pending";
+  }
+  get dragging() {
+    return this.value === "dragging";
+  }
+  get dropped() {
+    return this.value === "dropped";
+  }
+  /**
+   * Sets the current status value.
+   *
+   * @param value - The new status value
+   */
+  set(t) {
+    this.value = t;
+  }
+};
+W = N(null);
+gt = /* @__PURE__ */ new WeakMap();
+l(W, 4, "value", se, z, gt);
+l(W, 2, "current", ee, z);
+l(W, 2, "idle", te, z);
+l(W, 2, "initializing", Zt, z);
+l(W, 2, "initialized", Yt, z);
+l(W, 2, "dragging", Xt, z);
+l(W, 2, "dropped", Qt, z);
+F(W, z);
+var Te = class {
+  /**
+   * Creates a new instance of drag actions.
+   *
+   * @param manager - The drag and drop manager instance
+   */
+  constructor(t) {
+    this.manager = t;
+  }
+  /**
+   * Sets the source of the drag operation.
+   *
+   * @param source - The draggable entity or its unique identifier
+   */
+  setDragSource(t) {
+    const { dragOperation: e } = this.manager;
+    e.sourceIdentifier = typeof t == "string" || typeof t == "number" ? t : t.id;
+  }
+  /**
+   * Sets the target of the drop operation.
+   *
+   * @param identifier - The unique identifier of the droppable entity or null/undefined
+   * @returns A promise that resolves to true if the drop was prevented
+   */
+  setDropTarget(t) {
+    return k(() => {
+      const { dragOperation: e } = this.manager, s = t ?? null;
+      if (e.targetIdentifier === s)
+        return Promise.resolve(!1);
+      e.targetIdentifier = s;
+      const r = Z({
+        operation: e.snapshot()
+      });
+      return e.status.dragging && this.manager.monitor.dispatch("dragover", r), this.manager.renderer.rendering.then(() => r.defaultPrevented);
+    });
+  }
+  /**
+   * Starts a new drag operation.
+   *
+   * @param args - Configuration for the drag operation
+   * @param args.event - The event that initiated the drag
+   * @param args.source - The source draggable entity or its identifier
+   * @param args.coordinates - The initial coordinates of the drag
+   * @returns true if the drag operation started successfully
+   * @throws {Error} If there is no drag source or another operation is active
+   */
+  start(t) {
+    return k(() => {
+      const { dragOperation: e } = this.manager;
+      if (t.source != null && this.setDragSource(t.source), !e.source)
+        throw new Error("Cannot start a drag operation without a drag source");
+      if (!e.status.idle)
+        throw new Error(
+          "Cannot start a drag operation while another is active"
+        );
+      const r = new AbortController(), { event: i, coordinates: n } = t;
+      Rt(() => {
+        e.status.set(
+          "initialization-pending"
+          /* InitializationPending */
+        ), e.shape = null, e.canceled = !1, e.activatorEvent = i ?? null, e.position.reset(n);
+      });
+      const u = Z({
+        operation: e.snapshot()
+      });
+      return this.manager.monitor.dispatch("beforedragstart", u), u.defaultPrevented ? (e.reset(), r.abort(), r) : (e.status.set(
+        "initializing"
+        /* Initializing */
+      ), e.controller = r, this.manager.renderer.rendering.then(() => {
+        if (r.signal.aborted) return;
+        const { status: o } = e;
+        o.current === "initializing" && (e.status.set(
+          "dragging"
+          /* Dragging */
+        ), this.manager.monitor.dispatch("dragstart", {
+          nativeEvent: i,
+          operation: e.snapshot(),
+          cancelable: !1
+        }));
+      }), r);
+    });
+  }
+  /**
+   * Moves the dragged entity to a new position.
+   *
+   * @param args - Configuration for the move operation
+   * @param args.by - Relative coordinates to move by
+   * @param args.to - Absolute coordinates to move to
+   * @param args.event - The event that triggered the move
+   * @param args.cancelable - Whether the move can be canceled
+   * @param args.propagate - Whether to dispatch dragmove events
+   */
+  move(t) {
+    return k(() => {
+      var e, s;
+      const { dragOperation: r } = this.manager, { status: i, controller: n } = r;
+      if (!i.dragging || !n || n.signal.aborted)
+        return;
+      const u = Z(
+        {
+          nativeEvent: t.event,
+          operation: r.snapshot(),
+          by: t.by,
+          to: t.to
+        },
+        (e = t.cancelable) != null ? e : !0
+      );
+      ((s = t.propagate) == null || s) && this.manager.monitor.dispatch("dragmove", u), queueMicrotask(() => {
+        var o, p, h, g, c;
+        if (u.defaultPrevented)
+          return;
+        const P = (c = t.to) != null ? c : {
+          x: r.position.current.x + ((p = (o = t.by) == null ? void 0 : o.x) != null ? p : 0),
+          y: r.position.current.y + ((g = (h = t.by) == null ? void 0 : h.y) != null ? g : 0)
+        };
+        r.position.current = P;
+      });
+    });
+  }
+  /**
+   * Stops the current drag operation.
+   *
+   * @param args - Configuration for stopping the operation
+   * @param args.event - The event that triggered the stop
+   * @param args.canceled - Whether the operation was canceled
+   * @remarks
+   * This method:
+   * - Dispatches a dragend event
+   * - Allows suspension of the operation
+   * - Handles cleanup of the operation state
+   */
+  stop(t = {}) {
+    return k(() => {
+      var e, s;
+      const { dragOperation: r } = this.manager, { controller: i } = r;
+      if (!i || i.signal.aborted) return;
+      let n;
+      const u = () => {
+        const p = {
+          resume: () => {
+          },
+          abort: () => {
+          }
+        };
+        return n = new Promise((h, g) => {
+          p.resume = h, p.abort = g;
+        }), p;
+      };
+      i.abort();
+      const o = () => {
+        this.manager.renderer.rendering.then(() => {
+          r.status.set(
+            "dropped"
+            /* Dropped */
+          );
+          const p = k(
+            () => {
+              var g;
+              return ((g = r.source) == null ? void 0 : g.status) === "dropping";
+            }
+          ), h = () => {
+            r.controller === i && (r.controller = void 0), r.reset();
+          };
+          if (p) {
+            const { source: g } = r, c = Lt(() => {
+              g?.status === "idle" && (c(), h());
+            });
+          } else
+            this.manager.renderer.rendering.then(h);
+        });
+      };
+      r.canceled = (e = t.canceled) != null ? e : !1, this.manager.monitor.dispatch("dragend", {
+        nativeEvent: t.event,
+        operation: r.snapshot(),
+        canceled: (s = t.canceled) != null ? s : !1,
+        suspend: u
+      }), n ? n.then(o).catch(() => r.reset()) : o();
+    });
+  }
+}, re, ie, ne, ae, w, ft, vt, _t, mt;
+ae = [_], ne = [_], ie = [_], re = [_];
+var A = class {
+  /**
+   * Creates a new instance of the `Entity` class.
+   *
+   * @param input - An object containing the initial properties of the entity.
+   * @param manager - The manager that controls the drag and drop operations.
+   */
+  constructor(t, e) {
+    d(this, ft, a(w, 8, this)), a(w, 11, this), d(this, vt, a(w, 12, this)), a(w, 15, this), d(this, _t, a(w, 16, this)), a(w, 19, this), d(this, mt, a(w, 20, this)), a(w, 23, this);
+    const { effects: s, id: r, data: i = {}, disabled: n = !1, register: u = !0 } = t;
+    let o = r;
+    this.manager = e, this.id = r, this.data = i, this.disabled = n, this.effects = () => {
+      var p;
+      return [
+        () => {
+          const { id: h, manager: g } = this;
+          if (h !== o)
+            return g?.registry.register(this), () => g?.registry.unregister(this);
+        },
+        ...(p = s?.()) != null ? p : []
+      ];
+    }, this.register = this.register.bind(this), this.unregister = this.unregister.bind(this), this.destroy = this.destroy.bind(this), e && u && queueMicrotask(this.register);
+  }
+  /**
+   * A method that registers the entity with the manager.
+   * @returns CleanupFunction | void
+   */
+  register() {
+    var t;
+    return (t = this.manager) == null ? void 0 : t.registry.register(this);
+  }
+  /**
+   * A method that unregisters the entity from the manager.
+   * @returns void
+   */
+  unregister() {
+    var t;
+    (t = this.manager) == null || t.registry.unregister(this);
+  }
+  /**
+   * A method that cleans up the entity when it is no longer needed.
+   * @returns void
+   */
+  destroy() {
+    var t;
+    (t = this.manager) == null || t.registry.unregister(this);
+  }
+};
+w = N(null);
+ft = /* @__PURE__ */ new WeakMap();
+vt = /* @__PURE__ */ new WeakMap();
+_t = /* @__PURE__ */ new WeakMap();
+mt = /* @__PURE__ */ new WeakMap();
+l(w, 4, "manager", ae, A, ft);
+l(w, 4, "id", ne, A, vt);
+l(w, 4, "data", ie, A, _t);
+l(w, 4, "disabled", re, A, mt);
+F(w, A);
+var Ct = class {
+  constructor() {
+    this.map = jt(/* @__PURE__ */ new Map()), this.cleanupFunctions = /* @__PURE__ */ new WeakMap(), this.register = (t, e) => {
+      const s = this.map.peek(), r = s.get(t), i = () => this.unregister(t, e);
+      if (r === e) return i;
+      if (r) {
+        const o = this.cleanupFunctions.get(r);
+        o?.(), this.cleanupFunctions.delete(r);
+      }
+      const n = new Map(s);
+      n.set(t, e), this.map.value = n;
+      const u = rt(...e.effects());
+      return this.cleanupFunctions.set(e, u), i;
+    }, this.unregister = (t, e) => {
+      const s = this.map.peek();
+      if (s.get(t) !== e)
+        return;
+      const r = this.cleanupFunctions.get(e);
+      r?.(), this.cleanupFunctions.delete(e);
+      const i = new Map(s);
+      i.delete(t), this.map.value = i;
+    };
+  }
+  /**
+   * Iterator for the EntityRegistry class.
+   * @returns An iterator for the values in the map.
+   */
+  [Symbol.iterator]() {
+    return this.map.peek().values();
+  }
+  get value() {
+    return this.map.value.values();
+  }
+  /**
+   * Checks if a entity with the given identifier exists in the registry.
+   * @param identifier - The unique identifier of the entity.
+   * @returns True if the entity exists, false otherwise.
+   */
+  has(t) {
+    return this.map.value.has(t);
+  }
+  /**
+   * Retrieves a entity from the registry using its identifier.
+   * @param identifier - The unique identifier of the entity.
+   * @returns The entity if it exists, undefined otherwise.
+   */
+  get(t) {
+    return this.map.value.get(t);
+  }
+  /**
+   * Destroys all entries in the registry and clears the registry.
+   */
+  destroy() {
+    for (const t of this) {
+      const e = this.cleanupFunctions.get(t);
+      e?.(), t.destroy();
+    }
+    this.map.value = /* @__PURE__ */ new Map();
+  }
+}, oe, ce, le, ue, de, he, lt, y, yt, wt, bt, S = class extends (lt = A, he = [_], de = [_], ue = [_], le = [b], ce = [b], oe = [b], lt) {
+  constructor(e, s) {
+    var r = e, { modifiers: i, type: n, sensors: u } = r, o = Tt(r, ["modifiers", "type", "sensors"]);
+    super(o, s), a(y, 5, this), d(this, yt, a(y, 8, this)), a(y, 11, this), d(this, wt, a(y, 12, this)), a(y, 15, this), d(this, bt, a(y, 16, this, this.isDragSource ? "dragging" : "idle")), a(y, 19, this), this.type = n, this.sensors = u, this.modifiers = i, this.alignment = o.alignment;
+  }
+  get isDropping() {
+    return this.status === "dropping" && this.isDragSource;
+  }
+  get isDragging() {
+    return this.status === "dragging" && this.isDragSource;
+  }
+  get isDragSource() {
+    var e, s;
+    return ((s = (e = this.manager) == null ? void 0 : e.dragOperation.source) == null ? void 0 : s.id) === this.id;
+  }
+};
+y = N(lt);
+yt = /* @__PURE__ */ new WeakMap();
+wt = /* @__PURE__ */ new WeakMap();
+bt = /* @__PURE__ */ new WeakMap();
+l(y, 4, "type", he, S, yt);
+l(y, 4, "modifiers", de, S, wt);
+l(y, 4, "status", ue, S, bt);
+l(y, 2, "isDropping", le, S);
+l(y, 2, "isDragging", ce, S);
+l(y, 2, "isDragSource", oe, S);
+F(y, S);
+var pe, ge, fe, ve, _e, me, ut, v, Dt, Mt, Ot, kt, Et, x = class extends (ut = A, me = [_], _e = [_], ve = [_], fe = [_], ge = [_], pe = [b], ut) {
+  constructor(e, s) {
+    var r = e, { accept: i, collisionDetector: n, collisionPriority: u, type: o } = r, p = Tt(r, ["accept", "collisionDetector", "collisionPriority", "type"]);
+    super(p, s), a(v, 5, this), d(this, Dt, a(v, 8, this)), a(v, 11, this), d(this, Mt, a(v, 12, this)), a(v, 15, this), d(this, Ot, a(v, 16, this)), a(v, 19, this), d(this, kt, a(v, 20, this)), a(v, 23, this), d(this, Et, a(v, 24, this)), a(v, 27, this), this.accept = i, this.collisionDetector = n, this.collisionPriority = u, this.type = o;
+  }
+  /**
+   * Checks whether or not the droppable accepts a given draggable.
+   *
+   * @param draggable - The draggable to check
+   * @returns true if the draggable can be dropped here
+   */
+  accepts(e) {
+    const { accept: s } = this;
+    return s ? typeof s == "function" ? s(e) : e.type ? Array.isArray(s) ? s.includes(e.type) : e.type === s : !1 : !0;
+  }
+  get isDropTarget() {
+    var e, s;
+    return ((s = (e = this.manager) == null ? void 0 : e.dragOperation.target) == null ? void 0 : s.id) === this.id;
+  }
+};
+v = N(ut);
+Dt = /* @__PURE__ */ new WeakMap();
+Mt = /* @__PURE__ */ new WeakMap();
+Ot = /* @__PURE__ */ new WeakMap();
+kt = /* @__PURE__ */ new WeakMap();
+Et = /* @__PURE__ */ new WeakMap();
+l(v, 4, "accept", me, x, Dt);
+l(v, 4, "type", _e, x, Mt);
+l(v, 4, "collisionDetector", ve, x, Ot);
+l(v, 4, "collisionPriority", fe, x, kt);
+l(v, 4, "shape", ge, x, Et);
+l(v, 2, "isDropTarget", pe, x);
+F(v, x);
+var At = class extends C {
+  /**
+   * Creates a new sensor instance.
+   *
+   * @param manager - The drag drop manager instance
+   * @param options - Optional sensor configuration
+   */
+  constructor(t, e) {
+    super(t, e), this.manager = t, this.options = e;
+  }
+}, Ze = class extends AbortController {
+  constructor(t, e) {
+    super(), this.constraints = t, this.onActivate = e, this.activated = !1;
+    for (const s of t ?? [])
+      s.controller = this;
+  }
+  onEvent(t) {
+    var e;
+    if (!this.activated)
+      if ((e = this.constraints) != null && e.length)
+        for (const s of this.constraints)
+          s.onEvent(t);
+      else
+        this.activate(t);
+  }
+  activate(t) {
+    this.activated || (this.activated = !0, this.onActivate(t));
+  }
+  abort(t) {
+    this.activated = !1, super.abort(t);
+  }
+}, tt, ts = class {
+  constructor(t) {
+    this.options = t, d(this, tt);
+  }
+  set controller(t) {
+    E(this, tt, t), t.signal.addEventListener("abort", () => this.abort());
+  }
+  /**
+   * Called when the activation is triggered.
+   */
+  activate(t) {
+    var e;
+    (e = m(this, tt)) == null || e.activate(t);
+  }
+};
+tt = /* @__PURE__ */ new WeakMap();
+var Ft = class extends C {
+  /**
+   * Creates a new modifier instance.
+   *
+   * @param manager - The drag and drop manager that owns this modifier
+   * @param options - Optional configuration for the modifier
+   */
+  constructor(t, e) {
+    super(t, e), this.manager = t, this.options = e;
+  }
+  /**
+   * Applies the modifier to the current drag operation.
+   *
+   * @param operation - The current state of the drag operation
+   * @returns The transformed coordinates
+   *
+   * @remarks
+   * Override this method to implement custom transformation logic.
+   * The default implementation returns the original transform unchanged.
+   */
+  apply(t) {
+    return t.transform;
+  }
+}, $e = class {
+  /**
+   * Creates a new registry instance.
+   *
+   * @param manager - The drag and drop manager that owns this registry
+   */
+  constructor(t) {
+    this.draggables = new Ct(), this.droppables = new Ct(), this.plugins = new at(t), this.sensors = new at(t), this.modifiers = new at(t);
+  }
+  register(t, e) {
+    if (t instanceof S)
+      return this.draggables.register(t.id, t);
+    if (t instanceof x)
+      return this.droppables.register(t.id, t);
+    if (t.prototype instanceof Ft)
+      return this.modifiers.register(t, e);
+    if (t.prototype instanceof At)
+      return this.sensors.register(t, e);
+    if (t.prototype instanceof C)
+      return this.plugins.register(t, e);
+    throw new Error("Invalid instance type");
+  }
+  unregister(t) {
+    if (t instanceof A)
+      return t instanceof S ? this.draggables.unregister(t.id, t) : t instanceof x ? this.droppables.unregister(t.id, t) : () => {
+      };
+    if (t.prototype instanceof Ft)
+      return this.modifiers.unregister(t);
+    if (t.prototype instanceof At)
+      return this.sensors.unregister(t);
+    if (t.prototype instanceof C)
+      return this.plugins.unregister(t);
+    throw new Error("Invalid instance type");
+  }
+  /**
+   * Destroys all registered entities and cleans up resources.
+   *
+   * @remarks
+   * This method:
+   * - Destroys all draggable and droppable entities
+   * - Destroys all plugins, sensors, and modifiers
+   * - Cleans up any associated resources
+   */
+  destroy() {
+    this.draggables.destroy(), this.droppables.destroy(), this.plugins.destroy(), this.sensors.destroy(), this.modifiers.destroy();
+  }
+}, ye, we, be, De, Me, Oe, ke, Ee, We, G, et, V, f, Wt, It, Pt, St, xt, B;
+We = [b], Ee = [_], ke = [_], Oe = [_], Me = [_], De = [_], be = [b], we = [b], ye = [b];
+var I = class {
+  /**
+   * Creates a new drag operation instance.
+   *
+   * @param manager - The drag and drop manager that owns this operation
+   */
+  constructor(t) {
+    a(f, 5, this), d(this, G), d(this, et), d(this, V, new Ie(
+      void 0,
+      (e, s) => e && s ? e.equals(s) : e === s
+    )), this.status = new z(), d(this, Wt, a(f, 8, this, !1)), a(f, 11, this), d(this, It, a(f, 12, this, null)), a(f, 15, this), d(this, Pt, a(f, 16, this, null)), a(f, 19, this), d(this, St, a(f, 20, this, null)), a(f, 23, this), d(this, xt, a(f, 24, this, [])), a(f, 27, this), this.position = new Pe({ x: 0, y: 0 }), d(this, B, { x: 0, y: 0 }), E(this, G, t);
+  }
+  get shape() {
+    const { current: t, initial: e, previous: s } = m(this, V);
+    return !t || !e ? null : { current: t, initial: e, previous: s };
+  }
+  /**
+   * Sets the shape of the dragged entity.
+   *
+   * @param value - The new shape or null to reset
+   */
+  set shape(t) {
+    t ? m(this, V).current = t : m(this, V).reset();
+  }
+  get source() {
+    var t;
+    const e = this.sourceIdentifier;
+    if (e == null) return null;
+    const s = m(this, G).registry.draggables.get(e);
+    return s && E(this, et, s), (t = s ?? m(this, et)) != null ? t : null;
+  }
+  get target() {
+    var t;
+    const e = this.targetIdentifier;
+    return e != null && (t = m(this, G).registry.droppables.get(e)) != null ? t : null;
+  }
+  get transform() {
+    const { x: t, y: e } = this.position.delta;
+    let s = { x: t, y: e };
+    for (const r of this.modifiers)
+      s = r.apply(Ut(Nt({}, this.snapshot()), {
+        transform: s
+      }));
+    return E(this, B, s), s;
+  }
+  /**
+   * Creates a snapshot of the current drag operation state.
+   *
+   * @returns An immutable snapshot of the current operation state
+   */
+  snapshot() {
+    return k(() => ({
+      source: this.source,
+      target: this.target,
+      activatorEvent: this.activatorEvent,
+      transform: m(this, B),
+      shape: this.shape ? nt(this.shape) : null,
+      position: nt(this.position),
+      status: nt(this.status),
+      canceled: this.canceled
+    }));
+  }
+  /**
+   * Resets the drag operation to its initial state.
+   *
+   * @remarks
+   * This method:
+   * - Sets status to idle
+   * - Clears source and target identifiers
+   * - Resets shape history
+   * - Resets position and transform
+   * - Clears modifiers
+   */
+  reset() {
+    Rt(() => {
+      this.status.set(
+        "idle"
+        /* Idle */
+      ), this.sourceIdentifier = null, this.targetIdentifier = null, m(this, V).reset(), this.position.reset({ x: 0, y: 0 }), E(this, B, { x: 0, y: 0 }), this.modifiers = [];
+    });
+  }
+};
+f = N(null);
+G = /* @__PURE__ */ new WeakMap();
+et = /* @__PURE__ */ new WeakMap();
+V = /* @__PURE__ */ new WeakMap();
+Wt = /* @__PURE__ */ new WeakMap();
+It = /* @__PURE__ */ new WeakMap();
+Pt = /* @__PURE__ */ new WeakMap();
+St = /* @__PURE__ */ new WeakMap();
+xt = /* @__PURE__ */ new WeakMap();
+B = /* @__PURE__ */ new WeakMap();
+l(f, 2, "shape", We, I);
+l(f, 4, "canceled", Ee, I, Wt);
+l(f, 4, "activatorEvent", ke, I, It);
+l(f, 4, "sourceIdentifier", Oe, I, Pt);
+l(f, 4, "targetIdentifier", Me, I, St);
+l(f, 4, "modifiers", De, I, xt);
+l(f, 2, "source", be, I);
+l(f, 2, "target", we, I);
+l(f, 2, "transform", ye, I);
+F(f, I);
+var Ge = {
+  get rendering() {
+    return Promise.resolve();
+  }
+};
+function ot(t, e) {
+  return typeof t == "function" ? t(e) : t ?? e;
+}
+var es = class {
+  /**
+   * Creates a new drag and drop manager instance.
+   *
+   * @param config - Optional configuration for plugins, sensors, modifiers, and renderer
+   */
+  constructor(e) {
+    this.destroy = () => {
+      this.dragOperation.status.idle || this.actions.stop({ canceled: !0 }), this.dragOperation.modifiers.forEach((P) => P.destroy()), this.registry.destroy(), this.collisionObserver.destroy();
+    };
+    var s;
+    const r = e ?? {}, i = ot(r.plugins, []), n = ot(r.sensors, []), u = ot(r.modifiers, []), o = (s = r.renderer) != null ? s : Ge, p = new Ve(this), h = new $e(this);
+    this.registry = h, this.monitor = p, this.renderer = o, this.actions = new Te(this), this.dragOperation = new I(this), this.collisionObserver = new je(this), this.plugins = [qe, ...i], this.modifiers = u, this.sensors = n;
+    const { destroy: g } = this, c = rt(() => {
+      var P, D, L;
+      const K = k(() => this.dragOperation.modifiers), U = this.modifiers;
+      for (const R of K)
+        U.includes(R) || R.destroy();
+      this.dragOperation.modifiers = (L = (D = (P = this.dragOperation.source) == null ? void 0 : P.modifiers) == null ? void 0 : D.map((R) => {
+        const { plugin: M, options: T } = Bt(R);
+        return new M(this, T);
+      })) != null ? L : U;
+    });
+    this.destroy = () => {
+      c(), g();
+    };
+  }
+  /**
+   * Gets the list of active plugins.
+   *
+   * @returns Array of active plugin instances
+   */
+  get plugins() {
+    return this.registry.plugins.values;
+  }
+  /**
+   * Sets the list of plugins to be used by the manager.
+   *
+   * @param plugins - Array of plugin constructors or instances
+   */
+  set plugins(e) {
+    this.registry.plugins.values = e;
+  }
+  /**
+   * Gets the list of active modifiers.
+   *
+   * @returns Array of active modifier instances
+   */
+  get modifiers() {
+    return this.registry.modifiers.values;
+  }
+  /**
+   * Sets the list of modifiers to be used by the manager.
+   *
+   * @param modifiers - Array of modifier constructors or instances
+   */
+  set modifiers(e) {
+    this.registry.modifiers.values = e;
+  }
+  /**
+   * Gets the list of active sensors.
+   *
+   * @returns Array of active sensor instances
+   */
+  get sensors() {
+    return this.registry.sensors.values;
+  }
+  /**
+   * Sets the list of sensors to be used by the manager.
+   *
+   * @param sensors - Array of sensor constructors or instances
+   */
+  set sensors(e) {
+    this.registry.sensors.values = e;
+  }
+};
+export {
+  ts as ActivationConstraint,
+  Ze as ActivationController,
+  Ne as CollisionPriority,
+  Ue as CollisionType,
+  Kt as CorePlugin,
+  es as DragDropManager,
+  z as DragOperationStatus,
+  S as Draggable,
+  x as Droppable,
+  Ft as Modifier,
+  C as Plugin,
+  at as PluginRegistry,
+  At as Sensor,
+  Qe as configurator,
+  Gt as configure,
+  Bt as descriptor,
+  ot as resolveCustomizable,
+  Re as sortCollisions
+};