@devtron-labs/devtron-fe-common-lib 0.0.51 → 0.0.52-beta-1

package/dist/Common/DraggableWrapper/DraggableWrapper.js

@@ -0,0 +1,1499 @@
+import { jsx as ge } from "react/jsx-runtime";
+import Ie, { useRef as ze, useState as Ke, useEffect as Je } from "react";
+import { a as Ze, g as Qe } from "../../_commonjsHelpers-c5d32002.js";
+import { r as Xe } from "../../index-c855d89c.js";
+import { a as et, r as Ae } from "../../index-5a231705.js";
+import { c as tt } from "../../react-toastify.esm-e28f7200.js";
+import { DraggablePositionVariant as nt } from "./types.js";
+import "../../Helper-1f1cf2ba.js";
+import { MAX_Z_INDEX as rt } from "../Constants.js";
+import { useWindowSize as ot } from "../Hooks/UseWindowSize/UseWindowSize.js";
+var ce = { exports: {} }, Be = {}, Pe = { exports: {} }, ye, _e;
+function Ee() {
+  if (_e)
+    return ye;
+  _e = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return ye = e, ye;
+}
+var ve, Me;
+function Ue() {
+  return Me || (Me = 1, ve = Function.call.bind(Object.prototype.hasOwnProperty)), ve;
+}
+var me, Re;
+function it() {
+  if (Re)
+    return me;
+  Re = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var t = Ee(), n = {}, r = Ue();
+    e = function(a) {
+      var f = "Warning: " + a;
+      typeof console < "u" && console.error(f);
+      try {
+        throw new Error(f);
+      } catch {
+      }
+    };
+  }
+  function i(a, f, l, d, O) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var x in a)
+        if (r(a, x)) {
+          var W;
+          try {
+            if (typeof a[x] != "function") {
+              var U = Error(
+                (d || "React class") + ": " + l + " type `" + x + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof a[x] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw U.name = "Invariant Violation", U;
+            }
+            W = a[x](f, x, d, l, null, t);
+          } catch (C) {
+            W = C;
+          }
+          if (W && !(W instanceof Error) && e(
+            (d || "React class") + ": type specification of " + l + " `" + x + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof W + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), W instanceof Error && !(W.message in n)) {
+            n[W.message] = !0;
+            var Y = O ? O() : "";
+            e(
+              "Failed " + l + " type: " + W.message + (Y ?? "")
+            );
+          }
+        }
+    }
+  }
+  return i.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (n = {});
+  }, me = i, me;
+}
+var be, Ne;
+function at() {
+  if (Ne)
+    return be;
+  Ne = 1;
+  var e = Xe, t = et(), n = Ee(), r = Ue(), i = it(), a = function() {
+  };
+  process.env.NODE_ENV !== "production" && (a = function(l) {
+    var d = "Warning: " + l;
+    typeof console < "u" && console.error(d);
+    try {
+      throw new Error(d);
+    } catch {
+    }
+  });
+  function f() {
+    return null;
+  }
+  return be = function(l, d) {
+    var O = typeof Symbol == "function" && Symbol.iterator, x = "@@iterator";
+    function W(o) {
+      var s = o && (O && o[O] || o[x]);
+      if (typeof s == "function")
+        return s;
+    }
+    var U = "<<anonymous>>", Y = {
+      array: N("array"),
+      bigint: N("bigint"),
+      bool: N("boolean"),
+      func: N("function"),
+      number: N("number"),
+      object: N("object"),
+      string: N("string"),
+      symbol: N("symbol"),
+      any: u(),
+      arrayOf: c,
+      element: g(),
+      elementType: h(),
+      instanceOf: R,
+      node: G(),
+      objectOf: H,
+      oneOf: D,
+      oneOfType: Z,
+      shape: ie,
+      exact: he
+    };
+    function C(o, s) {
+      return o === s ? o !== 0 || 1 / o === 1 / s : o !== o && s !== s;
+    }
+    function E(o, s) {
+      this.message = o, this.data = s && typeof s == "object" ? s : {}, this.stack = "";
+    }
+    E.prototype = Error.prototype;
+    function M(o) {
+      if (process.env.NODE_ENV !== "production")
+        var s = {}, b = 0;
+      function v(w, y, m, S, P, T, j) {
+        if (S = S || U, T = T || m, j !== n) {
+          if (d) {
+            var A = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw A.name = "Invariant Violation", A;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var ne = S + ":" + m;
+            !s[ne] && // Avoid spamming the console because they are often not actionable except for lib authors
+            b < 3 && (a(
+              "You are manually calling a React.PropTypes validation function for the `" + T + "` prop on `" + S + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), s[ne] = !0, b++);
+          }
+        }
+        return y[m] == null ? w ? y[m] === null ? new E("The " + P + " `" + T + "` is marked as required " + ("in `" + S + "`, but its value is `null`.")) : new E("The " + P + " `" + T + "` is marked as required in " + ("`" + S + "`, but its value is `undefined`.")) : null : o(y, m, S, P, T);
+      }
+      var p = v.bind(null, !1);
+      return p.isRequired = v.bind(null, !0), p;
+    }
+    function N(o) {
+      function s(b, v, p, w, y, m) {
+        var S = b[v], P = V(S);
+        if (P !== o) {
+          var T = z(S);
+          return new E(
+            "Invalid " + w + " `" + y + "` of type " + ("`" + T + "` supplied to `" + p + "`, expected ") + ("`" + o + "`."),
+            { expectedType: o }
+          );
+        }
+        return null;
+      }
+      return M(s);
+    }
+    function u() {
+      return M(f);
+    }
+    function c(o) {
+      function s(b, v, p, w, y) {
+        if (typeof o != "function")
+          return new E("Property `" + y + "` of component `" + p + "` has invalid PropType notation inside arrayOf.");
+        var m = b[v];
+        if (!Array.isArray(m)) {
+          var S = V(m);
+          return new E("Invalid " + w + " `" + y + "` of type " + ("`" + S + "` supplied to `" + p + "`, expected an array."));
+        }
+        for (var P = 0; P < m.length; P++) {
+          var T = o(m, P, p, w, y + "[" + P + "]", n);
+          if (T instanceof Error)
+            return T;
+        }
+        return null;
+      }
+      return M(s);
+    }
+    function g() {
+      function o(s, b, v, p, w) {
+        var y = s[b];
+        if (!l(y)) {
+          var m = V(y);
+          return new E("Invalid " + p + " `" + w + "` of type " + ("`" + m + "` supplied to `" + v + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return M(o);
+    }
+    function h() {
+      function o(s, b, v, p, w) {
+        var y = s[b];
+        if (!e.isValidElementType(y)) {
+          var m = V(y);
+          return new E("Invalid " + p + " `" + w + "` of type " + ("`" + m + "` supplied to `" + v + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return M(o);
+    }
+    function R(o) {
+      function s(b, v, p, w, y) {
+        if (!(b[v] instanceof o)) {
+          var m = o.name || U, S = ue(b[v]);
+          return new E("Invalid " + w + " `" + y + "` of type " + ("`" + S + "` supplied to `" + p + "`, expected ") + ("instance of `" + m + "`."));
+        }
+        return null;
+      }
+      return M(s);
+    }
+    function D(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? a(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : a("Invalid argument supplied to oneOf, expected an array.")), f;
+      function s(b, v, p, w, y) {
+        for (var m = b[v], S = 0; S < o.length; S++)
+          if (C(m, o[S]))
+            return null;
+        var P = JSON.stringify(o, function(j, A) {
+          var ne = z(A);
+          return ne === "symbol" ? String(A) : A;
+        });
+        return new E("Invalid " + w + " `" + y + "` of value `" + String(m) + "` " + ("supplied to `" + p + "`, expected one of " + P + "."));
+      }
+      return M(s);
+    }
+    function H(o) {
+      function s(b, v, p, w, y) {
+        if (typeof o != "function")
+          return new E("Property `" + y + "` of component `" + p + "` has invalid PropType notation inside objectOf.");
+        var m = b[v], S = V(m);
+        if (S !== "object")
+          return new E("Invalid " + w + " `" + y + "` of type " + ("`" + S + "` supplied to `" + p + "`, expected an object."));
+        for (var P in m)
+          if (r(m, P)) {
+            var T = o(m, P, p, w, y + "." + P, n);
+            if (T instanceof Error)
+              return T;
+          }
+        return null;
+      }
+      return M(s);
+    }
+    function Z(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && a("Invalid argument supplied to oneOfType, expected an instance of array."), f;
+      for (var s = 0; s < o.length; s++) {
+        var b = o[s];
+        if (typeof b != "function")
+          return a(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + se(b) + " at index " + s + "."
+          ), f;
+      }
+      function v(p, w, y, m, S) {
+        for (var P = [], T = 0; T < o.length; T++) {
+          var j = o[T], A = j(p, w, y, m, S, n);
+          if (A == null)
+            return null;
+          A.data && r(A.data, "expectedType") && P.push(A.data.expectedType);
+        }
+        var ne = P.length > 0 ? ", expected one of type [" + P.join(", ") + "]" : "";
+        return new E("Invalid " + m + " `" + S + "` supplied to " + ("`" + y + "`" + ne + "."));
+      }
+      return M(v);
+    }
+    function G() {
+      function o(s, b, v, p, w) {
+        return ee(s[b]) ? null : new E("Invalid " + p + " `" + w + "` supplied to " + ("`" + v + "`, expected a ReactNode."));
+      }
+      return M(o);
+    }
+    function Q(o, s, b, v, p) {
+      return new E(
+        (o || "React class") + ": " + s + " type `" + b + "." + v + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + p + "`."
+      );
+    }
+    function ie(o) {
+      function s(b, v, p, w, y) {
+        var m = b[v], S = V(m);
+        if (S !== "object")
+          return new E("Invalid " + w + " `" + y + "` of type `" + S + "` " + ("supplied to `" + p + "`, expected `object`."));
+        for (var P in o) {
+          var T = o[P];
+          if (typeof T != "function")
+            return Q(p, w, y, P, z(T));
+          var j = T(m, P, p, w, y + "." + P, n);
+          if (j)
+            return j;
+        }
+        return null;
+      }
+      return M(s);
+    }
+    function he(o) {
+      function s(b, v, p, w, y) {
+        var m = b[v], S = V(m);
+        if (S !== "object")
+          return new E("Invalid " + w + " `" + y + "` of type `" + S + "` " + ("supplied to `" + p + "`, expected `object`."));
+        var P = t({}, b[v], o);
+        for (var T in P) {
+          var j = o[T];
+          if (r(o, T) && typeof j != "function")
+            return Q(p, w, y, T, z(j));
+          if (!j)
+            return new E(
+              "Invalid " + w + " `" + y + "` key `" + T + "` supplied to `" + p + "`.\nBad object: " + JSON.stringify(b[v], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(o), null, "  ")
+            );
+          var A = j(m, T, p, w, y + "." + T, n);
+          if (A)
+            return A;
+        }
+        return null;
+      }
+      return M(s);
+    }
+    function ee(o) {
+      switch (typeof o) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !o;
+        case "object":
+          if (Array.isArray(o))
+            return o.every(ee);
+          if (o === null || l(o))
+            return !0;
+          var s = W(o);
+          if (s) {
+            var b = s.call(o), v;
+            if (s !== o.entries) {
+              for (; !(v = b.next()).done; )
+                if (!ee(v.value))
+                  return !1;
+            } else
+              for (; !(v = b.next()).done; ) {
+                var p = v.value;
+                if (p && !ee(p[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function ae(o, s) {
+      return o === "symbol" ? !0 : s ? s["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && s instanceof Symbol : !1;
+    }
+    function V(o) {
+      var s = typeof o;
+      return Array.isArray(o) ? "array" : o instanceof RegExp ? "object" : ae(s, o) ? "symbol" : s;
+    }
+    function z(o) {
+      if (typeof o > "u" || o === null)
+        return "" + o;
+      var s = V(o);
+      if (s === "object") {
+        if (o instanceof Date)
+          return "date";
+        if (o instanceof RegExp)
+          return "regexp";
+      }
+      return s;
+    }
+    function se(o) {
+      var s = z(o);
+      switch (s) {
+        case "array":
+        case "object":
+          return "an " + s;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + s;
+        default:
+          return s;
+      }
+    }
+    function ue(o) {
+      return !o.constructor || !o.constructor.name ? U : o.constructor.name;
+    }
+    return Y.checkPropTypes = i, Y.resetWarningCache = i.resetWarningCache, Y.PropTypes = Y, Y;
+  }, be;
+}
+var De, We;
+function st() {
+  if (We)
+    return De;
+  We = 1;
+  var e = Ee();
+  function t() {
+  }
+  function n() {
+  }
+  return n.resetWarningCache = t, De = function() {
+    function r(f, l, d, O, x, W) {
+      if (W !== e) {
+        var U = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw U.name = "Invariant Violation", U;
+      }
+    }
+    r.isRequired = r;
+    function i() {
+      return r;
+    }
+    var a = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: i,
+      element: r,
+      elementType: r,
+      instanceOf: i,
+      node: r,
+      objectOf: i,
+      oneOf: i,
+      oneOfType: i,
+      shape: i,
+      exact: i,
+      checkPropTypes: n,
+      resetWarningCache: t
+    };
+    return a.PropTypes = a, a;
+  }, De;
+}
+if (process.env.NODE_ENV !== "production") {
+  var ut = Xe, lt = !0;
+  Pe.exports = at()(ut.isElement, lt);
+} else
+  Pe.exports = st()();
+var ke = Pe.exports;
+const ct = /* @__PURE__ */ Ze(tt);
+var _ = {}, $ = {};
+Object.defineProperty($, "__esModule", {
+  value: !0
+});
+$.dontSetMe = gt;
+$.findInArray = ft;
+$.int = ht;
+$.isFunction = dt;
+$.isNum = pt;
+function ft(e, t) {
+  for (let n = 0, r = e.length; n < r; n++)
+    if (t.apply(t, [e[n], n, e]))
+      return e[n];
+}
+function dt(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Function]";
+}
+function pt(e) {
+  return typeof e == "number" && !isNaN(e);
+}
+function ht(e) {
+  return parseInt(e, 10);
+}
+function gt(e, t, n) {
+  if (e[t])
+    return new Error("Invalid prop ".concat(t, " passed to ").concat(n, " - do not set this, set it on the child."));
+}
+var te = {};
+Object.defineProperty(te, "__esModule", {
+  value: !0
+});
+te.browserPrefixToKey = je;
+te.browserPrefixToStyle = yt;
+te.default = void 0;
+te.getPrefix = qe;
+const we = ["Moz", "Webkit", "O", "ms"];
+function qe() {
+  var e;
+  let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window > "u")
+    return "";
+  const n = (e = window.document) === null || e === void 0 || (e = e.documentElement) === null || e === void 0 ? void 0 : e.style;
+  if (!n || t in n)
+    return "";
+  for (let r = 0; r < we.length; r++)
+    if (je(t, we[r]) in n)
+      return we[r];
+  return "";
+}
+function je(e, t) {
+  return t ? "".concat(t).concat(vt(e)) : e;
+}
+function yt(e, t) {
+  return t ? "-".concat(t.toLowerCase(), "-").concat(e) : e;
+}
+function vt(e) {
+  let t = "", n = !0;
+  for (let r = 0; r < e.length; r++)
+    n ? (t += e[r].toUpperCase(), n = !1) : e[r] === "-" ? n = !0 : t += e[r];
+  return t;
+}
+te.default = qe();
+Object.defineProperty(_, "__esModule", {
+  value: !0
+});
+_.addClassName = $e;
+_.addEvent = Dt;
+_.addUserSelectStyles = Rt;
+_.createCSSTransform = xt;
+_.createSVGTransform = Ct;
+_.getTouch = _t;
+_.getTouchIdentifier = Mt;
+_.getTranslation = Oe;
+_.innerHeight = Pt;
+_.innerWidth = Et;
+_.matchesSelector = He;
+_.matchesSelectorAndParentsTo = bt;
+_.offsetXYFromParent = Ot;
+_.outerHeight = St;
+_.outerWidth = Tt;
+_.removeClassName = Fe;
+_.removeEvent = wt;
+_.removeUserSelectStyles = Nt;
+var q = $, Ye = mt(te);
+function Le(e) {
+  if (typeof WeakMap != "function")
+    return null;
+  var t = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+  return (Le = function(r) {
+    return r ? n : t;
+  })(e);
+}
+function mt(e, t) {
+  if (!t && e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var n = Le(t);
+  if (n && n.has(e))
+    return n.get(e);
+  var r = {}, i = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var a in e)
+    if (a !== "default" && Object.prototype.hasOwnProperty.call(e, a)) {
+      var f = i ? Object.getOwnPropertyDescriptor(e, a) : null;
+      f && (f.get || f.set) ? Object.defineProperty(r, a, f) : r[a] = e[a];
+    }
+  return r.default = e, n && n.set(e, r), r;
+}
+let le = "";
+function He(e, t) {
+  return le || (le = (0, q.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(n) {
+    return (0, q.isFunction)(e[n]);
+  })), (0, q.isFunction)(e[le]) ? e[le](t) : !1;
+}
+function bt(e, t, n) {
+  let r = e;
+  do {
+    if (He(r, t))
+      return !0;
+    if (r === n)
+      return !1;
+    r = r.parentNode;
+  } while (r);
+  return !1;
+}
+function Dt(e, t, n, r) {
+  if (!e)
+    return;
+  const i = {
+    capture: !0,
+    ...r
+  };
+  e.addEventListener ? e.addEventListener(t, n, i) : e.attachEvent ? e.attachEvent("on" + t, n) : e["on" + t] = n;
+}
+function wt(e, t, n, r) {
+  if (!e)
+    return;
+  const i = {
+    capture: !0,
+    ...r
+  };
+  e.removeEventListener ? e.removeEventListener(t, n, i) : e.detachEvent ? e.detachEvent("on" + t, n) : e["on" + t] = null;
+}
+function St(e) {
+  let t = e.clientHeight;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, q.int)(n.borderTopWidth), t += (0, q.int)(n.borderBottomWidth), t;
+}
+function Tt(e) {
+  let t = e.clientWidth;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, q.int)(n.borderLeftWidth), t += (0, q.int)(n.borderRightWidth), t;
+}
+function Pt(e) {
+  let t = e.clientHeight;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, q.int)(n.paddingTop), t -= (0, q.int)(n.paddingBottom), t;
+}
+function Et(e) {
+  let t = e.clientWidth;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, q.int)(n.paddingLeft), t -= (0, q.int)(n.paddingRight), t;
+}
+function Ot(e, t, n) {
+  const i = t === t.ownerDocument.body ? {
+    left: 0,
+    top: 0
+  } : t.getBoundingClientRect(), a = (e.clientX + t.scrollLeft - i.left) / n, f = (e.clientY + t.scrollTop - i.top) / n;
+  return {
+    x: a,
+    y: f
+  };
+}
+function xt(e, t) {
+  const n = Oe(e, t, "px");
+  return {
+    [(0, Ye.browserPrefixToKey)("transform", Ye.default)]: n
+  };
+}
+function Ct(e, t) {
+  return Oe(e, t, "");
+}
+function Oe(e, t, n) {
+  let {
+    x: r,
+    y: i
+  } = e, a = "translate(".concat(r).concat(n, ",").concat(i).concat(n, ")");
+  if (t) {
+    const f = "".concat(typeof t.x == "string" ? t.x : t.x + n), l = "".concat(typeof t.y == "string" ? t.y : t.y + n);
+    a = "translate(".concat(f, ", ").concat(l, ")") + a;
+  }
+  return a;
+}
+function _t(e, t) {
+  return e.targetTouches && (0, q.findInArray)(e.targetTouches, (n) => t === n.identifier) || e.changedTouches && (0, q.findInArray)(e.changedTouches, (n) => t === n.identifier);
+}
+function Mt(e) {
+  if (e.targetTouches && e.targetTouches[0])
+    return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0])
+    return e.changedTouches[0].identifier;
+}
+function Rt(e) {
+  if (!e)
+    return;
+  let t = e.getElementById("react-draggable-style-el");
+  t || (t = e.createElement("style"), t.type = "text/css", t.id = "react-draggable-style-el", t.innerHTML = `.react-draggable-transparent-selection *::-moz-selection {all: inherit;}
+`, t.innerHTML += `.react-draggable-transparent-selection *::selection {all: inherit;}
+`, e.getElementsByTagName("head")[0].appendChild(t)), e.body && $e(e.body, "react-draggable-transparent-selection");
+}
+function Nt(e) {
+  if (e)
+    try {
+      if (e.body && Fe(e.body, "react-draggable-transparent-selection"), e.selection)
+        e.selection.empty();
+      else {
+        const t = (e.defaultView || window).getSelection();
+        t && t.type !== "Caret" && t.removeAllRanges();
+      }
+    } catch {
+    }
+}
+function $e(e, t) {
+  e.classList ? e.classList.add(t) : e.className.match(new RegExp("(?:^|\\s)".concat(t, "(?!\\S)"))) || (e.className += " ".concat(t));
+}
+function Fe(e, t) {
+  e.classList ? e.classList.remove(t) : e.className = e.className.replace(new RegExp("(?:^|\\s)".concat(t, "(?!\\S)"), "g"), "");
+}
+var F = {};
+Object.defineProperty(F, "__esModule", {
+  value: !0
+});
+F.canDragX = It;
+F.canDragY = Xt;
+F.createCoreData = Bt;
+F.createDraggableData = Ut;
+F.getBoundPosition = Wt;
+F.getControlPosition = At;
+F.snapToGrid = Yt;
+var k = $, re = _;
+function Wt(e, t, n) {
+  if (!e.props.bounds)
+    return [t, n];
+  let {
+    bounds: r
+  } = e.props;
+  r = typeof r == "string" ? r : kt(r);
+  const i = xe(e);
+  if (typeof r == "string") {
+    const {
+      ownerDocument: a
+    } = i, f = a.defaultView;
+    let l;
+    if (r === "parent" ? l = i.parentNode : l = a.querySelector(r), !(l instanceof f.HTMLElement))
+      throw new Error('Bounds selector "' + r + '" could not find an element.');
+    const d = l, O = f.getComputedStyle(i), x = f.getComputedStyle(d);
+    r = {
+      left: -i.offsetLeft + (0, k.int)(x.paddingLeft) + (0, k.int)(O.marginLeft),
+      top: -i.offsetTop + (0, k.int)(x.paddingTop) + (0, k.int)(O.marginTop),
+      right: (0, re.innerWidth)(d) - (0, re.outerWidth)(i) - i.offsetLeft + (0, k.int)(x.paddingRight) - (0, k.int)(O.marginRight),
+      bottom: (0, re.innerHeight)(d) - (0, re.outerHeight)(i) - i.offsetTop + (0, k.int)(x.paddingBottom) - (0, k.int)(O.marginBottom)
+    };
+  }
+  return (0, k.isNum)(r.right) && (t = Math.min(t, r.right)), (0, k.isNum)(r.bottom) && (n = Math.min(n, r.bottom)), (0, k.isNum)(r.left) && (t = Math.max(t, r.left)), (0, k.isNum)(r.top) && (n = Math.max(n, r.top)), [t, n];
+}
+function Yt(e, t, n) {
+  const r = Math.round(t / e[0]) * e[0], i = Math.round(n / e[1]) * e[1];
+  return [r, i];
+}
+function It(e) {
+  return e.props.axis === "both" || e.props.axis === "x";
+}
+function Xt(e) {
+  return e.props.axis === "both" || e.props.axis === "y";
+}
+function At(e, t, n) {
+  const r = typeof t == "number" ? (0, re.getTouch)(e, t) : null;
+  if (typeof t == "number" && !r)
+    return null;
+  const i = xe(n), a = n.props.offsetParent || i.offsetParent || i.ownerDocument.body;
+  return (0, re.offsetXYFromParent)(r || e, a, n.props.scale);
+}
+function Bt(e, t, n) {
+  const r = !(0, k.isNum)(e.lastX), i = xe(e);
+  return r ? {
+    node: i,
+    deltaX: 0,
+    deltaY: 0,
+    lastX: t,
+    lastY: n,
+    x: t,
+    y: n
+  } : {
+    node: i,
+    deltaX: t - e.lastX,
+    deltaY: n - e.lastY,
+    lastX: e.lastX,
+    lastY: e.lastY,
+    x: t,
+    y: n
+  };
+}
+function Ut(e, t) {
+  const n = e.props.scale;
+  return {
+    node: t.node,
+    x: e.state.x + t.deltaX / n,
+    y: e.state.y + t.deltaY / n,
+    deltaX: t.deltaX / n,
+    deltaY: t.deltaY / n,
+    lastX: e.state.x,
+    lastY: e.state.y
+  };
+}
+function kt(e) {
+  return {
+    left: e.left,
+    top: e.top,
+    right: e.right,
+    bottom: e.bottom
+  };
+}
+function xe(e) {
+  const t = e.findDOMNode();
+  if (!t)
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  return t;
+}
+var fe = {}, de = {};
+Object.defineProperty(de, "__esModule", {
+  value: !0
+});
+de.default = qt;
+function qt() {
+}
+Object.defineProperty(fe, "__esModule", {
+  value: !0
+});
+fe.default = void 0;
+var Se = Lt(Ie), B = Ce(ke), jt = Ce(Ae), I = _, K = F, Te = $, oe = Ce(de);
+function Ce(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function Ve(e) {
+  if (typeof WeakMap != "function")
+    return null;
+  var t = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+  return (Ve = function(r) {
+    return r ? n : t;
+  })(e);
+}
+function Lt(e, t) {
+  if (!t && e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var n = Ve(t);
+  if (n && n.has(e))
+    return n.get(e);
+  var r = {}, i = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var a in e)
+    if (a !== "default" && Object.prototype.hasOwnProperty.call(e, a)) {
+      var f = i ? Object.getOwnPropertyDescriptor(e, a) : null;
+      f && (f.get || f.set) ? Object.defineProperty(r, a, f) : r[a] = e[a];
+    }
+  return r.default = e, n && n.set(e, r), r;
+}
+function X(e, t, n) {
+  return t = Ht(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function Ht(e) {
+  var t = $t(e, "string");
+  return typeof t == "symbol" ? t : String(t);
+}
+function $t(e, t) {
+  if (typeof e != "object" || e === null)
+    return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t || "default");
+    if (typeof r != "object")
+      return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+const L = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    move: "mousemove",
+    stop: "mouseup"
+  }
+};
+let J = L.mouse, pe = class extends Se.Component {
+  constructor() {
+    super(...arguments), X(this, "dragging", !1), X(this, "lastX", NaN), X(this, "lastY", NaN), X(this, "touchIdentifier", null), X(this, "mounted", !1), X(this, "handleDragStart", (t) => {
+      if (this.props.onMouseDown(t), !this.props.allowAnyClick && typeof t.button == "number" && t.button !== 0)
+        return !1;
+      const n = this.findDOMNode();
+      if (!n || !n.ownerDocument || !n.ownerDocument.body)
+        throw new Error("<DraggableCore> not mounted on DragStart!");
+      const {
+        ownerDocument: r
+      } = n;
+      if (this.props.disabled || !(t.target instanceof r.defaultView.Node) || this.props.handle && !(0, I.matchesSelectorAndParentsTo)(t.target, this.props.handle, n) || this.props.cancel && (0, I.matchesSelectorAndParentsTo)(t.target, this.props.cancel, n))
+        return;
+      t.type === "touchstart" && t.preventDefault();
+      const i = (0, I.getTouchIdentifier)(t);
+      this.touchIdentifier = i;
+      const a = (0, K.getControlPosition)(t, i, this);
+      if (a == null)
+        return;
+      const {
+        x: f,
+        y: l
+      } = a, d = (0, K.createCoreData)(this, f, l);
+      (0, oe.default)("DraggableCore: handleDragStart: %j", d), (0, oe.default)("calling", this.props.onStart), !(this.props.onStart(t, d) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && (0, I.addUserSelectStyles)(r), this.dragging = !0, this.lastX = f, this.lastY = l, (0, I.addEvent)(r, J.move, this.handleDrag), (0, I.addEvent)(r, J.stop, this.handleDragStop));
+    }), X(this, "handleDrag", (t) => {
+      const n = (0, K.getControlPosition)(t, this.touchIdentifier, this);
+      if (n == null)
+        return;
+      let {
+        x: r,
+        y: i
+      } = n;
+      if (Array.isArray(this.props.grid)) {
+        let l = r - this.lastX, d = i - this.lastY;
+        if ([l, d] = (0, K.snapToGrid)(this.props.grid, l, d), !l && !d)
+          return;
+        r = this.lastX + l, i = this.lastY + d;
+      }
+      const a = (0, K.createCoreData)(this, r, i);
+      if ((0, oe.default)("DraggableCore: handleDrag: %j", a), this.props.onDrag(t, a) === !1 || this.mounted === !1) {
+        try {
+          this.handleDragStop(new MouseEvent("mouseup"));
+        } catch {
+          const d = document.createEvent("MouseEvents");
+          d.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(d);
+        }
+        return;
+      }
+      this.lastX = r, this.lastY = i;
+    }), X(this, "handleDragStop", (t) => {
+      if (!this.dragging)
+        return;
+      const n = (0, K.getControlPosition)(t, this.touchIdentifier, this);
+      if (n == null)
+        return;
+      let {
+        x: r,
+        y: i
+      } = n;
+      if (Array.isArray(this.props.grid)) {
+        let d = r - this.lastX || 0, O = i - this.lastY || 0;
+        [d, O] = (0, K.snapToGrid)(this.props.grid, d, O), r = this.lastX + d, i = this.lastY + O;
+      }
+      const a = (0, K.createCoreData)(this, r, i);
+      if (this.props.onStop(t, a) === !1 || this.mounted === !1)
+        return !1;
+      const l = this.findDOMNode();
+      l && this.props.enableUserSelectHack && (0, I.removeUserSelectStyles)(l.ownerDocument), (0, oe.default)("DraggableCore: handleDragStop: %j", a), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, l && ((0, oe.default)("DraggableCore: Removing handlers"), (0, I.removeEvent)(l.ownerDocument, J.move, this.handleDrag), (0, I.removeEvent)(l.ownerDocument, J.stop, this.handleDragStop));
+    }), X(this, "onMouseDown", (t) => (J = L.mouse, this.handleDragStart(t))), X(this, "onMouseUp", (t) => (J = L.mouse, this.handleDragStop(t))), X(this, "onTouchStart", (t) => (J = L.touch, this.handleDragStart(t))), X(this, "onTouchEnd", (t) => (J = L.touch, this.handleDragStop(t)));
+  }
+  componentDidMount() {
+    this.mounted = !0;
+    const t = this.findDOMNode();
+    t && (0, I.addEvent)(t, L.touch.start, this.onTouchStart, {
+      passive: !1
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+    const t = this.findDOMNode();
+    if (t) {
+      const {
+        ownerDocument: n
+      } = t;
+      (0, I.removeEvent)(n, L.mouse.move, this.handleDrag), (0, I.removeEvent)(n, L.touch.move, this.handleDrag), (0, I.removeEvent)(n, L.mouse.stop, this.handleDragStop), (0, I.removeEvent)(n, L.touch.stop, this.handleDragStop), (0, I.removeEvent)(t, L.touch.start, this.onTouchStart, {
+        passive: !1
+      }), this.props.enableUserSelectHack && (0, I.removeUserSelectStyles)(n);
+    }
+  }
+  // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+  // the underlying DOM node ourselves. See the README for more information.
+  findDOMNode() {
+    var t, n;
+    return (t = this.props) !== null && t !== void 0 && t.nodeRef ? (n = this.props) === null || n === void 0 || (n = n.nodeRef) === null || n === void 0 ? void 0 : n.current : jt.default.findDOMNode(this);
+  }
+  render() {
+    return /* @__PURE__ */ Se.cloneElement(Se.Children.only(this.props.children), {
+      // Note: mouseMove handler is attached to document so it will still function
+      // when the user drags quickly and leaves the bounds of the element.
+      onMouseDown: this.onMouseDown,
+      onMouseUp: this.onMouseUp,
+      // onTouchStart is added on `componentDidMount` so they can be added with
+      // {passive: false}, which allows it to cancel. See
+      // https://developers.google.com/web/updates/2017/01/scrolling-intervention
+      onTouchEnd: this.onTouchEnd
+    });
+  }
+};
+fe.default = pe;
+X(pe, "displayName", "DraggableCore");
+X(pe, "propTypes", {
+  /**
+   * `allowAnyClick` allows dragging using any mouse button.
+   * By default, we only accept the left button.
+   *
+   * Defaults to `false`.
+   */
+  allowAnyClick: B.default.bool,
+  children: B.default.node.isRequired,
+  /**
+   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+   * with the exception of `onMouseDown`, will not fire.
+   */
+  disabled: B.default.bool,
+  /**
+   * By default, we add 'user-select:none' attributes to the document body
+   * to prevent ugly text selection during drag. If this is causing problems
+   * for your app, set this to `false`.
+   */
+  enableUserSelectHack: B.default.bool,
+  /**
+   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
+   * instead of using the parent node.
+   */
+  offsetParent: function(e, t) {
+    if (e[t] && e[t].nodeType !== 1)
+      throw new Error("Draggable's offsetParent must be a DOM Node.");
+  },
+  /**
+   * `grid` specifies the x and y that dragging should snap to.
+   */
+  grid: B.default.arrayOf(B.default.number),
+  /**
+   * `handle` specifies a selector to be used as the handle that initiates drag.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *         return (
+   *            <Draggable handle=".handle">
+   *              <div>
+   *                  <div className="handle">Click me to drag</div>
+   *                  <div>This is some other content</div>
+   *              </div>
+   *           </Draggable>
+   *         );
+   *       }
+   *   });
+   * ```
+   */
+  handle: B.default.string,
+  /**
+   * `cancel` specifies a selector to be used to prevent drag initialization.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *           return(
+   *               <Draggable cancel=".cancel">
+   *                   <div>
+   *                     <div className="cancel">You can't drag from here</div>
+   *                     <div>Dragging here works fine</div>
+   *                   </div>
+   *               </Draggable>
+   *           );
+   *       }
+   *   });
+   * ```
+   */
+  cancel: B.default.string,
+  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.
+   * Unfortunately, in order for <Draggable> to work properly, we need raw access
+   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`
+   * as in this example:
+   *
+   * function MyComponent() {
+   *   const nodeRef = React.useRef(null);
+   *   return (
+   *     <Draggable nodeRef={nodeRef}>
+   *       <div ref={nodeRef}>Example Target</div>
+   *     </Draggable>
+   *   );
+   * }
+   *
+   * This can be used for arbitrarily nested components, so long as the ref ends up
+   * pointing to the actual child DOM node and not a custom component.
+   */
+  nodeRef: B.default.object,
+  /**
+   * Called when dragging starts.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onStart: B.default.func,
+  /**
+   * Called while dragging.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onDrag: B.default.func,
+  /**
+   * Called when dragging stops.
+   * If this function returns the boolean false, the drag will remain active.
+   */
+  onStop: B.default.func,
+  /**
+   * A workaround option which can be passed if onMouseDown needs to be accessed,
+   * since it'll always be blocked (as there is internal use of onMouseDown)
+   */
+  onMouseDown: B.default.func,
+  /**
+   * `scale`, if set, applies scaling while dragging an element
+   */
+  scale: B.default.number,
+  /**
+   * These properties should be defined on the child, not here.
+   */
+  className: Te.dontSetMe,
+  style: Te.dontSetMe,
+  transform: Te.dontSetMe
+});
+X(pe, "defaultProps", {
+  allowAnyClick: !1,
+  // by default only accept left click
+  disabled: !1,
+  enableUserSelectHack: !0,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  scale: 1
+});
+(function(e) {
+  Object.defineProperty(e, "__esModule", {
+    value: !0
+  }), Object.defineProperty(e, "DraggableCore", {
+    enumerable: !0,
+    get: function() {
+      return d.default;
+    }
+  }), e.default = void 0;
+  var t = U(Ie), n = x(ke), r = x(Ae), i = x(ct), a = _, f = F, l = $, d = x(fe), O = x(de);
+  function x(u) {
+    return u && u.__esModule ? u : { default: u };
+  }
+  function W(u) {
+    if (typeof WeakMap != "function")
+      return null;
+    var c = /* @__PURE__ */ new WeakMap(), g = /* @__PURE__ */ new WeakMap();
+    return (W = function(h) {
+      return h ? g : c;
+    })(u);
+  }
+  function U(u, c) {
+    if (!c && u && u.__esModule)
+      return u;
+    if (u === null || typeof u != "object" && typeof u != "function")
+      return { default: u };
+    var g = W(c);
+    if (g && g.has(u))
+      return g.get(u);
+    var h = {}, R = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var D in u)
+      if (D !== "default" && Object.prototype.hasOwnProperty.call(u, D)) {
+        var H = R ? Object.getOwnPropertyDescriptor(u, D) : null;
+        H && (H.get || H.set) ? Object.defineProperty(h, D, H) : h[D] = u[D];
+      }
+    return h.default = u, g && g.set(u, h), h;
+  }
+  function Y() {
+    return Y = Object.assign ? Object.assign.bind() : function(u) {
+      for (var c = 1; c < arguments.length; c++) {
+        var g = arguments[c];
+        for (var h in g)
+          Object.prototype.hasOwnProperty.call(g, h) && (u[h] = g[h]);
+      }
+      return u;
+    }, Y.apply(this, arguments);
+  }
+  function C(u, c, g) {
+    return c = E(c), c in u ? Object.defineProperty(u, c, { value: g, enumerable: !0, configurable: !0, writable: !0 }) : u[c] = g, u;
+  }
+  function E(u) {
+    var c = M(u, "string");
+    return typeof c == "symbol" ? c : String(c);
+  }
+  function M(u, c) {
+    if (typeof u != "object" || u === null)
+      return u;
+    var g = u[Symbol.toPrimitive];
+    if (g !== void 0) {
+      var h = g.call(u, c || "default");
+      if (typeof h != "object")
+        return h;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (c === "string" ? String : Number)(u);
+  }
+  class N extends t.Component {
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps(c, g) {
+      let {
+        position: h
+      } = c, {
+        prevPropsPosition: R
+      } = g;
+      return h && (!R || h.x !== R.x || h.y !== R.y) ? ((0, O.default)("Draggable: getDerivedStateFromProps %j", {
+        position: h,
+        prevPropsPosition: R
+      }), {
+        x: h.x,
+        y: h.y,
+        prevPropsPosition: {
+          ...h
+        }
+      }) : null;
+    }
+    constructor(c) {
+      super(c), C(this, "onDragStart", (g, h) => {
+        if ((0, O.default)("Draggable: onDragStart: %j", h), this.props.onStart(g, (0, f.createDraggableData)(this, h)) === !1)
+          return !1;
+        this.setState({
+          dragging: !0,
+          dragged: !0
+        });
+      }), C(this, "onDrag", (g, h) => {
+        if (!this.state.dragging)
+          return !1;
+        (0, O.default)("Draggable: onDrag: %j", h);
+        const R = (0, f.createDraggableData)(this, h), D = {
+          x: R.x,
+          y: R.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x: Z,
+            y: G
+          } = D;
+          D.x += this.state.slackX, D.y += this.state.slackY;
+          const [Q, ie] = (0, f.getBoundPosition)(this, D.x, D.y);
+          D.x = Q, D.y = ie, D.slackX = this.state.slackX + (Z - D.x), D.slackY = this.state.slackY + (G - D.y), R.x = D.x, R.y = D.y, R.deltaX = D.x - this.state.x, R.deltaY = D.y - this.state.y;
+        }
+        if (this.props.onDrag(g, R) === !1)
+          return !1;
+        this.setState(D);
+      }), C(this, "onDragStop", (g, h) => {
+        if (!this.state.dragging || this.props.onStop(g, (0, f.createDraggableData)(this, h)) === !1)
+          return !1;
+        (0, O.default)("Draggable: onDragStop: %j", h);
+        const D = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const {
+            x: Z,
+            y: G
+          } = this.props.position;
+          D.x = Z, D.y = G;
+        }
+        this.setState(D);
+      }), this.state = {
+        // Whether or not we are currently dragging.
+        dragging: !1,
+        // Whether or not we have been dragged before.
+        dragged: !1,
+        // Current transform x and y.
+        x: c.position ? c.position.x : c.defaultPosition.x,
+        y: c.position ? c.position.y : c.defaultPosition.y,
+        prevPropsPosition: {
+          ...c.position
+        },
+        // Used for compensating for out-of-bounds drags
+        slackX: 0,
+        slackY: 0,
+        // Can only determine if SVG after mounting
+        isElementSVG: !1
+      }, c.position && !(c.onDrag || c.onStop) && console.warn("A `position` was applied to this <Draggable>, without drag handlers. This will make this component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the `position` of this element.");
+    }
+    componentDidMount() {
+      typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
+        isElementSVG: !0
+      });
+    }
+    componentWillUnmount() {
+      this.setState({
+        dragging: !1
+      });
+    }
+    // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+    // the underlying DOM node ourselves. See the README for more information.
+    findDOMNode() {
+      var c, g;
+      return (c = (g = this.props) === null || g === void 0 || (g = g.nodeRef) === null || g === void 0 ? void 0 : g.current) !== null && c !== void 0 ? c : r.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis: c,
+        bounds: g,
+        children: h,
+        defaultPosition: R,
+        defaultClassName: D,
+        defaultClassNameDragging: H,
+        defaultClassNameDragged: Z,
+        position: G,
+        positionOffset: Q,
+        scale: ie,
+        ...he
+      } = this.props;
+      let ee = {}, ae = null;
+      const z = !!!G || this.state.dragging, se = G || R, ue = {
+        // Set left if horizontal drag is enabled
+        x: (0, f.canDragX)(this) && z ? this.state.x : se.x,
+        // Set top if vertical drag is enabled
+        y: (0, f.canDragY)(this) && z ? this.state.y : se.y
+      };
+      this.state.isElementSVG ? ae = (0, a.createSVGTransform)(ue, Q) : ee = (0, a.createCSSTransform)(ue, Q);
+      const o = (0, i.default)(h.props.className || "", D, {
+        [H]: this.state.dragging,
+        [Z]: this.state.dragged
+      });
+      return /* @__PURE__ */ t.createElement(d.default, Y({}, he, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ t.cloneElement(t.Children.only(h), {
+        className: o,
+        style: {
+          ...h.props.style,
+          ...ee
+        },
+        transform: ae
+      }));
+    }
+  }
+  e.default = N, C(N, "displayName", "Draggable"), C(N, "propTypes", {
+    // Accepts all props <DraggableCore> accepts.
+    ...d.default.propTypes,
+    /**
+     * `axis` determines which axis the draggable can move.
+     *
+     *  Note that all callbacks will still return data as normal. This only
+     *  controls flushing to the DOM.
+     *
+     * 'both' allows movement horizontally and vertically.
+     * 'x' limits movement to horizontal axis.
+     * 'y' limits movement to vertical axis.
+     * 'none' limits all movement.
+     *
+     * Defaults to 'both'.
+     */
+    axis: n.default.oneOf(["both", "x", "y", "none"]),
+    /**
+     * `bounds` determines the range of movement available to the element.
+     * Available values are:
+     *
+     * 'parent' restricts movement within the Draggable's parent node.
+     *
+     * Alternatively, pass an object with the following properties, all of which are optional:
+     *
+     * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}
+     *
+     * All values are in px.
+     *
+     * Example:
+     *
+     * ```jsx
+     *   let App = React.createClass({
+     *       render: function () {
+     *         return (
+     *            <Draggable bounds={{right: 300, bottom: 300}}>
+     *              <div>Content</div>
+     *           </Draggable>
+     *         );
+     *       }
+     *   });
+     * ```
+     */
+    bounds: n.default.oneOfType([n.default.shape({
+      left: n.default.number,
+      right: n.default.number,
+      top: n.default.number,
+      bottom: n.default.number
+    }), n.default.string, n.default.oneOf([!1])]),
+    defaultClassName: n.default.string,
+    defaultClassNameDragging: n.default.string,
+    defaultClassNameDragged: n.default.string,
+    /**
+     * `defaultPosition` specifies the x and y that the dragged item should start at
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable defaultPosition={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    defaultPosition: n.default.shape({
+      x: n.default.number,
+      y: n.default.number
+    }),
+    positionOffset: n.default.shape({
+      x: n.default.oneOfType([n.default.number, n.default.string]),
+      y: n.default.oneOfType([n.default.number, n.default.string])
+    }),
+    /**
+     * `position`, if present, defines the current position of the element.
+     *
+     *  This is similar to how form elements in React work - if no `position` is supplied, the component
+     *  is uncontrolled.
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable position={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    position: n.default.shape({
+      x: n.default.number,
+      y: n.default.number
+    }),
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: l.dontSetMe,
+    style: l.dontSetMe,
+    transform: l.dontSetMe
+  }), C(N, "defaultProps", {
+    ...d.default.defaultProps,
+    axis: "both",
+    bounds: !1,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: {
+      x: 0,
+      y: 0
+    },
+    scale: 1
+  });
+})(Be);
+const {
+  default: Ge,
+  DraggableCore: Ft
+} = Be;
+ce.exports = Ge;
+ce.exports.default = Ge;
+ce.exports.DraggableCore = Ft;
+var Vt = ce.exports;
+const Gt = /* @__PURE__ */ Qe(Vt);
+function sn({
+  children: e,
+  zIndex: t = rt,
+  positionVariant: n,
+  dragSelector: r,
+  parentRef: i,
+  boundaryGap: a = 16,
+  childDivProps: f = {}
+}) {
+  const l = ot(), d = ze(null), [O, x] = Ke({
+    x: 0,
+    y: 0
+  }), W = (Y) => {
+    const C = i?.current?.getBoundingClientRect() ?? {
+      width: 0,
+      height: 0,
+      top: 0,
+      left: 0,
+      bottom: 0
+    }, E = d.current?.getBoundingClientRect().height ?? 0, M = d.current?.getBoundingClientRect().width ?? 0;
+    switch (Y) {
+      case nt.PARENT_BOTTOM_CENTER: {
+        const N = (C.width - M) / 2, c = (C.height > l.height ? l.height - C.top : C.height) - E - a;
+        return { x: N, y: c };
+      }
+      default: {
+        const N = l.width / 2 - C.left - M / 2, u = l.height - C.top - E - a;
+        return { x: N, y: u };
+      }
+    }
+  };
+  Je(() => {
+    const Y = W(n);
+    x(Y);
+  }, [d, n, l]);
+  function U(Y, C) {
+    const E = i?.current?.getBoundingClientRect().left ?? 0, M = i?.current?.getBoundingClientRect().top ?? 0, N = d.current?.getBoundingClientRect().height ?? 0, u = d.current?.getBoundingClientRect().width ?? 0;
+    E + C.x + u + a > l.width || M + C.y + N + a > l.height || E + C.x < 0 || M + C.y < 0 || x({
+      x: C.x,
+      y: C.y
+    });
+  }
+  return /* @__PURE__ */ ge(
+    "div",
+    {
+      className: "dc__position-fixed",
+      style: {
+        zIndex: t
+      },
+      children: /* @__PURE__ */ ge(Gt, { handle: r, nodeRef: d, position: O, onDrag: U, children: /* @__PURE__ */ ge(
+        "div",
+        {
+          ref: d,
+          ...f,
+          style: {
+            zIndex: t
+          },
+          children: e
+        }
+      ) })
+    }
+  );
+}
+export {
+  sn as default
+};