quantum-component-library 0.0.1 → 1.0.0-qa

package/dist/react-dnd-vendor-BZs2igAJ.js

@@ -0,0 +1,1375 @@
+import { j as oe, e as ae } from "./vendor-DvX9OX-j.js";
+import { createContext as ce, memo as ue, useEffect as y, useLayoutEffect as de, useState as le, useCallback as he, useMemo as p, isValidElement as ge, cloneElement as k, useContext as fe } from "react";
+import { c as pe } from "./dnd-core-vendor-q7mfiuVu.js";
+const X = ce({
+  dragDropManager: void 0
+});
+function T(r, e, ...t) {
+  if (ve() && e === void 0)
+    throw new Error("invariant requires an error message argument");
+  if (!r) {
+    let i;
+    if (e === void 0)
+      i = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+    else {
+      let n = 0;
+      i = new Error(e.replace(/%s/g, function() {
+        return t[n++];
+      })), i.name = "Invariant Violation";
+    }
+    throw i.framesToPop = 1, i;
+  }
+}
+function ve() {
+  return typeof process < "u" && process.env.NODE_ENV === "production";
+}
+const F = typeof global < "u" ? global : self, z = F.MutationObserver || F.WebKitMutationObserver;
+function W(r) {
+  return function() {
+    const t = setTimeout(n, 0), i = setInterval(n, 50);
+    function n() {
+      clearTimeout(t), clearInterval(i), r();
+    }
+  };
+}
+function De(r) {
+  let e = 1;
+  const t = new z(r), i = document.createTextNode("");
+  return t.observe(i, {
+    characterData: !0
+  }), function() {
+    e = -e, i.data = e;
+  };
+}
+const me = typeof z == "function" ? (
+  // reliably everywhere they are implemented.
+  // They are implemented in all modern browsers.
+  //
+  // - Android 4-4.3
+  // - Chrome 26-34
+  // - Firefox 14-29
+  // - Internet Explorer 11
+  // - iPad Safari 6-7.1
+  // - iPhone Safari 7-7.1
+  // - Safari 6-7
+  De
+) : (
+  // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
+  // 11-12, and in web workers in many engines.
+  // Although message channels yield to any queued rendering and IO tasks, they
+  // would be better than imposing the 4ms delay of timers.
+  // However, they do not work reliably in Internet Explorer or Safari.
+  // Internet Explorer 10 is the only browser that has setImmediate but does
+  // not have MutationObservers.
+  // Although setImmediate yields to the browser's renderer, it would be
+  // preferrable to falling back to setTimeout since it does not have
+  // the minimum 4ms penalty.
+  // Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
+  // Desktop to a lesser extent) that renders both setImmediate and
+  // MessageChannel useless for the purposes of ASAP.
+  // https://github.com/kriskowal/q/issues/396
+  // Timers are implemented universally.
+  // We fall back to timers in workers in most engines, and in foreground
+  // contexts in the following browsers.
+  // However, note that even this simple case requires nuances to operate in a
+  // broad spectrum of browsers.
+  //
+  // - Firefox 3-13
+  // - Internet Explorer 6-9
+  // - iPad Safari 4.3
+  // - Lynx 2.8.7
+  W
+);
+class Te {
+  // Use the fastest means possible to execute a task in its own turn, with
+  // priority over other events including IO, animation, reflow, and redraw
+  // events in browsers.
+  //
+  // An exception thrown by a task will permanently interrupt the processing of
+  // subsequent tasks. The higher level `asap` function ensures that if an
+  // exception is thrown by a task, that the task queue will continue flushing as
+  // soon as possible, but if you use `rawAsap` directly, you are responsible to
+  // either ensure that no exceptions are thrown from your task, or to manually
+  // call `rawAsap.requestFlush` if an exception is thrown.
+  enqueueTask(e) {
+    const { queue: t, requestFlush: i } = this;
+    t.length || (i(), this.flushing = !0), t[t.length] = e;
+  }
+  constructor() {
+    this.queue = [], this.pendingErrors = [], this.flushing = !1, this.index = 0, this.capacity = 1024, this.flush = () => {
+      const { queue: e } = this;
+      for (; this.index < e.length; ) {
+        const t = this.index;
+        if (this.index++, e[t].call(), this.index > this.capacity) {
+          for (let i = 0, n = e.length - this.index; i < n; i++)
+            e[i] = e[i + this.index];
+          e.length -= this.index, this.index = 0;
+        }
+      }
+      e.length = 0, this.index = 0, this.flushing = !1;
+    }, this.registerPendingError = (e) => {
+      this.pendingErrors.push(e), this.requestErrorThrow();
+    }, this.requestFlush = me(this.flush), this.requestErrorThrow = W(() => {
+      if (this.pendingErrors.length)
+        throw this.pendingErrors.shift();
+    });
+  }
+}
+class Ie {
+  call() {
+    try {
+      this.task && this.task();
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      this.task = null, this.release(this);
+    }
+  }
+  constructor(e, t) {
+    this.onError = e, this.release = t, this.task = null;
+  }
+}
+class Se {
+  create(e) {
+    const t = this.freeTasks, i = t.length ? t.pop() : new Ie(
+      this.onError,
+      (n) => t[t.length] = n
+    );
+    return i.task = e, i;
+  }
+  constructor(e) {
+    this.onError = e, this.freeTasks = [];
+  }
+}
+const B = new Te(), Oe = new Se(B.registerPendingError);
+function pt(r) {
+  B.enqueueTask(Oe.create(r));
+}
+function Ce(r, e) {
+  if (r == null) return {};
+  var t = we(r, e), i, n;
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(r);
+    for (n = 0; n < s.length; n++)
+      i = s[n], !(e.indexOf(i) >= 0) && Object.prototype.propertyIsEnumerable.call(r, i) && (t[i] = r[i]);
+  }
+  return t;
+}
+function we(r, e) {
+  if (r == null) return {};
+  var t = {}, i = Object.keys(r), n, s;
+  for (s = 0; s < i.length; s++)
+    n = i[s], !(e.indexOf(n) >= 0) && (t[n] = r[n]);
+  return t;
+}
+let A = 0;
+const E = Symbol.for("__REACT_DND_CONTEXT_INSTANCE__");
+var vt = /* @__PURE__ */ ue(function(e) {
+  var { children: t } = e, i = Ce(e, [
+    "children"
+  ]);
+  const [n, s] = Ee(i);
+  return y(() => {
+    if (s) {
+      const a = V();
+      return ++A, () => {
+        --A === 0 && (a[E] = null);
+      };
+    }
+  }, []), /* @__PURE__ */ oe.jsx(X.Provider, {
+    value: n,
+    children: t
+  });
+});
+function Ee(r) {
+  if ("manager" in r)
+    return [
+      {
+        dragDropManager: r.manager
+      },
+      !1
+    ];
+  const e = ye(r.backend, r.context, r.options, r.debugMode), t = !r.context;
+  return [
+    e,
+    t
+  ];
+}
+function ye(r, e = V(), t, i) {
+  const n = e;
+  return n[E] || (n[E] = {
+    dragDropManager: pe(r, e, t, i)
+  }), n[E];
+}
+function V() {
+  return typeof global < "u" ? global : window;
+}
+const I = typeof window < "u" ? de : y;
+function be(r, e, t) {
+  const [i, n] = le(
+    () => e(r)
+  ), s = he(() => {
+    const a = e(r);
+    ae(i, a) || (n(a), t && t());
+  }, [
+    i,
+    r,
+    t
+  ]);
+  return I(s), [
+    i,
+    s
+  ];
+}
+function Pe(r, e, t) {
+  const [i, n] = be(r, e, t);
+  return I(function() {
+    const a = r.getHandlerId();
+    if (a != null)
+      return r.subscribeToStateChange(n, {
+        handlerIds: [
+          a
+        ]
+      });
+  }, [
+    r,
+    n
+  ]), i;
+}
+function K(r, e, t) {
+  return Pe(
+    e,
+    r || (() => ({})),
+    () => t.reconnect()
+  );
+}
+function G(r, e) {
+  const t = [];
+  return typeof r != "function" && t.push(r), p(() => typeof r == "function" ? r() : r, t);
+}
+function Ne(r) {
+  return p(
+    () => r.hooks.dragSource(),
+    [
+      r
+    ]
+  );
+}
+function Me(r) {
+  return p(
+    () => r.hooks.dragPreview(),
+    [
+      r
+    ]
+  );
+}
+let b = !1, P = !1;
+class xe {
+  receiveHandlerId(e) {
+    this.sourceId = e;
+  }
+  getHandlerId() {
+    return this.sourceId;
+  }
+  canDrag() {
+    T(!b, "You may not call monitor.canDrag() inside your canDrag() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor");
+    try {
+      return b = !0, this.internalMonitor.canDragSource(this.sourceId);
+    } finally {
+      b = !1;
+    }
+  }
+  isDragging() {
+    if (!this.sourceId)
+      return !1;
+    T(!P, "You may not call monitor.isDragging() inside your isDragging() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor");
+    try {
+      return P = !0, this.internalMonitor.isDraggingSource(this.sourceId);
+    } finally {
+      P = !1;
+    }
+  }
+  subscribeToStateChange(e, t) {
+    return this.internalMonitor.subscribeToStateChange(e, t);
+  }
+  isDraggingSource(e) {
+    return this.internalMonitor.isDraggingSource(e);
+  }
+  isOverTarget(e, t) {
+    return this.internalMonitor.isOverTarget(e, t);
+  }
+  getTargetIds() {
+    return this.internalMonitor.getTargetIds();
+  }
+  isSourcePublic() {
+    return this.internalMonitor.isSourcePublic();
+  }
+  getSourceId() {
+    return this.internalMonitor.getSourceId();
+  }
+  subscribeToOffsetChange(e) {
+    return this.internalMonitor.subscribeToOffsetChange(e);
+  }
+  canDragSource(e) {
+    return this.internalMonitor.canDragSource(e);
+  }
+  canDropOnTarget(e) {
+    return this.internalMonitor.canDropOnTarget(e);
+  }
+  getItemType() {
+    return this.internalMonitor.getItemType();
+  }
+  getItem() {
+    return this.internalMonitor.getItem();
+  }
+  getDropResult() {
+    return this.internalMonitor.getDropResult();
+  }
+  didDrop() {
+    return this.internalMonitor.didDrop();
+  }
+  getInitialClientOffset() {
+    return this.internalMonitor.getInitialClientOffset();
+  }
+  getInitialSourceClientOffset() {
+    return this.internalMonitor.getInitialSourceClientOffset();
+  }
+  getSourceClientOffset() {
+    return this.internalMonitor.getSourceClientOffset();
+  }
+  getClientOffset() {
+    return this.internalMonitor.getClientOffset();
+  }
+  getDifferenceFromInitialOffset() {
+    return this.internalMonitor.getDifferenceFromInitialOffset();
+  }
+  constructor(e) {
+    this.sourceId = null, this.internalMonitor = e.getMonitor();
+  }
+}
+let N = !1;
+class Le {
+  receiveHandlerId(e) {
+    this.targetId = e;
+  }
+  getHandlerId() {
+    return this.targetId;
+  }
+  subscribeToStateChange(e, t) {
+    return this.internalMonitor.subscribeToStateChange(e, t);
+  }
+  canDrop() {
+    if (!this.targetId)
+      return !1;
+    T(!N, "You may not call monitor.canDrop() inside your canDrop() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target-monitor");
+    try {
+      return N = !0, this.internalMonitor.canDropOnTarget(this.targetId);
+    } finally {
+      N = !1;
+    }
+  }
+  isOver(e) {
+    return this.targetId ? this.internalMonitor.isOverTarget(this.targetId, e) : !1;
+  }
+  getItemType() {
+    return this.internalMonitor.getItemType();
+  }
+  getItem() {
+    return this.internalMonitor.getItem();
+  }
+  getDropResult() {
+    return this.internalMonitor.getDropResult();
+  }
+  didDrop() {
+    return this.internalMonitor.didDrop();
+  }
+  getInitialClientOffset() {
+    return this.internalMonitor.getInitialClientOffset();
+  }
+  getInitialSourceClientOffset() {
+    return this.internalMonitor.getInitialSourceClientOffset();
+  }
+  getSourceClientOffset() {
+    return this.internalMonitor.getSourceClientOffset();
+  }
+  getClientOffset() {
+    return this.internalMonitor.getClientOffset();
+  }
+  getDifferenceFromInitialOffset() {
+    return this.internalMonitor.getDifferenceFromInitialOffset();
+  }
+  constructor(e) {
+    this.targetId = null, this.internalMonitor = e.getMonitor();
+  }
+}
+function Re(r, e, t) {
+  const i = t.getRegistry(), n = i.addTarget(r, e);
+  return [
+    n,
+    () => i.removeTarget(n)
+  ];
+}
+function He(r, e, t) {
+  const i = t.getRegistry(), n = i.addSource(r, e);
+  return [
+    n,
+    () => i.removeSource(n)
+  ];
+}
+function L(r, e, t, i) {
+  let n;
+  if (n !== void 0)
+    return !!n;
+  if (r === e)
+    return !0;
+  if (typeof r != "object" || !r || typeof e != "object" || !e)
+    return !1;
+  const s = Object.keys(r), a = Object.keys(e);
+  if (s.length !== a.length)
+    return !1;
+  const o = Object.prototype.hasOwnProperty.bind(e);
+  for (let u = 0; u < s.length; u++) {
+    const d = s[u];
+    if (!o(d))
+      return !1;
+    const l = r[d], h = e[d];
+    if (n = void 0, n === !1 || n === void 0 && l !== h)
+      return !1;
+  }
+  return !0;
+}
+function R(r) {
+  return (
+    // eslint-disable-next-line no-prototype-builtins
+    r !== null && typeof r == "object" && Object.prototype.hasOwnProperty.call(r, "current")
+  );
+}
+function _e(r) {
+  if (typeof r.type == "string")
+    return;
+  const e = r.type.displayName || r.type.name || "the component";
+  throw new Error(`Only native element nodes can now be passed to React DnD connectors.You can either wrap ${e} into a <div>, or turn it into a drag source or a drop target itself.`);
+}
+function ke(r) {
+  return (e = null, t = null) => {
+    if (!ge(e)) {
+      const s = e;
+      return r(s, t), s;
+    }
+    const i = e;
+    return _e(i), Fe(i, t ? (s) => r(s, t) : r);
+  };
+}
+function $(r) {
+  const e = {};
+  return Object.keys(r).forEach((t) => {
+    const i = r[t];
+    if (t.endsWith("Ref"))
+      e[t] = r[t];
+    else {
+      const n = ke(i);
+      e[t] = () => n;
+    }
+  }), e;
+}
+function q(r, e) {
+  typeof r == "function" ? r(e) : r.current = e;
+}
+function Fe(r, e) {
+  const t = r.ref;
+  return T(typeof t != "string", "Cannot connect React DnD to an element with an existing string ref. Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. Read more: https://reactjs.org/docs/refs-and-the-dom.html#callback-refs"), t ? k(r, {
+    ref: (i) => {
+      q(t, i), q(e, i);
+    }
+  }) : k(r, {
+    ref: e
+  });
+}
+class Ae {
+  receiveHandlerId(e) {
+    this.handlerId !== e && (this.handlerId = e, this.reconnect());
+  }
+  get connectTarget() {
+    return this.dragSource;
+  }
+  get dragSourceOptions() {
+    return this.dragSourceOptionsInternal;
+  }
+  set dragSourceOptions(e) {
+    this.dragSourceOptionsInternal = e;
+  }
+  get dragPreviewOptions() {
+    return this.dragPreviewOptionsInternal;
+  }
+  set dragPreviewOptions(e) {
+    this.dragPreviewOptionsInternal = e;
+  }
+  reconnect() {
+    const e = this.reconnectDragSource();
+    this.reconnectDragPreview(e);
+  }
+  reconnectDragSource() {
+    const e = this.dragSource, t = this.didHandlerIdChange() || this.didConnectedDragSourceChange() || this.didDragSourceOptionsChange();
+    return t && this.disconnectDragSource(), this.handlerId ? e ? (t && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDragSource = e, this.lastConnectedDragSourceOptions = this.dragSourceOptions, this.dragSourceUnsubscribe = this.backend.connectDragSource(this.handlerId, e, this.dragSourceOptions)), t) : (this.lastConnectedDragSource = e, t) : t;
+  }
+  reconnectDragPreview(e = !1) {
+    const t = this.dragPreview, i = e || this.didHandlerIdChange() || this.didConnectedDragPreviewChange() || this.didDragPreviewOptionsChange();
+    if (i && this.disconnectDragPreview(), !!this.handlerId) {
+      if (!t) {
+        this.lastConnectedDragPreview = t;
+        return;
+      }
+      i && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDragPreview = t, this.lastConnectedDragPreviewOptions = this.dragPreviewOptions, this.dragPreviewUnsubscribe = this.backend.connectDragPreview(this.handlerId, t, this.dragPreviewOptions));
+    }
+  }
+  didHandlerIdChange() {
+    return this.lastConnectedHandlerId !== this.handlerId;
+  }
+  didConnectedDragSourceChange() {
+    return this.lastConnectedDragSource !== this.dragSource;
+  }
+  didConnectedDragPreviewChange() {
+    return this.lastConnectedDragPreview !== this.dragPreview;
+  }
+  didDragSourceOptionsChange() {
+    return !L(this.lastConnectedDragSourceOptions, this.dragSourceOptions);
+  }
+  didDragPreviewOptionsChange() {
+    return !L(this.lastConnectedDragPreviewOptions, this.dragPreviewOptions);
+  }
+  disconnectDragSource() {
+    this.dragSourceUnsubscribe && (this.dragSourceUnsubscribe(), this.dragSourceUnsubscribe = void 0);
+  }
+  disconnectDragPreview() {
+    this.dragPreviewUnsubscribe && (this.dragPreviewUnsubscribe(), this.dragPreviewUnsubscribe = void 0, this.dragPreviewNode = null, this.dragPreviewRef = null);
+  }
+  get dragSource() {
+    return this.dragSourceNode || this.dragSourceRef && this.dragSourceRef.current;
+  }
+  get dragPreview() {
+    return this.dragPreviewNode || this.dragPreviewRef && this.dragPreviewRef.current;
+  }
+  clearDragSource() {
+    this.dragSourceNode = null, this.dragSourceRef = null;
+  }
+  clearDragPreview() {
+    this.dragPreviewNode = null, this.dragPreviewRef = null;
+  }
+  constructor(e) {
+    this.hooks = $({
+      dragSource: (t, i) => {
+        this.clearDragSource(), this.dragSourceOptions = i || null, R(t) ? this.dragSourceRef = t : this.dragSourceNode = t, this.reconnectDragSource();
+      },
+      dragPreview: (t, i) => {
+        this.clearDragPreview(), this.dragPreviewOptions = i || null, R(t) ? this.dragPreviewRef = t : this.dragPreviewNode = t, this.reconnectDragPreview();
+      }
+    }), this.handlerId = null, this.dragSourceRef = null, this.dragSourceOptionsInternal = null, this.dragPreviewRef = null, this.dragPreviewOptionsInternal = null, this.lastConnectedHandlerId = null, this.lastConnectedDragSource = null, this.lastConnectedDragSourceOptions = null, this.lastConnectedDragPreview = null, this.lastConnectedDragPreviewOptions = null, this.backend = e;
+  }
+}
+class qe {
+  get connectTarget() {
+    return this.dropTarget;
+  }
+  reconnect() {
+    const e = this.didHandlerIdChange() || this.didDropTargetChange() || this.didOptionsChange();
+    e && this.disconnectDropTarget();
+    const t = this.dropTarget;
+    if (this.handlerId) {
+      if (!t) {
+        this.lastConnectedDropTarget = t;
+        return;
+      }
+      e && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDropTarget = t, this.lastConnectedDropTargetOptions = this.dropTargetOptions, this.unsubscribeDropTarget = this.backend.connectDropTarget(this.handlerId, t, this.dropTargetOptions));
+    }
+  }
+  receiveHandlerId(e) {
+    e !== this.handlerId && (this.handlerId = e, this.reconnect());
+  }
+  get dropTargetOptions() {
+    return this.dropTargetOptionsInternal;
+  }
+  set dropTargetOptions(e) {
+    this.dropTargetOptionsInternal = e;
+  }
+  didHandlerIdChange() {
+    return this.lastConnectedHandlerId !== this.handlerId;
+  }
+  didDropTargetChange() {
+    return this.lastConnectedDropTarget !== this.dropTarget;
+  }
+  didOptionsChange() {
+    return !L(this.lastConnectedDropTargetOptions, this.dropTargetOptions);
+  }
+  disconnectDropTarget() {
+    this.unsubscribeDropTarget && (this.unsubscribeDropTarget(), this.unsubscribeDropTarget = void 0);
+  }
+  get dropTarget() {
+    return this.dropTargetNode || this.dropTargetRef && this.dropTargetRef.current;
+  }
+  clearDropTarget() {
+    this.dropTargetRef = null, this.dropTargetNode = null;
+  }
+  constructor(e) {
+    this.hooks = $({
+      dropTarget: (t, i) => {
+        this.clearDropTarget(), this.dropTargetOptions = i, R(t) ? this.dropTargetRef = t : this.dropTargetNode = t, this.reconnect();
+      }
+    }), this.handlerId = null, this.dropTargetRef = null, this.dropTargetOptionsInternal = null, this.lastConnectedHandlerId = null, this.lastConnectedDropTarget = null, this.lastConnectedDropTargetOptions = null, this.backend = e;
+  }
+}
+function S() {
+  const { dragDropManager: r } = fe(X);
+  return T(r != null, "Expected drag drop context"), r;
+}
+function je(r, e) {
+  const t = S(), i = p(
+    () => new Ae(t.getBackend()),
+    [
+      t
+    ]
+  );
+  return I(() => (i.dragSourceOptions = r || null, i.reconnect(), () => i.disconnectDragSource()), [
+    i,
+    r
+  ]), I(() => (i.dragPreviewOptions = e || null, i.reconnect(), () => i.disconnectDragPreview()), [
+    i,
+    e
+  ]), i;
+}
+function Ue() {
+  const r = S();
+  return p(
+    () => new xe(r),
+    [
+      r
+    ]
+  );
+}
+class Ye {
+  beginDrag() {
+    const e = this.spec, t = this.monitor;
+    let i = null;
+    return typeof e.item == "object" ? i = e.item : typeof e.item == "function" ? i = e.item(t) : i = {}, i ?? null;
+  }
+  canDrag() {
+    const e = this.spec, t = this.monitor;
+    return typeof e.canDrag == "boolean" ? e.canDrag : typeof e.canDrag == "function" ? e.canDrag(t) : !0;
+  }
+  isDragging(e, t) {
+    const i = this.spec, n = this.monitor, { isDragging: s } = i;
+    return s ? s(n) : t === e.getSourceId();
+  }
+  endDrag() {
+    const e = this.spec, t = this.monitor, i = this.connector, { end: n } = e;
+    n && n(t.getItem(), t), i.reconnect();
+  }
+  constructor(e, t, i) {
+    this.spec = e, this.monitor = t, this.connector = i;
+  }
+}
+function Xe(r, e, t) {
+  const i = p(
+    () => new Ye(r, e, t),
+    [
+      e,
+      t
+    ]
+  );
+  return y(() => {
+    i.spec = r;
+  }, [
+    r
+  ]), i;
+}
+function ze(r) {
+  return p(() => {
+    const e = r.type;
+    return T(e != null, "spec.type must be defined"), e;
+  }, [
+    r
+  ]);
+}
+function We(r, e, t) {
+  const i = S(), n = Xe(r, e, t), s = ze(r);
+  I(function() {
+    if (s != null) {
+      const [o, u] = He(s, n, i);
+      return e.receiveHandlerId(o), t.receiveHandlerId(o), u;
+    }
+  }, [
+    i,
+    e,
+    t,
+    n,
+    s
+  ]);
+}
+function Dt(r, e) {
+  const t = G(r);
+  T(!t.begin, "useDrag::spec.begin was deprecated in v14. Replace spec.begin() with spec.item(). (see more here - https://react-dnd.github.io/react-dnd/docs/api/use-drag)");
+  const i = Ue(), n = je(t.options, t.previewOptions);
+  return We(t, i, n), [
+    K(t.collect, i, n),
+    Ne(n),
+    Me(n)
+  ];
+}
+function Be(r) {
+  return p(
+    () => r.hooks.dropTarget(),
+    [
+      r
+    ]
+  );
+}
+function Ve(r) {
+  const e = S(), t = p(
+    () => new qe(e.getBackend()),
+    [
+      e
+    ]
+  );
+  return I(() => (t.dropTargetOptions = r || null, t.reconnect(), () => t.disconnectDropTarget()), [
+    r
+  ]), t;
+}
+function Ke() {
+  const r = S();
+  return p(
+    () => new Le(r),
+    [
+      r
+    ]
+  );
+}
+function Ge(r) {
+  const { accept: e } = r;
+  return p(() => (T(r.accept != null, "accept must be defined"), Array.isArray(e) ? e : [
+    e
+  ]), [
+    e
+  ]);
+}
+class $e {
+  canDrop() {
+    const e = this.spec, t = this.monitor;
+    return e.canDrop ? e.canDrop(t.getItem(), t) : !0;
+  }
+  hover() {
+    const e = this.spec, t = this.monitor;
+    e.hover && e.hover(t.getItem(), t);
+  }
+  drop() {
+    const e = this.spec, t = this.monitor;
+    if (e.drop)
+      return e.drop(t.getItem(), t);
+  }
+  constructor(e, t) {
+    this.spec = e, this.monitor = t;
+  }
+}
+function Qe(r, e) {
+  const t = p(
+    () => new $e(r, e),
+    [
+      e
+    ]
+  );
+  return y(() => {
+    t.spec = r;
+  }, [
+    r
+  ]), t;
+}
+function Je(r, e, t) {
+  const i = S(), n = Qe(r, e), s = Ge(r);
+  I(function() {
+    const [o, u] = Re(s, n, i);
+    return e.receiveHandlerId(o), t.receiveHandlerId(o), u;
+  }, [
+    i,
+    e,
+    n,
+    t,
+    s.map(
+      (a) => a.toString()
+    ).join("|")
+  ]);
+}
+function mt(r, e) {
+  const t = G(r), i = Ke(), n = Ve(t.options);
+  return Je(t, i, n), [
+    K(t.collect, i, n),
+    Be(n)
+  ];
+}
+function Q(r) {
+  let e = null;
+  return () => (e == null && (e = r()), e);
+}
+function Ze(r, e) {
+  return r.filter(
+    (t) => t !== e
+  );
+}
+function et(r, e) {
+  const t = /* @__PURE__ */ new Set(), i = (s) => t.add(s);
+  r.forEach(i), e.forEach(i);
+  const n = [];
+  return t.forEach(
+    (s) => n.push(s)
+  ), n;
+}
+class tt {
+  enter(e) {
+    const t = this.entered.length, i = (n) => this.isNodeInDocument(n) && (!n.contains || n.contains(e));
+    return this.entered = et(this.entered.filter(i), [
+      e
+    ]), t === 0 && this.entered.length > 0;
+  }
+  leave(e) {
+    const t = this.entered.length;
+    return this.entered = Ze(this.entered.filter(this.isNodeInDocument), e), t > 0 && this.entered.length === 0;
+  }
+  reset() {
+    this.entered = [];
+  }
+  constructor(e) {
+    this.entered = [], this.isNodeInDocument = e;
+  }
+}
+class rt {
+  initializeExposedProperties() {
+    Object.keys(this.config.exposeProperties).forEach((e) => {
+      Object.defineProperty(this.item, e, {
+        configurable: !0,
+        enumerable: !0,
+        get() {
+          return console.warn(`Browser doesn't allow reading "${e}" until the drop event.`), null;
+        }
+      });
+    });
+  }
+  loadDataTransfer(e) {
+    if (e) {
+      const t = {};
+      Object.keys(this.config.exposeProperties).forEach((i) => {
+        const n = this.config.exposeProperties[i];
+        n != null && (t[i] = {
+          value: n(e, this.config.matchesTypes),
+          configurable: !0,
+          enumerable: !0
+        });
+      }), Object.defineProperties(this.item, t);
+    }
+  }
+  canDrag() {
+    return !0;
+  }
+  beginDrag() {
+    return this.item;
+  }
+  isDragging(e, t) {
+    return t === e.getSourceId();
+  }
+  endDrag() {
+  }
+  constructor(e) {
+    this.config = e, this.item = {}, this.initializeExposedProperties();
+  }
+}
+const J = "__NATIVE_FILE__", Z = "__NATIVE_URL__", ee = "__NATIVE_TEXT__", te = "__NATIVE_HTML__", j = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FILE: J,
+  HTML: te,
+  TEXT: ee,
+  URL: Z
+}, Symbol.toStringTag, { value: "Module" }));
+function M(r, e, t) {
+  const i = e.reduce(
+    (n, s) => n || r.getData(s),
+    ""
+  );
+  return i ?? t;
+}
+const H = {
+  [J]: {
+    exposeProperties: {
+      files: (r) => Array.prototype.slice.call(r.files),
+      items: (r) => r.items,
+      dataTransfer: (r) => r
+    },
+    matchesTypes: [
+      "Files"
+    ]
+  },
+  [te]: {
+    exposeProperties: {
+      html: (r, e) => M(r, e, ""),
+      dataTransfer: (r) => r
+    },
+    matchesTypes: [
+      "Html",
+      "text/html"
+    ]
+  },
+  [Z]: {
+    exposeProperties: {
+      urls: (r, e) => M(r, e, "").split(`
+`),
+      dataTransfer: (r) => r
+    },
+    matchesTypes: [
+      "Url",
+      "text/uri-list"
+    ]
+  },
+  [ee]: {
+    exposeProperties: {
+      text: (r, e) => M(r, e, ""),
+      dataTransfer: (r) => r
+    },
+    matchesTypes: [
+      "Text",
+      "text/plain"
+    ]
+  }
+};
+function nt(r, e) {
+  const t = H[r];
+  if (!t)
+    throw new Error(`native type ${r} has no configuration`);
+  const i = new rt(t);
+  return i.loadDataTransfer(e), i;
+}
+function x(r) {
+  if (!r)
+    return null;
+  const e = Array.prototype.slice.call(r.types || []);
+  return Object.keys(H).filter((t) => {
+    const i = H[t];
+    return i?.matchesTypes ? i.matchesTypes.some(
+      (n) => e.indexOf(n) > -1
+    ) : !1;
+  })[0] || null;
+}
+const it = Q(
+  () => /firefox/i.test(navigator.userAgent)
+), re = Q(
+  () => !!window.safari
+);
+class U {
+  interpolate(e) {
+    const { xs: t, ys: i, c1s: n, c2s: s, c3s: a } = this;
+    let o = t.length - 1;
+    if (e === t[o])
+      return i[o];
+    let u = 0, d = a.length - 1, l;
+    for (; u <= d; ) {
+      l = Math.floor(0.5 * (u + d));
+      const c = t[l];
+      if (c < e)
+        u = l + 1;
+      else if (c > e)
+        d = l - 1;
+      else
+        return i[l];
+    }
+    o = Math.max(0, d);
+    const h = e - t[o], g = h * h;
+    return i[o] + n[o] * h + s[o] * g + a[o] * h * g;
+  }
+  constructor(e, t) {
+    const { length: i } = e, n = [];
+    for (let c = 0; c < i; c++)
+      n.push(c);
+    n.sort(
+      (c, f) => e[c] < e[f] ? -1 : 1
+    );
+    const s = [], a = [];
+    let o, u;
+    for (let c = 0; c < i - 1; c++)
+      o = e[c + 1] - e[c], u = t[c + 1] - t[c], s.push(o), a.push(u / o);
+    const d = [
+      a[0]
+    ];
+    for (let c = 0; c < s.length - 1; c++) {
+      const f = a[c], v = a[c + 1];
+      if (f * v <= 0)
+        d.push(0);
+      else {
+        o = s[c];
+        const D = s[c + 1], m = o + D;
+        d.push(3 * m / ((m + D) / f + (m + o) / v));
+      }
+    }
+    d.push(a[a.length - 1]);
+    const l = [], h = [];
+    let g;
+    for (let c = 0; c < d.length - 1; c++) {
+      g = a[c];
+      const f = d[c], v = 1 / s[c], D = f + d[c + 1] - g - g;
+      l.push((g - f - D) * v), h.push(D * v * v);
+    }
+    this.xs = e, this.ys = t, this.c1s = d, this.c2s = l, this.c3s = h;
+  }
+}
+const st = 1;
+function ne(r) {
+  const e = r.nodeType === st ? r : r.parentElement;
+  if (!e)
+    return null;
+  const { top: t, left: i } = e.getBoundingClientRect();
+  return {
+    x: i,
+    y: t
+  };
+}
+function w(r) {
+  return {
+    x: r.clientX,
+    y: r.clientY
+  };
+}
+function ot(r) {
+  var e;
+  return r.nodeName === "IMG" && (it() || !(!((e = document.documentElement) === null || e === void 0) && e.contains(r)));
+}
+function at(r, e, t, i) {
+  let n = r ? e.width : t, s = r ? e.height : i;
+  return re() && r && (s /= window.devicePixelRatio, n /= window.devicePixelRatio), {
+    dragPreviewWidth: n,
+    dragPreviewHeight: s
+  };
+}
+function ct(r, e, t, i, n) {
+  const s = ot(e), o = ne(s ? r : e), u = {
+    x: t.x - o.x,
+    y: t.y - o.y
+  }, { offsetWidth: d, offsetHeight: l } = r, { anchorX: h, anchorY: g } = i, { dragPreviewWidth: c, dragPreviewHeight: f } = at(s, e, d, l), v = () => {
+    let _ = new U([
+      0,
+      0.5,
+      1
+    ], [
+      // Dock to the top
+      u.y,
+      // Align at the center
+      u.y / l * f,
+      // Dock to the bottom
+      u.y + f - l
+    ]).interpolate(g);
+    return re() && s && (_ += (window.devicePixelRatio - 1) * f), _;
+  }, D = () => new U([
+    0,
+    0.5,
+    1
+  ], [
+    // Dock to the left
+    u.x,
+    // Align at the center
+    u.x / d * c,
+    // Dock to the right
+    u.x + c - d
+  ]).interpolate(h), { offsetX: m, offsetY: O } = n, C = m === 0 || m, ie = O === 0 || O;
+  return {
+    x: C ? m : D(),
+    y: ie ? O : v()
+  };
+}
+class ut {
+  get window() {
+    if (this.globalContext)
+      return this.globalContext;
+    if (typeof window < "u")
+      return window;
+  }
+  get document() {
+    var e;
+    return !((e = this.globalContext) === null || e === void 0) && e.document ? this.globalContext.document : this.window ? this.window.document : void 0;
+  }
+  get rootElement() {
+    var e;
+    return ((e = this.optionsArgs) === null || e === void 0 ? void 0 : e.rootElement) || this.window;
+  }
+  constructor(e, t) {
+    this.ownerDocument = null, this.globalContext = e, this.optionsArgs = t;
+  }
+}
+function dt(r, e, t) {
+  return e in r ? Object.defineProperty(r, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[e] = t, r;
+}
+function Y(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {}, i = Object.keys(t);
+    typeof Object.getOwnPropertySymbols == "function" && (i = i.concat(Object.getOwnPropertySymbols(t).filter(function(n) {
+      return Object.getOwnPropertyDescriptor(t, n).enumerable;
+    }))), i.forEach(function(n) {
+      dt(r, n, t[n]);
+    });
+  }
+  return r;
+}
+class lt {
+  /**
+  * Generate profiling statistics for the HTML5Backend.
+  */
+  profile() {
+    var e, t;
+    return {
+      sourcePreviewNodes: this.sourcePreviewNodes.size,
+      sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+      sourceNodeOptions: this.sourceNodeOptions.size,
+      sourceNodes: this.sourceNodes.size,
+      dragStartSourceIds: ((e = this.dragStartSourceIds) === null || e === void 0 ? void 0 : e.length) || 0,
+      dropTargetIds: this.dropTargetIds.length,
+      dragEnterTargetIds: this.dragEnterTargetIds.length,
+      dragOverTargetIds: ((t = this.dragOverTargetIds) === null || t === void 0 ? void 0 : t.length) || 0
+    };
+  }
+  // public for test
+  get window() {
+    return this.options.window;
+  }
+  get document() {
+    return this.options.document;
+  }
+  /**
+  * Get the root element to use for event subscriptions
+  */
+  get rootElement() {
+    return this.options.rootElement;
+  }
+  setup() {
+    const e = this.rootElement;
+    if (e !== void 0) {
+      if (e.__isReactDndBackendSetUp)
+        throw new Error("Cannot have two HTML5 backends at the same time.");
+      e.__isReactDndBackendSetUp = !0, this.addEventListeners(e);
+    }
+  }
+  teardown() {
+    const e = this.rootElement;
+    if (e !== void 0 && (e.__isReactDndBackendSetUp = !1, this.removeEventListeners(this.rootElement), this.clearCurrentDragSourceNode(), this.asyncEndDragFrameId)) {
+      var t;
+      (t = this.window) === null || t === void 0 || t.cancelAnimationFrame(this.asyncEndDragFrameId);
+    }
+  }
+  connectDragPreview(e, t, i) {
+    return this.sourcePreviewNodeOptions.set(e, i), this.sourcePreviewNodes.set(e, t), () => {
+      this.sourcePreviewNodes.delete(e), this.sourcePreviewNodeOptions.delete(e);
+    };
+  }
+  connectDragSource(e, t, i) {
+    this.sourceNodes.set(e, t), this.sourceNodeOptions.set(e, i);
+    const n = (a) => this.handleDragStart(a, e), s = (a) => this.handleSelectStart(a);
+    return t.setAttribute("draggable", "true"), t.addEventListener("dragstart", n), t.addEventListener("selectstart", s), () => {
+      this.sourceNodes.delete(e), this.sourceNodeOptions.delete(e), t.removeEventListener("dragstart", n), t.removeEventListener("selectstart", s), t.setAttribute("draggable", "false");
+    };
+  }
+  connectDropTarget(e, t) {
+    const i = (a) => this.handleDragEnter(a, e), n = (a) => this.handleDragOver(a, e), s = (a) => this.handleDrop(a, e);
+    return t.addEventListener("dragenter", i), t.addEventListener("dragover", n), t.addEventListener("drop", s), () => {
+      t.removeEventListener("dragenter", i), t.removeEventListener("dragover", n), t.removeEventListener("drop", s);
+    };
+  }
+  addEventListeners(e) {
+    e.addEventListener && (e.addEventListener("dragstart", this.handleTopDragStart), e.addEventListener("dragstart", this.handleTopDragStartCapture, !0), e.addEventListener("dragend", this.handleTopDragEndCapture, !0), e.addEventListener("dragenter", this.handleTopDragEnter), e.addEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.addEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.addEventListener("dragover", this.handleTopDragOver), e.addEventListener("dragover", this.handleTopDragOverCapture, !0), e.addEventListener("drop", this.handleTopDrop), e.addEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  removeEventListeners(e) {
+    e.removeEventListener && (e.removeEventListener("dragstart", this.handleTopDragStart), e.removeEventListener("dragstart", this.handleTopDragStartCapture, !0), e.removeEventListener("dragend", this.handleTopDragEndCapture, !0), e.removeEventListener("dragenter", this.handleTopDragEnter), e.removeEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.removeEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.removeEventListener("dragover", this.handleTopDragOver), e.removeEventListener("dragover", this.handleTopDragOverCapture, !0), e.removeEventListener("drop", this.handleTopDrop), e.removeEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  getCurrentSourceNodeOptions() {
+    const e = this.monitor.getSourceId(), t = this.sourceNodeOptions.get(e);
+    return Y({
+      dropEffect: this.altKeyPressed ? "copy" : "move"
+    }, t || {});
+  }
+  getCurrentDropEffect() {
+    return this.isDraggingNativeItem() ? "copy" : this.getCurrentSourceNodeOptions().dropEffect;
+  }
+  getCurrentSourcePreviewNodeOptions() {
+    const e = this.monitor.getSourceId(), t = this.sourcePreviewNodeOptions.get(e);
+    return Y({
+      anchorX: 0.5,
+      anchorY: 0.5,
+      captureDraggingState: !1
+    }, t || {});
+  }
+  isDraggingNativeItem() {
+    const e = this.monitor.getItemType();
+    return Object.keys(j).some(
+      (t) => j[t] === e
+    );
+  }
+  beginDragNativeItem(e, t) {
+    this.clearCurrentDragSourceNode(), this.currentNativeSource = nt(e, t), this.currentNativeHandle = this.registry.addSource(e, this.currentNativeSource), this.actions.beginDrag([
+      this.currentNativeHandle
+    ]);
+  }
+  setCurrentDragSourceNode(e) {
+    this.clearCurrentDragSourceNode(), this.currentDragSourceNode = e;
+    const t = 1e3;
+    this.mouseMoveTimeoutTimer = setTimeout(() => {
+      var i;
+      return (i = this.rootElement) === null || i === void 0 ? void 0 : i.addEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+    }, t);
+  }
+  clearCurrentDragSourceNode() {
+    if (this.currentDragSourceNode) {
+      if (this.currentDragSourceNode = null, this.rootElement) {
+        var e;
+        (e = this.window) === null || e === void 0 || e.clearTimeout(this.mouseMoveTimeoutTimer || void 0), this.rootElement.removeEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+      }
+      return this.mouseMoveTimeoutTimer = null, !0;
+    }
+    return !1;
+  }
+  handleDragStart(e, t) {
+    e.defaultPrevented || (this.dragStartSourceIds || (this.dragStartSourceIds = []), this.dragStartSourceIds.unshift(t));
+  }
+  handleDragEnter(e, t) {
+    this.dragEnterTargetIds.unshift(t);
+  }
+  handleDragOver(e, t) {
+    this.dragOverTargetIds === null && (this.dragOverTargetIds = []), this.dragOverTargetIds.unshift(t);
+  }
+  handleDrop(e, t) {
+    this.dropTargetIds.unshift(t);
+  }
+  constructor(e, t, i) {
+    this.sourcePreviewNodes = /* @__PURE__ */ new Map(), this.sourcePreviewNodeOptions = /* @__PURE__ */ new Map(), this.sourceNodes = /* @__PURE__ */ new Map(), this.sourceNodeOptions = /* @__PURE__ */ new Map(), this.dragStartSourceIds = null, this.dropTargetIds = [], this.dragEnterTargetIds = [], this.currentNativeSource = null, this.currentNativeHandle = null, this.currentDragSourceNode = null, this.altKeyPressed = !1, this.mouseMoveTimeoutTimer = null, this.asyncEndDragFrameId = null, this.dragOverTargetIds = null, this.lastClientOffset = null, this.hoverRafId = null, this.getSourceClientOffset = (n) => {
+      const s = this.sourceNodes.get(n);
+      return s && ne(s) || null;
+    }, this.endDragNativeItem = () => {
+      this.isDraggingNativeItem() && (this.actions.endDrag(), this.currentNativeHandle && this.registry.removeSource(this.currentNativeHandle), this.currentNativeHandle = null, this.currentNativeSource = null);
+    }, this.isNodeInDocument = (n) => !!(n && this.document && this.document.body && this.document.body.contains(n)), this.endDragIfSourceWasRemovedFromDOM = () => {
+      const n = this.currentDragSourceNode;
+      n == null || this.isNodeInDocument(n) || (this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover());
+    }, this.scheduleHover = (n) => {
+      this.hoverRafId === null && typeof requestAnimationFrame < "u" && (this.hoverRafId = requestAnimationFrame(() => {
+        this.monitor.isDragging() && this.actions.hover(n || [], {
+          clientOffset: this.lastClientOffset
+        }), this.hoverRafId = null;
+      }));
+    }, this.cancelHover = () => {
+      this.hoverRafId !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(this.hoverRafId), this.hoverRafId = null);
+    }, this.handleTopDragStartCapture = () => {
+      this.clearCurrentDragSourceNode(), this.dragStartSourceIds = [];
+    }, this.handleTopDragStart = (n) => {
+      if (n.defaultPrevented)
+        return;
+      const { dragStartSourceIds: s } = this;
+      this.dragStartSourceIds = null;
+      const a = w(n);
+      this.monitor.isDragging() && (this.actions.endDrag(), this.cancelHover()), this.actions.beginDrag(s || [], {
+        publishSource: !1,
+        getSourceClientOffset: this.getSourceClientOffset,
+        clientOffset: a
+      });
+      const { dataTransfer: o } = n, u = x(o);
+      if (this.monitor.isDragging()) {
+        if (o && typeof o.setDragImage == "function") {
+          const l = this.monitor.getSourceId(), h = this.sourceNodes.get(l), g = this.sourcePreviewNodes.get(l) || h;
+          if (g) {
+            const { anchorX: c, anchorY: f, offsetX: v, offsetY: D } = this.getCurrentSourcePreviewNodeOptions(), C = ct(h, g, a, {
+              anchorX: c,
+              anchorY: f
+            }, {
+              offsetX: v,
+              offsetY: D
+            });
+            o.setDragImage(g, C.x, C.y);
+          }
+        }
+        try {
+          o?.setData("application/json", {});
+        } catch {
+        }
+        this.setCurrentDragSourceNode(n.target);
+        const { captureDraggingState: d } = this.getCurrentSourcePreviewNodeOptions();
+        d ? this.actions.publishDragSource() : setTimeout(
+          () => this.actions.publishDragSource(),
+          0
+        );
+      } else if (u)
+        this.beginDragNativeItem(u);
+      else {
+        if (o && !o.types && (n.target && !n.target.hasAttribute || !n.target.hasAttribute("draggable")))
+          return;
+        n.preventDefault();
+      }
+    }, this.handleTopDragEndCapture = () => {
+      this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleTopDragEnterCapture = (n) => {
+      if (this.dragEnterTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(n.dataTransfer);
+      }
+      if (!this.enterLeaveCounter.enter(n.target) || this.monitor.isDragging())
+        return;
+      const { dataTransfer: o } = n, u = x(o);
+      u && this.beginDragNativeItem(u, o);
+    }, this.handleTopDragEnter = (n) => {
+      const { dragEnterTargetIds: s } = this;
+      if (this.dragEnterTargetIds = [], !this.monitor.isDragging())
+        return;
+      this.altKeyPressed = n.altKey, s.length > 0 && this.actions.hover(s, {
+        clientOffset: w(n)
+      }), s.some(
+        (o) => this.monitor.canDropOnTarget(o)
+      ) && (n.preventDefault(), n.dataTransfer && (n.dataTransfer.dropEffect = this.getCurrentDropEffect()));
+    }, this.handleTopDragOverCapture = (n) => {
+      if (this.dragOverTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(n.dataTransfer);
+      }
+    }, this.handleTopDragOver = (n) => {
+      const { dragOverTargetIds: s } = this;
+      if (this.dragOverTargetIds = [], !this.monitor.isDragging()) {
+        n.preventDefault(), n.dataTransfer && (n.dataTransfer.dropEffect = "none");
+        return;
+      }
+      this.altKeyPressed = n.altKey, this.lastClientOffset = w(n), this.scheduleHover(s), (s || []).some(
+        (o) => this.monitor.canDropOnTarget(o)
+      ) ? (n.preventDefault(), n.dataTransfer && (n.dataTransfer.dropEffect = this.getCurrentDropEffect())) : this.isDraggingNativeItem() ? n.preventDefault() : (n.preventDefault(), n.dataTransfer && (n.dataTransfer.dropEffect = "none"));
+    }, this.handleTopDragLeaveCapture = (n) => {
+      this.isDraggingNativeItem() && n.preventDefault(), this.enterLeaveCounter.leave(n.target) && (this.isDraggingNativeItem() && setTimeout(
+        () => this.endDragNativeItem(),
+        0
+      ), this.cancelHover());
+    }, this.handleTopDropCapture = (n) => {
+      if (this.dropTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        n.preventDefault(), (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(n.dataTransfer);
+      } else x(n.dataTransfer) && n.preventDefault();
+      this.enterLeaveCounter.reset();
+    }, this.handleTopDrop = (n) => {
+      const { dropTargetIds: s } = this;
+      this.dropTargetIds = [], this.actions.hover(s, {
+        clientOffset: w(n)
+      }), this.actions.drop({
+        dropEffect: this.getCurrentDropEffect()
+      }), this.isDraggingNativeItem() ? this.endDragNativeItem() : this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleSelectStart = (n) => {
+      const s = n.target;
+      typeof s.dragDrop == "function" && (s.tagName === "INPUT" || s.tagName === "SELECT" || s.tagName === "TEXTAREA" || s.isContentEditable || (n.preventDefault(), s.dragDrop()));
+    }, this.options = new ut(t, i), this.actions = e.getActions(), this.monitor = e.getMonitor(), this.registry = e.getRegistry(), this.enterLeaveCounter = new tt(this.isNodeInDocument);
+  }
+}
+const Tt = function(e, t, i) {
+  return new lt(e, t, i);
+};
+export {
+  vt as D,
+  Tt as H,
+  Dt as a,
+  pt as b,
+  T as i,
+  mt as u
+};