fluid-dnd 1.2.0-beta.0 → 1.2.1-beta.0

package/dist/index-BDu6-Hq8.js

@@ -0,0 +1,1283 @@
+var ve = Object.defineProperty;
+var De = (t, e, n) => e in t ? ve(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var k = (t, e, n) => De(t, typeof e != "symbol" ? e + "" : e, n);
+const Q = "draggable", It = "droppable", Ot = "handler-class", qt = "dragging", Yt = "dragging-handler-class", Wt = "dropping", se = "grabbing", be = "grab", Jt = "disable-transition", et = (t, e) => t.classList.contains(e), bt = (t, e, n = !1) => {
+  t.classList.toggle(e, n);
+}, nt = (t, e) => {
+  t.classList.add(e);
+}, Ct = (t, e) => {
+  t.classList.remove(e);
+}, Te = (t, e) => yt(e).every(
+  (n) => et(t, n)
+), gt = (t) => t ? `.${yt(t).join(".")}` : "", Ee = (t, e) => {
+  if (!e)
+    return;
+  const n = yt(e);
+  t.classList.add(...n);
+}, yt = (t) => t ? t.split(" ").filter((e) => e) : [], _ = "horizontal", U = "vertical", Ce = () => {
+  const { scrollX: t, scrollY: e } = window;
+  return { scrollX: t, scrollY: e };
+}, zt = (t) => !t || t.trim().length == 0 || t == "normal" ? 0 : parseFloat(t), ye = (t) => t ? parseInt(t) : -1, Ae = (t) => {
+  const e = getComputedStyle(t), n = new DOMMatrixReadOnly(e.transform);
+  return {
+    x: n.m41,
+    y: n.m42
+  };
+}, oe = (t, e) => t.x1 > e.x1 ? oe(e, t) : t.x2 < e.x1 ? 0 : t.x2 >= e.x2 ? t.x2 - t.x1 : t.x2 - e.x1, pt = (t, e) => !xe(t, e), xe = (t, e) => {
+  const n = Mt(t), s = Mt(e), o = Kt(n, s, U), r = Kt(n, s, _);
+  return o >= Math.min(n.height, s.height) / 2 && r >= Math.min(n.width, s.width) / 2;
+}, Kt = (t, e, n) => {
+  const { before: s, distance: o } = w(n);
+  return oe(
+    {
+      x1: t[s],
+      x2: t[s] + t[o]
+    },
+    {
+      x1: e[s],
+      x2: e[s] + e[o]
+    }
+  );
+}, O = (t, e) => t ? zt(getComputedStyle(t)[e]) : 0, Qt = (t) => {
+  const { scrollLeft: e, scrollTop: n } = t;
+  return { scrollLeft: e, scrollTop: n };
+}, Mt = (t) => t.getBoundingClientRect(), w = (t) => {
+  const e = t == _;
+  return {
+    beforeMargin: e ? "marginLeft" : "marginTop",
+    afterMargin: e ? "marginRight" : "marginBottom",
+    borderBeforeWidth: e ? "borderLeftWidth" : "borderTopWidth",
+    before: e ? "left" : "top",
+    after: e ? "right" : "down",
+    gap: e ? "columnGap" : "rowGap",
+    distance: e ? "width" : "height",
+    axis: e ? "x" : "y",
+    offset: e ? "offsetX" : "offsetY",
+    scroll: e ? "scrollX" : "scrollY",
+    scrollElement: e ? "scrollLeft" : "scrollTop",
+    page: e ? "pageX" : "pageY",
+    inner: e ? "innerWidth" : "innerHeight",
+    offsetElement: e ? "offsetLeft" : "offsetTop",
+    scrollDistance: e ? "scrollWidth" : "scrollHeight",
+    clientDistance: e ? "clientWidth" : "clientHeight",
+    paddingBefore: e ? "paddingLeft" : "paddingTop",
+    getRect: Mt
+  };
+}, Rt = (t, e) => we(t, e), re = (t) => [...t.children].filter(
+  (n) => et(n, Q)
+), we = (t, e) => {
+  const n = [...e.children].filter(
+    (o) => et(o, Q) && !o.isEqualNode(t)
+  ).toReversed(), s = [...e.children].findLastIndex(
+    (o) => o.isEqualNode(t)
+  );
+  return [
+    n,
+    s,
+    e
+  ];
+}, Be = (t) => {
+  let e = t.parentElement;
+  for (; e; ) {
+    if (window.getComputedStyle(e).position === "fixed")
+      return e;
+    e = e.parentElement;
+  }
+  return null;
+}, ie = (t, e) => {
+  const {
+    before: n,
+    borderBeforeWidth: s
+  } = w(e), o = Be(t);
+  return o ? Mt(o)[n] + O(o, s) : 0;
+}, Xt = (t) => window.TouchEvent && t instanceof TouchEvent, it = (t) => t instanceof HTMLElement, ce = (t) => t instanceof MouseEvent, Re = ["onmouseup", "onmousedown", "onmousemove"], Le = (t, e, n) => {
+  t && (t.style.height = `${e}px`, t.style.width = `${n}px`);
+}, Tt = (t, e, n) => {
+  !t || !it(t) || (n == 0 && e == 0 ? t.style.transform = "" : t.style.transform = `translate(${n}px,${e}px)`);
+}, Oe = (t, e, n) => {
+  t[e] = (s) => {
+    if (s.defaultPrevented)
+      return;
+    const o = Vt(s);
+    n(o);
+  };
+}, $t = (t, e, n) => {
+  n && (Me(e) ? t[e] = n : Oe(t, e, n));
+}, Me = (t) => Re.includes(t), Ne = (t) => {
+  const { target: e } = t;
+  return {
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    screenX: 0,
+    screenY: 0,
+    target: e,
+    offsetX: 0,
+    offsetY: 0
+  };
+}, Fe = (t, e) => {
+  const n = (s, o) => $e(e, window, o, s);
+  if (ce(t)) {
+    const { offsetX: s, offsetY: o } = t;
+    return [s, o];
+  } else {
+    const s = t.target;
+    return [
+      n(s, _),
+      n(s, U)
+    ];
+  }
+}, Vt = (t) => {
+  const e = Pe(t);
+  if (!e)
+    return Ne(t);
+  const [n, s] = Fe(t, e), { clientX: o, clientY: r, pageX: a, pageY: l, screenX: u, screenY: d, target: m } = e;
+  return {
+    clientX: o,
+    clientY: r,
+    pageX: a,
+    pageY: l,
+    screenX: u,
+    screenY: d,
+    target: m,
+    offsetX: n,
+    offsetY: s
+  };
+}, Pe = (t) => {
+  if (Xt(t))
+    return t.touches[0] ?? t.changedTouches[0];
+  if (ce(t))
+    return t;
+}, $e = (t, e, n, s) => {
+  const { page: o, scroll: r, before: a, borderBeforeWidth: l, getRect: u } = w(n), d = u(s);
+  return t[o] - e[r] - d[a] - O(s, l);
+}, Ft = (t, e, n = "ease-out", s = "transform") => {
+  it(t) && (t.style.transitionDuration = `${e}ms`, t.style.transitionTimingFunction = `${n}`, t.style.transitionProperty = `${s}`);
+}, ae = (t, e, n) => {
+  !t || !it(t) || (t[e] = () => {
+    n();
+  });
+}, Ge = (t) => {
+  var e = t.querySelector("style");
+  if (!e) {
+    var n = document.createElement("style");
+    return t.appendChild(n), n;
+  }
+  return e;
+}, Ie = (t, e) => {
+  const n = /\.-?[_a-zA-Z0-9-*\s<>():]+/g, [s] = e.match(n) || [];
+  for (const o of t.cssRules) {
+    const [r] = o.cssText.match(n) || [];
+    if (s === r)
+      return !0;
+  }
+  return !1;
+}, Ye = (t, e) => {
+  e.forEach((n) => {
+    We(t, n);
+  });
+}, We = (t, e) => {
+  var s;
+  var n = Ge(t);
+  n.sheet && (Ie(n.sheet, e) || (s = n.sheet) == null || s.insertRule(e, n.sheet.cssRules.length));
+}, le = (t, e = {}) => {
+  for (const n of Object.keys(e)) {
+    const s = e[n];
+    s != null && Xe(t, `--${n}`, s);
+  }
+}, Xe = (t, e, n) => t && t.style.setProperty(e, n), ue = "startDrag", Nt = "drag", jt = "startDrop", Ve = "drop", at = "temp-child", fe = "cubic-bezier(0.2, 0, 0, 1)", _e = (t) => t === Ve || t === jt, _t = (t) => !t || t.length == 0 ? 0 : zt(t.replace("px", "")), He = (t, e) => {
+  const n = getComputedStyle(t)[e];
+  if (n.match("%")) {
+    const o = zt(n.replace("%", "")), { width: r } = t.getBoundingClientRect();
+    return r * (o / 100);
+  }
+  return _t(n);
+}, kt = (t, e) => {
+  if (!(t instanceof Element))
+    return [
+      0,
+      !1
+    ];
+  const n = He(t, e), s = getComputedStyle(t).display, o = n > 0 || s === "flex";
+  return [n, o];
+}, qe = (t) => {
+  const { top: e, left: n } = getComputedStyle(t);
+  return [_t(e), _t(n)];
+}, ze = (t, e) => {
+  const { gap: n } = w(e), [s, o] = kt(t, n);
+  return o ? s : 0;
+};
+function Et(t, e, n, s, o = t.previousElementSibling, r = t.nextElementSibling) {
+  let { height: a, width: l } = je(
+    n,
+    t,
+    o,
+    r
+  );
+  return pt(t, s) && e == Nt && (a = 0, l = 0), { height: a, width: l };
+}
+const je = (t, e, n, s) => {
+  const {
+    afterMargin: o,
+    beforeMargin: r,
+    distance: a,
+    gap: l,
+    getRect: u
+  } = w(t), d = O(e, o), m = O(e, r), v = O(s, r), [B, M] = kt(
+    e.parentElement,
+    l
+  ), F = u(e)[a];
+  if (M)
+    return Ut(F, m, d, B, 0, t);
+  const [C, p, D] = ke(
+    n,
+    v,
+    d,
+    m,
+    o
+  );
+  return Ut(F, p, C, 0, D, t);
+}, ke = (t, e, n, s, o) => {
+  const r = Math.max(e, n);
+  let a = s, l = e;
+  if (t) {
+    const u = O(
+      t,
+      o
+    );
+    a = Math.max(u, s), l = Math.max(l, u);
+  }
+  return [r, a, l];
+}, Ut = (t, e, n, s, o, r) => Ze(r, t + e + n + s - o), Ze = (t, e) => t == _ ? { width: e, height: 0 } : { width: 0, height: e }, te = (t, e) => {
+  const {
+    borderBeforeWidth: n,
+    paddingBefore: s,
+    axis: o,
+    getRect: r
+  } = w(t), a = O(e, n), l = O(e, s), u = r(e)[o];
+  return a + l + u;
+}, Je = (t, e) => {
+  const [n, s] = qe(e), o = te(U, t);
+  return [
+    te(_, t) - s,
+    o - n
+  ];
+};
+function Ke(t, e, n, s, o, r, a, l, u) {
+  let d = 0, m = 0;
+  const v = !!(n < 0 && u);
+  if (n === s && !v)
+    return ee(
+      { height: d, width: m },
+      t,
+      o,
+      a,
+      v
+    );
+  const [B, M, F, C] = tn(e, n, s, u);
+  if (v) {
+    const [tt, ot] = Je(l, u);
+    d += ot, m += tt;
+  }
+  const {
+    scrollElement: p,
+    beforeMargin: D,
+    afterMargin: R,
+    distance: L,
+    gap: Y
+  } = w(t), [W, $] = kt(l, Y), [
+    st,
+    H,
+    P
+  ] = nn(
+    D,
+    R,
+    B,
+    M == null ? void 0 : M.previousElementSibling,
+    C,
+    $,
+    v
+  ), [Z, q, z] = en(
+    D,
+    R,
+    L,
+    F,
+    W,
+    $
+  ), X = Ue(
+    q,
+    Z,
+    z,
+    H,
+    st,
+    W
+  ), j = v ? l[p] : Qe(p, l, r), G = (C ? X - P : P - X) - j;
+  return t === U ? d += G : t === _ && (m += G), ee(
+    { height: d, width: m },
+    t,
+    o,
+    a,
+    v
+  );
+}
+const Qe = (t, e, n) => {
+  const s = e[t], o = n[t];
+  return s - o;
+}, Ue = (t, e, n, s, o, r) => {
+  const a = Math.max(e, o);
+  return Math.max(n, s) + t + a + r;
+}, tn = (t, e, n, s) => {
+  const o = e < n, [r, a] = [e, n].toSorted(
+    (m, v) => m - v
+  ), l = t[e] ?? s, u = t[n];
+  let d = o ? t.slice(r + 1, a + 1) : t.slice(r, a);
+  return r < 0 && s && (d = t.slice(r + 1, a)), [
+    l,
+    u,
+    d,
+    o
+  ];
+}, en = (t, e, n, s, o, r) => {
+  if (s.length == 0)
+    return [0, 0, 0];
+  const a = O(s[0], t);
+  let l = 0, u = -a;
+  for (const [d, m] of s.entries()) {
+    const v = m.getBoundingClientRect()[n], B = O(m, t);
+    r && (l += B), r && d > 0 ? l += o : l = Math.max(l, B), u += l + v, l = O(m, e);
+  }
+  return [a, u, l];
+}, ee = (t, e, n, s, o) => {
+  const { scroll: r, distance: a } = w(e), l = window[r], u = n[r], d = o ? 0 : u - 2 * l + s[r];
+  return t[a] += d, t;
+}, nn = (t, e, n, s, o, r, a) => {
+  const l = o ? n.previousElementSibling : s;
+  return sn(
+    t,
+    e,
+    l,
+    n,
+    r,
+    a
+  );
+}, sn = (t, e, n, s, o, r) => {
+  if (o)
+    return [0, 0, 0];
+  const a = O(
+    r ? null : n,
+    e
+  ), l = O(s, t);
+  let u = Math.max(a, l);
+  return [a, l, u];
+}, Zt = (t, e, n, s = () => !0) => {
+  const o = new MutationObserver((r) => {
+    if (r = r.filter(s), r.length > 0) {
+      const a = r[0];
+      t(o, a);
+    }
+  });
+  return o.observe(e, n), o;
+}, on = (t, e, n) => {
+  n != 0 && (e === "vertical" ? t.scrollBy(0, n) : t.scrollBy(n, 0));
+}, rn = (t, e, n) => {
+  const { scrollDistance: s, clientDistance: o, scrollElement: r } = w(t);
+  return n[r] / (e[s] - e[o]);
+}, cn = "startDrag", de = "cubic-bezier(0.2, 0, 0, 1)", ge = 50, Ht = (t) => it(t) ? t.classList.contains(at) : !1, an = (t, e, n) => {
+  let s = Et(
+    e,
+    cn,
+    n,
+    t
+  );
+  const o = ze(t, n), { distance: r } = w(n);
+  s[r] -= o;
+  const [a, l] = ln(n, e);
+  return s[l] = a, s;
+}, ln = (t, e) => {
+  const n = t == _ ? U : _, { distance: s, getRect: o } = w(n);
+  return [
+    o(e)[s],
+    s
+  ];
+}, ht = (t, e, n) => {
+  Le(t, e, n), t.style.minWidth = `${n}px`;
+}, un = (t, e, n) => (s) => {
+  e.contains(t) && (ht(t, n.height, n.width), s.disconnect());
+}, fn = (t, e) => {
+  if (!e)
+    return;
+  const { droppable: n, config: s, scroll: o } = t, { direction: r } = s, a = rn(s.direction, n, o) > 0.99, { scrollDistance: l, clientDistance: u, scrollElement: d } = w(r);
+  a && (n[d] = n[l] - n[u]);
+}, pe = (t, e, n, s) => {
+  if (!n)
+    return;
+  const { droppable: o, config: r } = n, { direction: a, animationDuration: l } = r;
+  if (fn(n, e), o.querySelector(`.${at}`) || !t)
+    return;
+  var u = t.tagName == "LI" ? "DIV" : t.tagName, d = document.createElement(u);
+  nt(d, at), ht(d, 0, 0);
+  const m = an(o, t, a);
+  return Ft(
+    d,
+    l,
+    de,
+    "width, min-width, height"
+  ), [d, m, o];
+}, Gt = (t, e, n, s, o) => {
+  const r = pe(t, n, s);
+  if (!r)
+    return;
+  const [a, l, u] = r;
+  e.isSameNode(u) && ht(a, l.height, l.width), Zt(
+    un(a, u, l),
+    u,
+    {
+      childList: !0,
+      subtree: !0
+    }
+  ), u.appendChild(a);
+}, dn = (t, e, n) => {
+  const s = pe(t, e, n);
+  if (!s)
+    return;
+  const [o, r, a] = s;
+  a.appendChild(o), gn(o, r);
+}, gn = (t, e) => requestAnimationFrame(() => {
+  ht(t, e.height, e.width), requestAnimationFrame(() => {
+    Ft(
+      t,
+      0,
+      de,
+      "width, min-width, height"
+    );
+  });
+}), pn = (t, e, n, s, o = !0) => {
+  if (n) {
+    var r = document.querySelectorAll(
+      `${gt(n)} > .${at}`
+    );
+    r.forEach((a) => {
+      const l = a.parentElement;
+      if (l != null && l.isSameNode(e) || !o && (l != null && l.isSameNode(t)))
+        return;
+      ht(a, 0, 0), setTimeout(() => {
+        var d;
+        (d = a.parentNode) == null || d.removeChild(a);
+      }, s + ge);
+    });
+  }
+}, Dt = (t, e, n = !1) => {
+  var s = t.querySelectorAll(`.${at}`);
+  s.forEach((o) => {
+    const r = o;
+    n ? (ht(r, 0, 0), setTimeout(() => {
+      t.contains(r) && t.removeChild(r);
+    }, e + ge)) : t.removeChild(o);
+  });
+}, hn = 50;
+function mn(t, e, n, s, o, r) {
+  let a = e;
+  const {
+    direction: l,
+    handlerSelector: u,
+    onRemoveAtEvent: d,
+    animationDuration: m,
+    delayBeforeInsert: v,
+    draggingClass: B
+  } = t, M = (i, f, h, S, y) => {
+    if (!S)
+      return;
+    const { droppable: b, config: T } = S, A = Et(
+      i,
+      f,
+      T.direction,
+      b
+    );
+    _e(f) ? $(
+      i,
+      f,
+      A,
+      h,
+      S,
+      y
+    ) : D(
+      i,
+      f,
+      A,
+      S
+    );
+  }, F = (i, f, h, S, y) => {
+    const b = Et(
+      f,
+      "insert",
+      t.direction,
+      h
+    ), { onInsertEvent: T } = t, A = re(h);
+    for (const [N, x] of A.entries())
+      et(x, Q) && N >= i && W(x, b);
+    y(), setTimeout(() => {
+      T(i, S), he(i, h, t), tt(f), V(f, n), Dt(n, 0, !0);
+    }, v);
+  }, C = (i, f, h, S) => {
+    if (!h || !h.droppable || !h.config)
+      return;
+    const { droppable: y, config: b } = h;
+    let [T] = Rt(f, y);
+    T = [f, ...T].toReversed();
+    const A = Et(
+      f,
+      "remove",
+      b.direction,
+      y
+    );
+    for (const [N, x] of T.entries())
+      N >= i && (Y(x, A), setTimeout(() => {
+        S(x);
+      }, m));
+  }, p = (i) => {
+    Dt(n, m, !0), setTimeout(() => {
+      tt(i), V(i, n);
+    }, m);
+  }, D = (i, f, h, S) => {
+    const { config: y, droppable: b } = S, [T] = Rt(i, b), A = pt(i, b);
+    T.length == 0 && L(
+      h,
+      1,
+      y.direction,
+      T
+    );
+    for (const [N, x] of T.entries()) {
+      if (!et(x, Q))
+        continue;
+      const I = R(
+        y.direction,
+        i,
+        x,
+        h
+      );
+      if (!A && I)
+        h = I;
+      else if (!A)
+        continue;
+      const J = T.length - N;
+      L(
+        h,
+        J,
+        y.direction,
+        T
+      ), f === ue ? Y(x, h) : f === Nt && W(x, h);
+    }
+  }, R = (i, f, h, S) => {
+    const { before: y, distance: b, axis: T, getRect: A } = w(i), N = A(f), x = A(h), I = N[y], J = x[y], ft = x[b], mt = J + ft / 2, St = Ae(h)[T], ct = mt - St;
+    return I > ct ? { height: 0, width: 0 } : S;
+  }, L = (i, f, h, S) => {
+    const y = S.filter(
+      (T) => et(T, Q)
+    ).length, { distance: b } = w(h);
+    i[b] == 0 ? a = Math.max(a, f) : a = Math.min(a, f - 1), a = Math.min(a, y);
+  }, Y = (i, f) => {
+    const { width: h, height: S } = f;
+    Tt(i, S, h);
+  }, W = (i, f) => {
+    const { width: h, height: S } = f;
+    Tt(i, S, h), Ft(i, m, fe);
+  }, $ = (i, f, h, S, y, b) => {
+    const { droppable: T, scroll: A, config: N } = y, [x, I] = Rt(
+      i,
+      T
+    ), J = x.toReversed(), ft = I === -1 ? J.length : I;
+    J.splice(ft, 0, i);
+    const [mt, St, ct] = st(
+      i,
+      I,
+      J,
+      T
+    );
+    h = Et(
+      i,
+      f,
+      N.direction,
+      n,
+      mt,
+      St
+    );
+    const Pt = Ce(), At = Ke(
+      N.direction,
+      J,
+      I,
+      ct,
+      Pt,
+      A,
+      S,
+      T,
+      i
+    );
+    x.length == 0 && H(
+      void 0,
+      h,
+      i,
+      At
+    );
+    for (const [xt, wt] of x.toReversed().entries()) {
+      let Bt = h;
+      ct - 1 >= xt && (Bt = { height: 0, width: 0 }), f === jt && !et(wt, at) && H(
+        wt,
+        Bt,
+        i,
+        At
+      );
+    }
+    P(
+      ct,
+      i,
+      N,
+      T,
+      b
+    );
+  }, st = (i, f, h, S) => {
+    const b = pt(i, S) ? f : a, T = () => f < b ? [b, b + 1] : f > b ? [b - 1, b] : [b - 1, b + 1], [A, N] = T(), x = h[A] ?? null, I = h[N] ?? null;
+    return [
+      x,
+      I,
+      b
+    ];
+  }, H = (i, f, h, S) => {
+    Tt(i, f.height, f.width), Tt(
+      h,
+      S.height,
+      S.width
+    );
+  }, P = (i, f, h, S, y) => {
+    const { onInsertEvent: b, onDragEnd: T } = h;
+    nt(f, Wt), z(f, n, S, () => {
+      if (Ct(f, Wt), y != null) {
+        const A = d(y, !0);
+        A != null && (b(i, A, !0), T({ value: A, index: i })), q(f), Z();
+      }
+    });
+  }, Z = () => {
+    if (s) {
+      var i = document.querySelectorAll(
+        `${gt(s)} > .${Q}`
+      );
+      for (const f of i)
+        G(f);
+    }
+  }, q = (i) => {
+    setTimeout(() => {
+      Ct(i, B);
+    }, hn);
+  }, z = (i, f, h, S) => {
+    setTimeout(() => {
+      S && S(), X(f, h), j(h), tt(i), V(i, f), V(i, h);
+    }, m);
+  }, X = (i, f) => {
+    i.isSameNode(f) ? Dt(i, m) : (Dt(i, m, !0), Dt(f, m));
+  }, j = (i) => {
+    if (n.isSameNode(i))
+      return;
+    var [f] = n.querySelectorAll(`.${at}`);
+    if (!f)
+      return;
+    const { distance: h } = w(l);
+    it(f) && (f.style[h] = "0px");
+  }, V = (i, f) => {
+    const [h] = Rt(i, f);
+    for (const S of [...h, i])
+      G(S);
+  }, G = (i) => {
+    it(i) && (i.style.transition = "", i.style.transform = "");
+  }, tt = (i) => {
+    r(), ut(i, !1), i.style.transform = "", i.style.transition = "", i.style.top = "", i.style.left = "", le(i, {
+      fixedHeight: "",
+      fixedWidth: ""
+    });
+  }, ot = (i, f) => {
+    const h = f.querySelector(u);
+    bt(document.body, se, i), bt(h || f, Yt, i);
+  }, ut = (i, f) => {
+    bt(i, qt, f), ot(f, i), o.toggleGrabClass(!f);
+  };
+  return [
+    M,
+    C,
+    F,
+    p,
+    ut
+  ];
+}
+const Sn = (t) => t.addedNodes.values().filter((n) => !Ht(n)).toArray().length > 0, he = (t, e, n) => {
+  const { insertingFromClass: s, animationDuration: o } = n, r = Zt(() => {
+    const l = re(e)[t];
+    nt(l, s), nt(l, Jt), setTimeout(() => {
+      Ct(l, Jt), Ct(l, s), r.disconnect();
+    }, o);
+  }, e, {
+    childList: !0
+  }, Sn);
+}, Ln = (t, e, n, s) => {
+  if (!e)
+    return;
+  const { onInsertEvent: o, delayBeforeInsert: r } = t;
+  setTimeout(() => {
+    o(n, s), he(n, e, t);
+  }, r);
+}, vn = (t, e) => {
+  const n = (l, u) => t.removeAtEvent(l, u), s = (l, u, d) => t.insertEvent(l, u, d), o = () => t.getLength(), r = (l) => t.getValue(l), a = (l) => l;
+  return {
+    direction: (e == null ? void 0 : e.direction) ?? U,
+    handlerSelector: (e == null ? void 0 : e.handlerSelector) ?? Q,
+    draggingClass: (e == null ? void 0 : e.draggingClass) ?? "dragging",
+    droppableClass: (e == null ? void 0 : e.droppableClass) ?? "droppable-hover",
+    isDraggable: (e == null ? void 0 : e.isDraggable) ?? (() => !0),
+    onDragStart: (e == null ? void 0 : e.onDragStart) ?? (() => {
+    }),
+    onDragEnd: (e == null ? void 0 : e.onDragEnd) ?? (() => {
+    }),
+    droppableGroup: e == null ? void 0 : e.droppableGroup,
+    onRemoveAtEvent: n,
+    onInsertEvent: s,
+    onGetLegth: o,
+    onGetValue: r,
+    animationDuration: (e == null ? void 0 : e.animationDuration) ?? 200,
+    removingClass: (e == null ? void 0 : e.removingClass) ?? "removing",
+    insertingFromClass: (e == null ? void 0 : e.insertingFromClass) ?? "from-inserting",
+    delayBeforeRemove: (e == null ? void 0 : e.delayBeforeRemove) ?? 200,
+    delayBeforeInsert: (e == null ? void 0 : e.delayBeforeInsert) ?? 200,
+    mapFrom: (e == null ? void 0 : e.mapFrom) ?? a
+  };
+}, Dn = (t, e) => {
+  const { config: n, droppable: s } = t, { onInsertEvent: o, onDragEnd: r } = n;
+  return {
+    ...n,
+    onDragEnd: (u) => {
+      const { index: d, value: m } = u;
+      r({ index: d, value: e(m, s) });
+    },
+    onInsertEvent: (u, d) => o(u, e(d, s), !0)
+  };
+}, bn = (t) => {
+  let e = { offsetX: 0, offsetY: 0 }, n = { top: 0, left: 0 }, s = { x: 0, y: 0 };
+  const o = (u) => {
+    t.style.transform = `translate( ${u.x}px, ${u.y}px)`;
+  }, r = (u) => {
+    t.style.top = `${u.top}px`, t.style.left = `${u.left}px`;
+  };
+  return [
+    (u, d, m, v) => {
+      const B = (C) => {
+        const {
+          beforeMargin: p,
+          borderBeforeWidth: D,
+          before: R,
+          offset: L,
+          scroll: Y,
+          page: W,
+          inner: $,
+          distance: st,
+          axis: H,
+          getRect: P
+        } = w(C), Z = m[W], q = window[Y], z = window[$], X = P(u)[st], j = O(u, D), V = O(u, p), G = Z - e[L], tt = ie(u, C);
+        if (G >= q - X / 2 && G <= q + z) {
+          const ut = G - n[R] - j - V - q - tt;
+          return M(C), ut;
+        }
+        return s[H];
+      }, M = (C) => {
+        if (u && et(u, qt) && C === v) {
+          const { before: p, distance: D, axis: R, getRect: L } = w(v), Y = L(u)[D], W = L(d), $ = n[p] - W[p] + s[R], H = W[D] - Y, P = $ / H, Z = Y / H, q = 0.1, z = 0.2, X = 0.8;
+          let j = 0;
+          const V = pt(u, d);
+          !V && P < z && P > -Z ? j = P / z - 1 : !V && P > X && P < 1 + Z && (j = 1 / (1 - X) * (P - X));
+          const G = q * Y * j;
+          on(d, v, G);
+        }
+      }, F = (C) => {
+        const { axis: p } = w(C);
+        s[p] = B(C), o(s);
+      };
+      F(_), F(U);
+    },
+    (u, d) => {
+      const [m, v, B, M] = Cn(
+        u,
+        d,
+        t
+      );
+      n = {
+        top: m,
+        left: v
+      }, r(n), e = { offsetX: B, offsetY: M };
+    }
+  ];
+}, Lt = (t, e, n) => {
+  const { borderBeforeWidth: s, before: o, getRect: r } = w(t);
+  return r(e)[o] - r(n)[o] - O(n, s);
+}, Tn = (t, e) => {
+  let { offsetX: n, offsetY: s, target: o } = t, r = En(o, e);
+  const a = o;
+  return a && r && !a.isSameNode(r) && (n += Lt(_, a, r), s += Lt(U, a, r)), r && e != o && (n += Lt(_, r, e), s += Lt(U, r, e)), [n, s];
+}, En = (t, e) => {
+  const n = t == null ? void 0 : t.closest(`.${Ot}`);
+  return n && n.isSameNode(e) ? t : n;
+}, ne = (t, e, n, s) => {
+  const { offset: o, beforeMargin: r, page: a, borderBeforeWidth: l, scroll: u } = w(t), d = ie(n, t);
+  return e[a] - s[o] - O(n, r) - O(n, l) - window[u] - d;
+}, Cn = (t, e, n) => {
+  const [s, o] = Tn(t, n);
+  return [
+    ne(U, t, e, {
+      offsetX: s,
+      offsetY: o
+    }),
+    ne(_, t, e, {
+      offsetX: s,
+      offsetY: o
+    }),
+    s,
+    o
+  ];
+}, K = class K {
+  static addConfig(e, n) {
+    const s = K.configs.filter(
+      (r) => !r.droppable.isSameNode(e)
+    ), o = Qt(e);
+    s.push({
+      droppable: e,
+      config: n,
+      scroll: o
+    }), K.configs = s;
+  }
+  static updateScrolls(e, n) {
+    for (const s of K.configs) {
+      const { droppable: o } = s;
+      (n && Te(o, n) || o.isSameNode(e)) && (s.scroll = Qt(o));
+    }
+  }
+  static getConfig(e) {
+    return K.configs.find(
+      ({ droppable: s }) => s.isSameNode(e)
+    );
+  }
+};
+k(K, "configs", []), k(K, "removeObsoleteConfigs", () => {
+  const e = K.configs.filter(
+    ({ droppable: n }) => document.contains(n)
+  );
+  K.configs = e;
+});
+let lt = K;
+class yn {
+  constructor(e, n, s, o, r, a) {
+    k(this, "initial");
+    k(this, "current");
+    k(this, "parent");
+    k(this, "draggableElement");
+    k(this, "groupClass");
+    k(this, "dragEvent");
+    k(this, "changeDroppable");
+    k(this, "mapFrom");
+    this.parent = s, this.draggableElement = e, this.groupClass = n, this.dragEvent = o, this.mapFrom = a, this.initial = s ? lt.getConfig(s) : void 0, this.changeDroppable = r;
+  }
+  getDraggableAncestor(e, n, s) {
+    return document.elementsFromPoint(e, n).filter((o) => !o.isSameNode(s));
+  }
+  getElementBelow(e, n, s = !0) {
+    const o = (a) => {
+      const [l] = a.getDraggableAncestor(
+        n.clientX,
+        n.clientY,
+        e
+      );
+      return l;
+    };
+    let r = null;
+    return s ? (e.hidden = !0, r = o(this), e.hidden = !1) : r = o(this), r;
+  }
+  getCurrent(e, n, s = !0) {
+    const o = this.getElementBelow(e, n, s);
+    return !this.groupClass || !o ? void 0 : o.closest(
+      gt(this.groupClass)
+    );
+  }
+  isOutsideOfAllDroppables(e) {
+    return (this.groupClass ? Array.from(
+      document.querySelectorAll(gt(this.groupClass))
+    ) : [this.parent]).every(
+      (s) => pt(e, s)
+    );
+  }
+  isNotInsideAnotherDroppable(e, n) {
+    return !pt(e, n) || this.isOutsideOfAllDroppables(e);
+  }
+  onScrollEvent() {
+    this.dragEvent();
+  }
+  setOnScroll(e) {
+    ae(e, "onscroll", () => {
+      this.onScrollEvent();
+    });
+  }
+  getConfigFrom(e) {
+    const n = lt.getConfig(e);
+    if (n)
+      return e.isSameNode(this.parent) ? n : {
+        ...n,
+        config: Dn(n, this.mapFrom)
+      };
+  }
+  getCurrentConfig(e) {
+    var o;
+    const n = this.draggableElement;
+    if (this.current && this.isNotInsideAnotherDroppable(
+      n,
+      (o = this.current) == null ? void 0 : o.droppable
+    ))
+      return this.current;
+    const s = this.getCurrent(n, e);
+    return s ? (it(s) && !s.onscroll && this.setOnScroll(s), this.getConfigFrom(s)) : this.getConfigFrom(this.parent);
+  }
+  updateConfig(e) {
+    const n = this.current;
+    this.current = this.getCurrentConfig(e), this.changeDroppable(this.current, n);
+  }
+  isOutside(e, n = !0) {
+    const s = this.draggableElement;
+    return !this.getCurrent(s, e, n);
+  }
+}
+function An(t, e, n, s, o) {
+  const {
+    handlerSelector: r,
+    isDraggable: a,
+    droppableGroup: l,
+    animationDuration: u,
+    delayBeforeRemove: d,
+    draggingClass: m,
+    removingClass: v,
+    onRemoveAtEvent: B,
+    droppableClass: M,
+    onDragStart: F
+  } = n, C = yt(l).map((c) => `droppable-group-${c}`).join(" ");
+  let p = 0, D = {
+    scrollX: 0,
+    scrollY: 0
+  }, R = { pageX: 0, pageY: 0 }, L;
+  const [Y, W] = bn(
+    t
+  ), [
+    $,
+    st,
+    H,
+    P,
+    Z
+  ] = mn(
+    n,
+    e,
+    s,
+    C,
+    o,
+    () => p = 0
+    /* NOT_DRAGGING */
+  ), q = () => {
+    nt(t, Q);
+  }, z = (c) => {
+    nt(c, Ot), o.addSubscriber(c);
+  }, X = () => {
+    if (a(t)) {
+      const c = t.querySelector(r);
+      z(c || t);
+    }
+  }, j = () => {
+    X(), q();
+  }, V = (c) => {
+    const g = c == null ? void 0 : c.querySelector(`.${Ot}`), E = g == null ? void 0 : g.parentElement;
+    return g && E && et(E, It) && !E.isSameNode(s) ? null : g;
+  }, G = (c) => {
+    const g = V(c) ?? c;
+    g && a(c) && ($t(
+      g,
+      "onmousedown",
+      N("mousemove", "mouseup")
+    ), $t(
+      g,
+      "ontouchstart",
+      N("touchmove", "touchend")
+    ), tt(g)), c != null && c.isSameNode(g) || $t(c, "onmousedown", x), nt(s, It);
+  }, tt = (c) => {
+    const g = c.querySelectorAll("img");
+    Array.from(g).forEach((E) => {
+      E.onmousedown = () => !1;
+    });
+  }, ot = () => {
+    if (R.pageX == 0 && R.pageY == 0 || !i.current)
+      return;
+    const { droppable: c, config: g } = i.current;
+    Y(t, c, R, g.direction), $(
+      t,
+      Nt,
+      D,
+      i.current
+    );
+  }, ut = (c, g) => {
+    g && p == 2 && !(c != null && c.droppable.isSameNode(g.droppable)) && $(
+      t,
+      Nt,
+      D,
+      g
+    );
+  }, i = new yn(
+    t,
+    C,
+    s,
+    ot,
+    ut,
+    n.mapFrom
+  ), f = (c) => {
+    if (!i.current)
+      return;
+    const g = C ? Array.from(
+      document.querySelectorAll(gt(C))
+    ) : [s];
+    for (const E of g)
+      E.classList.toggle(
+        M,
+        !c && E.isSameNode(i.current.droppable)
+      );
+  }, h = (c) => {
+    i.updateConfig(c);
+    const g = i.isOutside(c);
+    f(g), p === 1 ? ft(c) : p === 2 && (S(g), St(c));
+  }, S = (c = !0) => {
+    if (!i.current)
+      return;
+    const { droppable: g } = i.current;
+    pn(
+      g,
+      s,
+      C,
+      u,
+      c
+    ), !c && Gt(
+      t,
+      s,
+      p == 1,
+      i.current
+    );
+  }, y = (c) => {
+    if (Xt(c) && c.cancelable)
+      c.preventDefault();
+    else if (Xt(c))
+      return;
+    const g = Vt(c);
+    h(g);
+  }, b = (c, g) => {
+    c == "touchmove" ? L = setTimeout(() => {
+      g();
+    }, 200) : g();
+  }, T = (c, g) => {
+    const { clientX: E, clientY: dt } = c, rt = document.elementFromPoint(E, dt), vt = rt == null ? void 0 : rt.closest(`.${Q}`);
+    return rt && g && vt && !g.isSameNode(vt);
+  }, A = (c) => {
+    const g = n.onGetValue(e);
+    return { index: e, element: c, value: g };
+  }, N = (c, g) => (E) => {
+    if (T(E, t))
+      return;
+    lt.updateScrolls(s, C);
+    const { scrollX: dt, scrollY: rt } = window;
+    if (D = { scrollX: dt, scrollY: rt }, p === 0) {
+      p = 1;
+      const vt = A(t);
+      vt && F(vt), b(c, () => {
+        c == "touchmove" && (i.updateConfig(E), f(i.isOutside(E)), ft(E)), document.addEventListener(c, y, {
+          passive: !1
+        });
+      }), ct(s), document.addEventListener(g, I(c), {
+        once: !0
+      });
+    }
+  }, x = (c) => i.updateConfig(c), I = (c) => (g) => {
+    f(!0);
+    const E = Vt(g);
+    clearTimeout(L), At(i.isOutside(E, !1)), document.removeEventListener(c, y), i.updateConfig(E);
+    const dt = i.getCurrentConfig(E);
+    if (dt) {
+      const { droppable: rt } = dt;
+      J(rt);
+    }
+    s.onscroll = null;
+  }, J = (c) => {
+    if (c.onscroll = null, !C)
+      return;
+    const g = Array.from(
+      document.querySelectorAll(gt(C))
+    );
+    for (const E of g)
+      it(E) && (E.onscroll = null);
+  }, ft = (c) => {
+    Gt(
+      t,
+      s,
+      p == 1,
+      i.current
+    ), mt(), $(
+      t,
+      ue,
+      D,
+      i.current
+    ), wt(t), W(c, t);
+  }, mt = () => {
+    p = 2;
+  }, St = (c) => {
+    const { pageX: g, pageY: E } = c;
+    R = { pageX: g, pageY: E }, ot();
+  }, ct = (c) => ae(c, "onscroll", Pt), Pt = () => ot(), At = (c) => {
+    if (p !== 2) {
+      p = 0;
+      return;
+    }
+    p = 3, xt(t), $(
+      t,
+      jt,
+      D,
+      c ? i.initial : i.current,
+      e
+    );
+  }, xt = (c) => {
+    Ft(c, u, fe), Tt(c, 0, 0);
+  }, wt = (c) => {
+    const { height: g, width: E } = c.getBoundingClientRect();
+    le(c, {
+      fixedHeight: `${g}px`,
+      fixedWidth: `${E}px`
+    }), Z(c, !0), bt(c, m, !0), c.style.transition = "";
+  }, Bt = (c, g) => {
+    Ct(t, v), Gt(
+      t,
+      s,
+      p == 1,
+      i.initial
+    ), st(
+      c,
+      t,
+      g,
+      (E) => {
+        xt(E), P(t);
+      }
+    ), B(e, !0);
+  }, me = (c) => {
+    if (!i.initial)
+      return;
+    const g = i.initial;
+    c == e && (nt(t, v), setTimeout(() => {
+      Bt(c, g);
+    }, d));
+  }, Se = (c, g) => {
+    (c === e || c === n.onGetLegth() && e === c - 1) && H(
+      c,
+      t,
+      s,
+      g,
+      () => {
+        dn(
+          t,
+          p == 1,
+          i.initial
+        );
+      }
+    );
+  };
+  return j(), G(t), [me, Se];
+}
+const xn = (t, e) => {
+  t && Ee(e, t);
+}, wn = () => {
+  Ye(document.body, [
+    `.${Q}{touch-action:manipulation;user-select:none;box-sizing:border-box!important;-webkit-user-select:none;}`,
+    `.${Ot}{pointer-events:auto!important;}`,
+    `.${be}{cursor:grab;}`,
+    ".temp-child{touch-action:none;pointer-events:none;box-sizing:border-box!important;}",
+    ".droppable{box-sizing:border-box!important;}",
+    `.${qt}{position:fixed;z-index:5000;width:var(--fixedWidth)!important;height:var(--fixedHeight)!important;}`,
+    `.${Yt}{pointer-events:none!important;}`,
+    `.${Wt}{pointer-events:none!important;}`,
+    `.${se}{cursor:grabbing;}`,
+    ".disable-transition{transition:none!important;}"
+  ]);
+};
+function Bn(t, e, n, s = "index") {
+  const o = s;
+  let r = [], a = [];
+  const { droppableGroup: l } = t;
+  if (!n)
+    return [
+      r,
+      a
+    ];
+  const u = yt(l).map((d) => `droppable-group-${d}`).join(" ");
+  wn(), xn(u, n);
+  for (const d of n.children) {
+    const m = d.getAttribute(o), v = ye(m), B = d;
+    if (B && v >= 0) {
+      const [M, F] = An(
+        B,
+        v,
+        t,
+        n,
+        e
+      );
+      r.push(M), a.push(F);
+    }
+  }
+  return [
+    r,
+    a
+  ];
+}
+function On(t, e, n, s = "index", o = !0) {
+  let r = [], a = [];
+  const l = vn(t, n), u = (p) => {
+    for (const D of r)
+      D(p);
+  }, d = (p, D) => {
+    if (l.onGetLegth() === 0)
+      t.insertToListEmpty(l, p, D);
+    else
+      for (const L of a)
+        L(p, D);
+  }, m = (p) => {
+    const [D, R] = Bn(l, e, p, s);
+    r = D, a = R;
+  }, v = (p) => {
+    const D = p.addedNodes.values().filter((L) => !Ht(L)).toArray(), R = p.removedNodes.values().filter((L) => !Ht(L)).toArray();
+    return D.length > 0 || R.length > 0;
+  }, B = (p) => {
+    Zt(
+      (D) => {
+        m(p), o || D.disconnect();
+      },
+      p,
+      { childList: !0 },
+      v
+    );
+  }, M = (p) => {
+    nt(p, It);
+  }, F = (p) => {
+    lt.addConfig(
+      p,
+      l
+    );
+  };
+  return [u, d, (p) => {
+    p && (M(p), F(p), B(p), m(p), lt.removeObsoleteConfigs());
+  }];
+}
+export {
+  be as G,
+  nt as a,
+  On as d,
+  Ln as i,
+  bt as t
+};