@m4l/components 0.1.26 → 0.1.28

package/react-draggable.20e95c61.js

@@ -1,164 +1,226 @@
-import de from "react";
-import pe from "prop-types";
-import ge from "react-dom";
-import Ie from "clsx";
-import { s as ye, l as ve, d as he, p as me } from "./utils/index.214d9542.js";
-var re = { exports: {} }, be = {}, L = {};
-function V(r) {
-  return V = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(a) {
-    return typeof a;
-  } : function(a) {
-    return a && typeof Symbol == "function" && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a;
-  }, V(r);
+import React$1 from "react";
+import require$$1 from "prop-types";
+import require$$2 from "react-dom";
+import clsx from "clsx";
+import { s as shims, l as log, d as domFns, p as positionFns } from "./utils/index.214d9542.js";
+var cjs = { exports: {} };
+var Draggable$1 = {};
+var DraggableCore$2 = {};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
 }
-Object.defineProperty(L, "__esModule", {
-  value: !0
+Object.defineProperty(DraggableCore$2, "__esModule", {
+  value: true
 });
-L.default = void 0;
-var Z = We(de), w = ne(pe), Ue = ne(ge), _ = he, j = me, ee = ye, F = ne(ve);
-function ne(r) {
-  return r && r.__esModule ? r : { default: r };
+DraggableCore$2.default = void 0;
+var React = _interopRequireWildcard(React$1);
+var _propTypes = _interopRequireDefault(require$$1);
+var _reactDom = _interopRequireDefault(require$$2);
+var _domFns = domFns;
+var _positionFns = positionFns;
+var _shims = shims;
+var _log = _interopRequireDefault(log);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
 }
-function De(r) {
-  if (typeof WeakMap != "function")
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
     return null;
-  var a = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap();
-  return (De = function(d) {
-    return d ? l : a;
-  })(r);
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
 }
-function We(r, a) {
-  if (!a && r && r.__esModule)
-    return r;
-  if (r === null || V(r) !== "object" && typeof r != "function")
-    return { default: r };
-  var l = De(a);
-  if (l && l.has(r))
-    return l.get(r);
-  var e = {}, d = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var p in r)
-    if (p !== "default" && Object.prototype.hasOwnProperty.call(r, p)) {
-      var h = d ? Object.getOwnPropertyDescriptor(r, p) : null;
-      h && (h.get || h.set) ? Object.defineProperty(e, p, h) : e[p] = r[p];
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
     }
-  return e.default = r, l && l.set(r, e), e;
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
 }
-function fe(r, a) {
-  return Xe(r) || Fe(r, a) || qe(r, a) || $e();
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
-function $e() {
-  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function qe(r, a) {
-  if (!!r) {
-    if (typeof r == "string")
-      return se(r, a);
-    var l = Object.prototype.toString.call(r).slice(8, -1);
-    if (l === "Object" && r.constructor && (l = r.constructor.name), l === "Map" || l === "Set")
-      return Array.from(r);
-    if (l === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(l))
-      return se(r, a);
-  }
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
 }
-function se(r, a) {
-  (a == null || a > r.length) && (a = r.length);
-  for (var l = 0, e = new Array(a); l < a; l++)
-    e[l] = r[l];
-  return e;
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
 }
-function Fe(r, a) {
-  var l = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
-  if (l != null) {
-    var e = [], d = !0, p = !1, h, s;
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i == null)
+    return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _s, _e;
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i)
+        break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
     try {
-      for (l = l.call(r); !(d = (h = l.next()).done) && (e.push(h.value), !(a && e.length === a)); d = !0)
-        ;
-    } catch (v) {
-      p = !0, s = v;
+      if (!_n && _i["return"] != null)
+        _i["return"]();
     } finally {
-      try {
-        !d && l.return != null && l.return();
-      } finally {
-        if (p)
-          throw s;
-      }
+      if (_d)
+        throw _e;
     }
-    return e;
   }
+  return _arr;
 }
-function Xe(r) {
-  if (Array.isArray(r))
-    return r;
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr))
+    return arr;
 }
-function Ye(r, a) {
-  if (!(r instanceof a))
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
     throw new TypeError("Cannot call a class as a function");
+  }
 }
-function ce(r, a) {
-  for (var l = 0; l < a.length; l++) {
-    var e = a[l];
-    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(r, e.key, e);
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
   }
 }
-function Be(r, a, l) {
-  return a && ce(r.prototype, a), l && ce(r, l), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
 }
-function He(r, a) {
-  if (typeof a != "function" && a !== null)
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
     throw new TypeError("Super expression must either be null or a function");
-  r.prototype = Object.create(a && a.prototype, { constructor: { value: r, writable: !0, configurable: !0 } }), Object.defineProperty(r, "prototype", { writable: !1 }), a && te(r, a);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass)
+    _setPrototypeOf(subClass, superClass);
 }
-function te(r, a) {
-  return te = Object.setPrototypeOf || function(e, d) {
-    return e.__proto__ = d, e;
-  }, te(r, a);
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
 }
-function Ve(r) {
-  var a = Le();
-  return function() {
-    var e = G(r), d;
-    if (a) {
-      var p = G(this).constructor;
-      d = Reflect.construct(e, arguments, p);
-    } else
-      d = e.apply(this, arguments);
-    return Ge(this, d);
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
   };
 }
-function Ge(r, a) {
-  if (a && (V(a) === "object" || typeof a == "function"))
-    return a;
-  if (a !== void 0)
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
     throw new TypeError("Derived constructors may only return object or undefined");
-  return S(r);
+  }
+  return _assertThisInitialized(self);
 }
-function S(r) {
-  if (r === void 0)
+function _assertThisInitialized(self) {
+  if (self === void 0) {
     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  return r;
+  }
+  return self;
 }
-function Le() {
-  if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
-    return !1;
-  if (typeof Proxy == "function")
-    return !0;
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
   try {
-    return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
-    })), !0;
-  } catch {
-    return !1;
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
   }
 }
-function G(r) {
-  return G = Object.setPrototypeOf ? Object.getPrototypeOf : function(l) {
-    return l.__proto__ || Object.getPrototypeOf(l);
-  }, G(r);
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
 }
-function P(r, a, l) {
-  return a in r ? Object.defineProperty(r, a, { value: l, enumerable: !0, configurable: !0, writable: !0 }) : r[a] = l, r;
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
 }
-var N = {
+var eventsFor = {
   touch: {
     start: "touchstart",
     move: "touchmove",
@@ -169,532 +231,717 @@ var N = {
     move: "mousemove",
     stop: "mouseup"
   }
-}, k = N.mouse, z = /* @__PURE__ */ function(r) {
-  He(l, r);
-  var a = Ve(l);
-  function l() {
-    var e;
-    Ye(this, l);
-    for (var d = arguments.length, p = new Array(d), h = 0; h < d; h++)
-      p[h] = arguments[h];
-    return e = a.call.apply(a, [this].concat(p)), P(S(e), "state", {
-      dragging: !1,
+};
+var dragEventFor = eventsFor.mouse;
+var DraggableCore$1 = /* @__PURE__ */ function(_React$Component) {
+  _inherits(DraggableCore2, _React$Component);
+  var _super = _createSuper(DraggableCore2);
+  function DraggableCore2() {
+    var _this;
+    _classCallCheck(this, DraggableCore2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      dragging: false,
       lastX: NaN,
       lastY: NaN,
       touchIdentifier: null
-    }), P(S(e), "mounted", !1), P(S(e), "handleDragStart", function(s) {
-      if (e.props.onMouseDown(s), !e.props.allowAnyClick && typeof s.button == "number" && s.button !== 0)
-        return !1;
-      var v = e.findDOMNode();
-      if (!v || !v.ownerDocument || !v.ownerDocument.body)
+    });
+    _defineProperty(_assertThisInitialized(_this), "mounted", false);
+    _defineProperty(_assertThisInitialized(_this), "handleDragStart", function(e) {
+      _this.props.onMouseDown(e);
+      if (!_this.props.allowAnyClick && typeof e.button === "number" && e.button !== 0)
+        return false;
+      var thisNode = _this.findDOMNode();
+      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {
         throw new Error("<DraggableCore> not mounted on DragStart!");
-      var m = v.ownerDocument;
-      if (!(e.props.disabled || !(s.target instanceof m.defaultView.Node) || e.props.handle && !(0, _.matchesSelectorAndParentsTo)(s.target, e.props.handle, v) || e.props.cancel && (0, _.matchesSelectorAndParentsTo)(s.target, e.props.cancel, v))) {
-        s.type === "touchstart" && s.preventDefault();
-        var D = (0, _.getTouchIdentifier)(s);
-        e.setState({
-          touchIdentifier: D
-        });
-        var O = (0, j.getControlPosition)(s, D, S(e));
-        if (O != null) {
-          var b = O.x, E = O.y, M = (0, j.createCoreData)(S(e), b, E);
-          (0, F.default)("DraggableCore: handleDragStart: %j", M), (0, F.default)("calling", e.props.onStart);
-          var x = e.props.onStart(s, M);
-          x === !1 || e.mounted === !1 || (e.props.enableUserSelectHack && (0, _.addUserSelectStyles)(m), e.setState({
-            dragging: !0,
-            lastX: b,
-            lastY: E
-          }), (0, _.addEvent)(m, k.move, e.handleDrag), (0, _.addEvent)(m, k.stop, e.handleDragStop));
-        }
       }
-    }), P(S(e), "handleDrag", function(s) {
-      var v = (0, j.getControlPosition)(s, e.state.touchIdentifier, S(e));
-      if (v != null) {
-        var m = v.x, D = v.y;
-        if (Array.isArray(e.props.grid)) {
-          var O = m - e.state.lastX, b = D - e.state.lastY, E = (0, j.snapToGrid)(e.props.grid, O, b), M = fe(E, 2);
-          if (O = M[0], b = M[1], !O && !b)
-            return;
-          m = e.state.lastX + O, D = e.state.lastY + b;
-        }
-        var x = (0, j.createCoreData)(S(e), m, D);
-        (0, F.default)("DraggableCore: handleDrag: %j", x);
-        var $ = e.props.onDrag(s, x);
-        if ($ === !1 || e.mounted === !1) {
-          try {
-            e.handleDragStop(new MouseEvent("mouseup"));
-          } catch {
-            var C = document.createEvent("MouseEvents");
-            C.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), e.handleDragStop(C);
-          }
+      var ownerDocument = thisNode.ownerDocument;
+      if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {
+        return;
+      }
+      if (e.type === "touchstart")
+        e.preventDefault();
+      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
+      _this.setState({
+        touchIdentifier
+      });
+      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));
+      if (position == null)
+        return;
+      var x = position.x, y = position.y;
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
+      (0, _log.default)("DraggableCore: handleDragStart: %j", coreEvent);
+      (0, _log.default)("calling", _this.props.onStart);
+      var shouldUpdate = _this.props.onStart(e, coreEvent);
+      if (shouldUpdate === false || _this.mounted === false)
+        return;
+      if (_this.props.enableUserSelectHack)
+        (0, _domFns.addUserSelectStyles)(ownerDocument);
+      _this.setState({
+        dragging: true,
+        lastX: x,
+        lastY: y
+      });
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleDrag", function(e) {
+      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
+      if (position == null)
+        return;
+      var x = position.x, y = position.y;
+      if (Array.isArray(_this.props.grid)) {
+        var deltaX = x - _this.state.lastX, deltaY = y - _this.state.lastY;
+        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
+        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);
+        deltaX = _snapToGrid2[0];
+        deltaY = _snapToGrid2[1];
+        if (!deltaX && !deltaY)
           return;
-        }
-        e.setState({
-          lastX: m,
-          lastY: D
-        });
+        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
       }
-    }), P(S(e), "handleDragStop", function(s) {
-      if (!!e.state.dragging) {
-        var v = (0, j.getControlPosition)(s, e.state.touchIdentifier, S(e));
-        if (v != null) {
-          var m = v.x, D = v.y;
-          if (Array.isArray(e.props.grid)) {
-            var O = m - e.state.lastX || 0, b = D - e.state.lastY || 0, E = (0, j.snapToGrid)(e.props.grid, O, b), M = fe(E, 2);
-            O = M[0], b = M[1], m = e.state.lastX + O, D = e.state.lastY + b;
-          }
-          var x = (0, j.createCoreData)(S(e), m, D), $ = e.props.onStop(s, x);
-          if ($ === !1 || e.mounted === !1)
-            return !1;
-          var C = e.findDOMNode();
-          C && e.props.enableUserSelectHack && (0, _.removeUserSelectStyles)(C.ownerDocument), (0, F.default)("DraggableCore: handleDragStop: %j", x), e.setState({
-            dragging: !1,
-            lastX: NaN,
-            lastY: NaN
-          }), C && ((0, F.default)("DraggableCore: Removing handlers"), (0, _.removeEvent)(C.ownerDocument, k.move, e.handleDrag), (0, _.removeEvent)(C.ownerDocument, k.stop, e.handleDragStop));
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
+      (0, _log.default)("DraggableCore: handleDrag: %j", coreEvent);
+      var shouldUpdate = _this.props.onDrag(e, coreEvent);
+      if (shouldUpdate === false || _this.mounted === false) {
+        try {
+          _this.handleDragStop(new MouseEvent("mouseup"));
+        } catch (err) {
+          var event = document.createEvent("MouseEvents");
+          event.initMouseEvent("mouseup", true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+          _this.handleDragStop(event);
         }
+        return;
       }
-    }), P(S(e), "onMouseDown", function(s) {
-      return k = N.mouse, e.handleDragStart(s);
-    }), P(S(e), "onMouseUp", function(s) {
-      return k = N.mouse, e.handleDragStop(s);
-    }), P(S(e), "onTouchStart", function(s) {
-      return k = N.touch, e.handleDragStart(s);
-    }), P(S(e), "onTouchEnd", function(s) {
-      return k = N.touch, e.handleDragStop(s);
-    }), e;
-  }
-  return Be(l, [{
-    key: "componentDidMount",
-    value: function() {
-      this.mounted = !0;
-      var d = this.findDOMNode();
-      d && (0, _.addEvent)(d, N.touch.start, this.onTouchStart, {
-        passive: !1
+      _this.setState({
+        lastX: x,
+        lastY: y
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleDragStop", function(e) {
+      if (!_this.state.dragging)
+        return;
+      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
+      if (position == null)
+        return;
+      var x = position.x, y = position.y;
+      if (Array.isArray(_this.props.grid)) {
+        var deltaX = x - _this.state.lastX || 0;
+        var deltaY = y - _this.state.lastY || 0;
+        var _snapToGrid3 = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
+        var _snapToGrid4 = _slicedToArray(_snapToGrid3, 2);
+        deltaX = _snapToGrid4[0];
+        deltaY = _snapToGrid4[1];
+        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
+      }
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
+      var shouldContinue = _this.props.onStop(e, coreEvent);
+      if (shouldContinue === false || _this.mounted === false)
+        return false;
+      var thisNode = _this.findDOMNode();
+      if (thisNode) {
+        if (_this.props.enableUserSelectHack)
+          (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
+      }
+      (0, _log.default)("DraggableCore: handleDragStop: %j", coreEvent);
+      _this.setState({
+        dragging: false,
+        lastX: NaN,
+        lastY: NaN
       });
+      if (thisNode) {
+        (0, _log.default)("DraggableCore: Removing handlers");
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "onMouseDown", function(e) {
+      dragEventFor = eventsFor.mouse;
+      return _this.handleDragStart(e);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onMouseUp", function(e) {
+      dragEventFor = eventsFor.mouse;
+      return _this.handleDragStop(e);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onTouchStart", function(e) {
+      dragEventFor = eventsFor.touch;
+      return _this.handleDragStart(e);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onTouchEnd", function(e) {
+      dragEventFor = eventsFor.touch;
+      return _this.handleDragStop(e);
+    });
+    return _this;
+  }
+  _createClass(DraggableCore2, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.mounted = true;
+      var thisNode = this.findDOMNode();
+      if (thisNode) {
+        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+          passive: false
+        });
+      }
     }
   }, {
     key: "componentWillUnmount",
-    value: function() {
-      this.mounted = !1;
-      var d = this.findDOMNode();
-      if (d) {
-        var p = d.ownerDocument;
-        (0, _.removeEvent)(p, N.mouse.move, this.handleDrag), (0, _.removeEvent)(p, N.touch.move, this.handleDrag), (0, _.removeEvent)(p, N.mouse.stop, this.handleDragStop), (0, _.removeEvent)(p, N.touch.stop, this.handleDragStop), (0, _.removeEvent)(d, N.touch.start, this.onTouchStart, {
-          passive: !1
-        }), this.props.enableUserSelectHack && (0, _.removeUserSelectStyles)(p);
+    value: function componentWillUnmount() {
+      this.mounted = false;
+      var thisNode = this.findDOMNode();
+      if (thisNode) {
+        var ownerDocument = thisNode.ownerDocument;
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
+        (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+          passive: false
+        });
+        if (this.props.enableUserSelectHack)
+          (0, _domFns.removeUserSelectStyles)(ownerDocument);
       }
     }
   }, {
     key: "findDOMNode",
-    value: function() {
-      var d, p, h;
-      return (d = this.props) !== null && d !== void 0 && d.nodeRef ? (p = this.props) === null || p === void 0 || (h = p.nodeRef) === null || h === void 0 ? void 0 : h.current : Ue.default.findDOMNode(this);
+    value: function findDOMNode() {
+      var _this$props, _this$props2, _this$props2$nodeRef;
+      return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 ? void 0 : (_this$props2$nodeRef = _this$props2.nodeRef) === null || _this$props2$nodeRef === void 0 ? void 0 : _this$props2$nodeRef.current : _reactDom.default.findDOMNode(this);
     }
   }, {
     key: "render",
-    value: function() {
-      return /* @__PURE__ */ Z.cloneElement(Z.Children.only(this.props.children), {
+    value: function render() {
+      return /* @__PURE__ */ React.cloneElement(React.Children.only(this.props.children), {
         onMouseDown: this.onMouseDown,
         onMouseUp: this.onMouseUp,
         onTouchEnd: this.onTouchEnd
       });
     }
-  }]), l;
-}(Z.Component);
-L.default = z;
-P(z, "displayName", "DraggableCore");
-P(z, "propTypes", {
-  allowAnyClick: w.default.bool,
-  disabled: w.default.bool,
-  enableUserSelectHack: w.default.bool,
-  offsetParent: function(a, l) {
-    if (a[l] && a[l].nodeType !== 1)
+  }]);
+  return DraggableCore2;
+}(React.Component);
+DraggableCore$2.default = DraggableCore$1;
+_defineProperty(DraggableCore$1, "displayName", "DraggableCore");
+_defineProperty(DraggableCore$1, "propTypes", {
+  allowAnyClick: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  enableUserSelectHack: _propTypes.default.bool,
+  offsetParent: function offsetParent(props, propName) {
+    if (props[propName] && props[propName].nodeType !== 1) {
       throw new Error("Draggable's offsetParent must be a DOM Node.");
+    }
   },
-  grid: w.default.arrayOf(w.default.number),
-  handle: w.default.string,
-  cancel: w.default.string,
-  nodeRef: w.default.object,
-  onStart: w.default.func,
-  onDrag: w.default.func,
-  onStop: w.default.func,
-  onMouseDown: w.default.func,
-  scale: w.default.number,
-  className: ee.dontSetMe,
-  style: ee.dontSetMe,
-  transform: ee.dontSetMe
+  grid: _propTypes.default.arrayOf(_propTypes.default.number),
+  handle: _propTypes.default.string,
+  cancel: _propTypes.default.string,
+  nodeRef: _propTypes.default.object,
+  onStart: _propTypes.default.func,
+  onDrag: _propTypes.default.func,
+  onStop: _propTypes.default.func,
+  onMouseDown: _propTypes.default.func,
+  scale: _propTypes.default.number,
+  className: _shims.dontSetMe,
+  style: _shims.dontSetMe,
+  transform: _shims.dontSetMe
 });
-P(z, "defaultProps", {
-  allowAnyClick: !1,
-  disabled: !1,
-  enableUserSelectHack: !0,
-  onStart: function() {
+_defineProperty(DraggableCore$1, "defaultProps", {
+  allowAnyClick: false,
+  disabled: false,
+  enableUserSelectHack: true,
+  onStart: function onStart() {
   },
-  onDrag: function() {
+  onDrag: function onDrag() {
   },
-  onStop: function() {
+  onStop: function onStop() {
   },
-  onMouseDown: function() {
+  onMouseDown: function onMouseDown() {
   },
   scale: 1
 });
-(function(r) {
-  function a(t) {
-    return a = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(n) {
-      return typeof n;
-    } : function(n) {
-      return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
-    }, a(t);
-  }
-  Object.defineProperty(r, "__esModule", {
-    value: !0
-  }), Object.defineProperty(r, "DraggableCore", {
-    enumerable: !0,
-    get: function() {
-      return m.default;
+(function(exports) {
+  function _typeof2(obj) {
+    "@babel/helpers - typeof";
+    return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof2(obj);
+  }
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "DraggableCore", {
+    enumerable: true,
+    get: function get() {
+      return _DraggableCore.default;
     }
-  }), r.default = void 0;
-  var l = M(de), e = b(pe), d = b(ge), p = b(Ie), h = he, s = me, v = ye, m = b(L), D = b(ve), O = ["axis", "bounds", "children", "defaultPosition", "defaultClassName", "defaultClassNameDragging", "defaultClassNameDragged", "position", "positionOffset", "scale"];
-  function b(t) {
-    return t && t.__esModule ? t : { default: t };
-  }
-  function E(t) {
-    if (typeof WeakMap != "function")
+  });
+  exports.default = void 0;
+  var React2 = _interopRequireWildcard2(React$1);
+  var _propTypes2 = _interopRequireDefault2(require$$1);
+  var _reactDom2 = _interopRequireDefault2(require$$2);
+  var _clsx2 = _interopRequireDefault2(clsx);
+  var _domFns2 = domFns;
+  var _positionFns2 = positionFns;
+  var _shims2 = shims;
+  var _DraggableCore = _interopRequireDefault2(DraggableCore$2);
+  var _log2 = _interopRequireDefault2(log);
+  var _excluded = ["axis", "bounds", "children", "defaultPosition", "defaultClassName", "defaultClassNameDragging", "defaultClassNameDragged", "position", "positionOffset", "scale"];
+  function _interopRequireDefault2(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  function _getRequireWildcardCache2(nodeInterop) {
+    if (typeof WeakMap !== "function")
       return null;
-    var n = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
-    return (E = function(u) {
-      return u ? o : n;
-    })(t);
-  }
-  function M(t, n) {
-    if (!n && t && t.__esModule)
-      return t;
-    if (t === null || a(t) !== "object" && typeof t != "function")
-      return { default: t };
-    var o = E(n);
-    if (o && o.has(t))
-      return o.get(t);
-    var i = {}, u = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for (var f in t)
-      if (f !== "default" && Object.prototype.hasOwnProperty.call(t, f)) {
-        var c = u ? Object.getOwnPropertyDescriptor(t, f) : null;
-        c && (c.get || c.set) ? Object.defineProperty(i, f, c) : i[f] = t[f];
+    var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+    var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+    return (_getRequireWildcardCache2 = function _getRequireWildcardCache3(nodeInterop2) {
+      return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+  }
+  function _interopRequireWildcard2(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+      return obj;
+    }
+    if (obj === null || _typeof2(obj) !== "object" && typeof obj !== "function") {
+      return { default: obj };
+    }
+    var cache = _getRequireWildcardCache2(nodeInterop);
+    if (cache && cache.has(obj)) {
+      return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var key in obj) {
+      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        if (desc && (desc.get || desc.set)) {
+          Object.defineProperty(newObj, key, desc);
+        } else {
+          newObj[key] = obj[key];
+        }
       }
-    return i.default = t, o && o.set(t, i), i;
-  }
-  function x() {
-    return x = Object.assign || function(t) {
-      for (var n = 1; n < arguments.length; n++) {
-        var o = arguments[n];
-        for (var i in o)
-          Object.prototype.hasOwnProperty.call(o, i) && (t[i] = o[i]);
+    }
+    newObj.default = obj;
+    if (cache) {
+      cache.set(obj, newObj);
+    }
+    return newObj;
+  }
+  function _extends() {
+    _extends = Object.assign || function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
       }
-      return t;
-    }, x.apply(this, arguments);
+      return target;
+    };
+    return _extends.apply(this, arguments);
   }
-  function $(t, n) {
-    if (t == null)
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null)
       return {};
-    var o = C(t, n), i, u;
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
     if (Object.getOwnPropertySymbols) {
-      var f = Object.getOwnPropertySymbols(t);
-      for (u = 0; u < f.length; u++)
-        i = f[u], !(n.indexOf(i) >= 0) && (!Object.prototype.propertyIsEnumerable.call(t, i) || (o[i] = t[i]));
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0)
+          continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key))
+          continue;
+        target[key] = source[key];
+      }
     }
-    return o;
+    return target;
   }
-  function C(t, n) {
-    if (t == null)
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null)
       return {};
-    var o = {}, i = Object.keys(t), u, f;
-    for (f = 0; f < i.length; f++)
-      u = i[f], !(n.indexOf(u) >= 0) && (o[u] = t[u]);
-    return o;
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0)
+        continue;
+      target[key] = source[key];
+    }
+    return target;
   }
-  function K(t, n) {
-    var o = Object.keys(t);
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
-      var i = Object.getOwnPropertySymbols(t);
-      n && (i = i.filter(function(u) {
-        return Object.getOwnPropertyDescriptor(t, u).enumerable;
-      })), o.push.apply(o, i);
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
     }
-    return o;
-  }
-  function R(t) {
-    for (var n = 1; n < arguments.length; n++) {
-      var o = arguments[n] != null ? arguments[n] : {};
-      n % 2 ? K(Object(o), !0).forEach(function(i) {
-        T(t, i, o[i]);
-      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(o)) : K(Object(o)).forEach(function(i) {
-        Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(o, i));
+    return keys;
+  }
+  function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty2(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
       });
     }
-    return t;
-  }
-  function Oe(t, n) {
-    return Ne(t) || xe(t, n) || Pe(t, n) || we();
-  }
-  function we() {
-    throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
-  }
-  function Pe(t, n) {
-    if (!!t) {
-      if (typeof t == "string")
-        return ae(t, n);
-      var o = Object.prototype.toString.call(t).slice(8, -1);
-      if (o === "Object" && t.constructor && (o = t.constructor.name), o === "Map" || o === "Set")
-        return Array.from(t);
-      if (o === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(o))
-        return ae(t, n);
+    return target;
+  }
+  function _slicedToArray2(arr, i) {
+    return _arrayWithHoles2(arr) || _iterableToArrayLimit2(arr, i) || _unsupportedIterableToArray2(arr, i) || _nonIterableRest2();
+  }
+  function _nonIterableRest2() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _unsupportedIterableToArray2(o, minLen) {
+    if (!o)
+      return;
+    if (typeof o === "string")
+      return _arrayLikeToArray2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+      n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+      return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _arrayLikeToArray2(o, minLen);
+  }
+  function _arrayLikeToArray2(arr, len) {
+    if (len == null || len > arr.length)
+      len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) {
+      arr2[i] = arr[i];
     }
-  }
-  function ae(t, n) {
-    (n == null || n > t.length) && (n = t.length);
-    for (var o = 0, i = new Array(n); o < n; o++)
-      i[o] = t[o];
-    return i;
-  }
-  function xe(t, n) {
-    var o = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
-    if (o != null) {
-      var i = [], u = !0, f = !1, c, y;
+    return arr2;
+  }
+  function _iterableToArrayLimit2(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+      return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i)
+          break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
       try {
-        for (o = o.call(t); !(u = (c = o.next()).done) && (i.push(c.value), !(n && i.length === n)); u = !0)
-          ;
-      } catch (g) {
-        f = !0, y = g;
+        if (!_n && _i["return"] != null)
+          _i["return"]();
       } finally {
-        try {
-          !u && o.return != null && o.return();
-        } finally {
-          if (f)
-            throw y;
-        }
+        if (_d)
+          throw _e;
       }
-      return i;
     }
+    return _arr;
   }
-  function Ne(t) {
-    if (Array.isArray(t))
-      return t;
+  function _arrayWithHoles2(arr) {
+    if (Array.isArray(arr))
+      return arr;
   }
-  function Me(t, n) {
-    if (!(t instanceof n))
+  function _classCallCheck2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
+    }
   }
-  function oe(t, n) {
-    for (var o = 0; o < n.length; o++) {
-      var i = n[o];
-      i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(t, i.key, i);
+  function _defineProperties2(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor)
+        descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
     }
   }
-  function Ce(t, n, o) {
-    return n && oe(t.prototype, n), o && oe(t, o), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+  function _createClass2(Constructor, protoProps, staticProps) {
+    if (protoProps)
+      _defineProperties2(Constructor.prototype, protoProps);
+    if (staticProps)
+      _defineProperties2(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", { writable: false });
+    return Constructor;
   }
-  function Ee(t, n) {
-    if (typeof n != "function" && n !== null)
+  function _inherits2(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
       throw new TypeError("Super expression must either be null or a function");
-    t.prototype = Object.create(n && n.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), n && J(t, n);
-  }
-  function J(t, n) {
-    return J = Object.setPrototypeOf || function(i, u) {
-      return i.__proto__ = u, i;
-    }, J(t, n);
-  }
-  function Te(t) {
-    var n = Ae();
-    return function() {
-      var i = X(t), u;
-      if (n) {
-        var f = X(this).constructor;
-        u = Reflect.construct(i, arguments, f);
-      } else
-        u = i.apply(this, arguments);
-      return Re(this, u);
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+    Object.defineProperty(subClass, "prototype", { writable: false });
+    if (superClass)
+      _setPrototypeOf2(subClass, superClass);
+  }
+  function _setPrototypeOf2(o, p) {
+    _setPrototypeOf2 = Object.setPrototypeOf || function _setPrototypeOf3(o2, p2) {
+      o2.__proto__ = p2;
+      return o2;
+    };
+    return _setPrototypeOf2(o, p);
+  }
+  function _createSuper2(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct2();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf2(Derived), result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf2(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn2(this, result);
     };
   }
-  function Re(t, n) {
-    if (n && (a(n) === "object" || typeof n == "function"))
-      return n;
-    if (n !== void 0)
+  function _possibleConstructorReturn2(self, call) {
+    if (call && (_typeof2(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
       throw new TypeError("Derived constructors may only return object or undefined");
-    return A(t);
+    }
+    return _assertThisInitialized2(self);
   }
-  function A(t) {
-    if (t === void 0)
+  function _assertThisInitialized2(self) {
+    if (self === void 0) {
       throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    return t;
-  }
-  function Ae() {
-    if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
-      return !1;
-    if (typeof Proxy == "function")
-      return !0;
+    }
+    return self;
+  }
+  function _isNativeReflectConstruct2() {
+    if (typeof Reflect === "undefined" || !Reflect.construct)
+      return false;
+    if (Reflect.construct.sham)
+      return false;
+    if (typeof Proxy === "function")
+      return true;
     try {
-      return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
-      })), !0;
-    } catch {
-      return !1;
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+      return true;
+    } catch (e) {
+      return false;
     }
   }
-  function X(t) {
-    return X = Object.setPrototypeOf ? Object.getPrototypeOf : function(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
-    }, X(t);
-  }
-  function T(t, n, o) {
-    return n in t ? Object.defineProperty(t, n, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : t[n] = o, t;
-  }
-  var Y = /* @__PURE__ */ function(t) {
-    Ee(o, t);
-    var n = Te(o);
-    function o(i) {
-      var u;
-      return Me(this, o), u = n.call(this, i), T(A(u), "onDragStart", function(f, c) {
-        (0, D.default)("Draggable: onDragStart: %j", c);
-        var y = u.props.onStart(f, (0, s.createDraggableData)(A(u), c));
-        if (y === !1)
-          return !1;
-        u.setState({
-          dragging: !0,
-          dragged: !0
+  function _getPrototypeOf2(o) {
+    _getPrototypeOf2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf3(o2) {
+      return o2.__proto__ || Object.getPrototypeOf(o2);
+    };
+    return _getPrototypeOf2(o);
+  }
+  function _defineProperty2(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var Draggable2 = /* @__PURE__ */ function(_React$Component) {
+    _inherits2(Draggable3, _React$Component);
+    var _super = _createSuper2(Draggable3);
+    function Draggable3(props) {
+      var _this;
+      _classCallCheck2(this, Draggable3);
+      _this = _super.call(this, props);
+      _defineProperty2(_assertThisInitialized2(_this), "onDragStart", function(e, coreData) {
+        (0, _log2.default)("Draggable: onDragStart: %j", coreData);
+        var shouldStart = _this.props.onStart(e, (0, _positionFns2.createDraggableData)(_assertThisInitialized2(_this), coreData));
+        if (shouldStart === false)
+          return false;
+        _this.setState({
+          dragging: true,
+          dragged: true
         });
-      }), T(A(u), "onDrag", function(f, c) {
-        if (!u.state.dragging)
-          return !1;
-        (0, D.default)("Draggable: onDrag: %j", c);
-        var y = (0, s.createDraggableData)(A(u), c), g = {
-          x: y.x,
-          y: y.y
+      });
+      _defineProperty2(_assertThisInitialized2(_this), "onDrag", function(e, coreData) {
+        if (!_this.state.dragging)
+          return false;
+        (0, _log2.default)("Draggable: onDrag: %j", coreData);
+        var uiData = (0, _positionFns2.createDraggableData)(_assertThisInitialized2(_this), coreData);
+        var newState = {
+          x: uiData.x,
+          y: uiData.y
         };
-        if (u.props.bounds) {
-          var q = g.x, U = g.y;
-          g.x += u.state.slackX, g.y += u.state.slackY;
-          var W = (0, s.getBoundPosition)(A(u), g.x, g.y), I = Oe(W, 2), Q = I[0], B = I[1];
-          g.x = Q, g.y = B, g.slackX = u.state.slackX + (q - g.x), g.slackY = u.state.slackY + (U - g.y), y.x = g.x, y.y = g.y, y.deltaX = g.x - u.state.x, y.deltaY = g.y - u.state.y;
+        if (_this.props.bounds) {
+          var x = newState.x, y = newState.y;
+          newState.x += _this.state.slackX;
+          newState.y += _this.state.slackY;
+          var _getBoundPosition = (0, _positionFns2.getBoundPosition)(_assertThisInitialized2(_this), newState.x, newState.y), _getBoundPosition2 = _slicedToArray2(_getBoundPosition, 2), newStateX = _getBoundPosition2[0], newStateY = _getBoundPosition2[1];
+          newState.x = newStateX;
+          newState.y = newStateY;
+          newState.slackX = _this.state.slackX + (x - newState.x);
+          newState.slackY = _this.state.slackY + (y - newState.y);
+          uiData.x = newState.x;
+          uiData.y = newState.y;
+          uiData.deltaX = newState.x - _this.state.x;
+          uiData.deltaY = newState.y - _this.state.y;
         }
-        var H = u.props.onDrag(f, y);
-        if (H === !1)
-          return !1;
-        u.setState(g);
-      }), T(A(u), "onDragStop", function(f, c) {
-        if (!u.state.dragging)
-          return !1;
-        var y = u.props.onStop(f, (0, s.createDraggableData)(A(u), c));
-        if (y === !1)
-          return !1;
-        (0, D.default)("Draggable: onDragStop: %j", c);
-        var g = {
-          dragging: !1,
+        var shouldUpdate = _this.props.onDrag(e, uiData);
+        if (shouldUpdate === false)
+          return false;
+        _this.setState(newState);
+      });
+      _defineProperty2(_assertThisInitialized2(_this), "onDragStop", function(e, coreData) {
+        if (!_this.state.dragging)
+          return false;
+        var shouldContinue = _this.props.onStop(e, (0, _positionFns2.createDraggableData)(_assertThisInitialized2(_this), coreData));
+        if (shouldContinue === false)
+          return false;
+        (0, _log2.default)("Draggable: onDragStop: %j", coreData);
+        var newState = {
+          dragging: false,
           slackX: 0,
           slackY: 0
-        }, q = Boolean(u.props.position);
-        if (q) {
-          var U = u.props.position, W = U.x, I = U.y;
-          g.x = W, g.y = I;
+        };
+        var controlled = Boolean(_this.props.position);
+        if (controlled) {
+          var _this$props$position = _this.props.position, x = _this$props$position.x, y = _this$props$position.y;
+          newState.x = x;
+          newState.y = y;
         }
-        u.setState(g);
-      }), u.state = {
-        dragging: !1,
-        dragged: !1,
-        x: i.position ? i.position.x : i.defaultPosition.x,
-        y: i.position ? i.position.y : i.defaultPosition.y,
-        prevPropsPosition: R({}, i.position),
+        _this.setState(newState);
+      });
+      _this.state = {
+        dragging: false,
+        dragged: false,
+        x: props.position ? props.position.x : props.defaultPosition.x,
+        y: props.position ? props.position.y : props.defaultPosition.y,
+        prevPropsPosition: _objectSpread({}, props.position),
         slackX: 0,
         slackY: 0,
-        isElementSVG: !1
-      }, i.position && !(i.onDrag || i.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."), u;
+        isElementSVG: false
+      };
+      if (props.position && !(props.onDrag || props.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.");
+      }
+      return _this;
     }
-    return Ce(o, [{
+    _createClass2(Draggable3, [{
       key: "componentDidMount",
-      value: function() {
-        typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
-          isElementSVG: !0
-        });
+      value: function componentDidMount() {
+        if (typeof window.SVGElement !== "undefined" && this.findDOMNode() instanceof window.SVGElement) {
+          this.setState({
+            isElementSVG: true
+          });
+        }
       }
     }, {
       key: "componentWillUnmount",
-      value: function() {
+      value: function componentWillUnmount() {
         this.setState({
-          dragging: !1
+          dragging: false
         });
       }
     }, {
       key: "findDOMNode",
-      value: function() {
-        var u, f, c;
-        return (u = (f = this.props) === null || f === void 0 || (c = f.nodeRef) === null || c === void 0 ? void 0 : c.current) !== null && u !== void 0 ? u : d.default.findDOMNode(this);
+      value: function findDOMNode() {
+        var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;
+        return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom2.default.findDOMNode(this);
       }
     }, {
       key: "render",
-      value: function() {
-        var u, f = this.props;
-        f.axis, f.bounds;
-        var c = f.children, y = f.defaultPosition, g = f.defaultClassName, q = f.defaultClassNameDragging, U = f.defaultClassNameDragged, W = f.position, I = f.positionOffset;
-        f.scale;
-        var Q = $(f, O), B = {}, H = null, je = Boolean(W), ie = !je || this.state.dragging, ue = W || y, le = {
-          x: (0, s.canDragX)(this) && ie ? this.state.x : ue.x,
-          y: (0, s.canDragY)(this) && ie ? this.state.y : ue.y
+      value: function render() {
+        var _clsx;
+        var _this$props2 = this.props;
+        _this$props2.axis;
+        _this$props2.bounds;
+        var children = _this$props2.children, defaultPosition = _this$props2.defaultPosition, defaultClassName = _this$props2.defaultClassName, defaultClassNameDragging = _this$props2.defaultClassNameDragging, defaultClassNameDragged = _this$props2.defaultClassNameDragged, position = _this$props2.position, positionOffset = _this$props2.positionOffset;
+        _this$props2.scale;
+        var draggableCoreProps = _objectWithoutProperties(_this$props2, _excluded);
+        var style = {};
+        var svgTransform = null;
+        var controlled = Boolean(position);
+        var draggable = !controlled || this.state.dragging;
+        var validPosition = position || defaultPosition;
+        var transformOpts = {
+          x: (0, _positionFns2.canDragX)(this) && draggable ? this.state.x : validPosition.x,
+          y: (0, _positionFns2.canDragY)(this) && draggable ? this.state.y : validPosition.y
         };
-        this.state.isElementSVG ? H = (0, h.createSVGTransform)(le, I) : B = (0, h.createCSSTransform)(le, I);
-        var ke = (0, p.default)(c.props.className || "", g, (u = {}, T(u, q, this.state.dragging), T(u, U, this.state.dragged), u));
-        return /* @__PURE__ */ l.createElement(m.default, x({}, Q, {
+        if (this.state.isElementSVG) {
+          svgTransform = (0, _domFns2.createSVGTransform)(transformOpts, positionOffset);
+        } else {
+          style = (0, _domFns2.createCSSTransform)(transformOpts, positionOffset);
+        }
+        var className = (0, _clsx2.default)(children.props.className || "", defaultClassName, (_clsx = {}, _defineProperty2(_clsx, defaultClassNameDragging, this.state.dragging), _defineProperty2(_clsx, defaultClassNameDragged, this.state.dragged), _clsx));
+        return /* @__PURE__ */ React2.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {
           onStart: this.onDragStart,
           onDrag: this.onDrag,
           onStop: this.onDragStop
-        }), /* @__PURE__ */ l.cloneElement(l.Children.only(c), {
-          className: ke,
-          style: R(R({}, c.props.style), B),
-          transform: H
+        }), /* @__PURE__ */ React2.cloneElement(React2.Children.only(children), {
+          className,
+          style: _objectSpread(_objectSpread({}, children.props.style), style),
+          transform: svgTransform
         }));
       }
     }], [{
       key: "getDerivedStateFromProps",
-      value: function(u, f) {
-        var c = u.position, y = f.prevPropsPosition;
-        return c && (!y || c.x !== y.x || c.y !== y.y) ? ((0, D.default)("Draggable: getDerivedStateFromProps %j", {
-          position: c,
-          prevPropsPosition: y
-        }), {
-          x: c.x,
-          y: c.y,
-          prevPropsPosition: R({}, c)
-        }) : null;
+      value: function getDerivedStateFromProps(_ref, _ref2) {
+        var position = _ref.position;
+        var prevPropsPosition = _ref2.prevPropsPosition;
+        if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {
+          (0, _log2.default)("Draggable: getDerivedStateFromProps %j", {
+            position,
+            prevPropsPosition
+          });
+          return {
+            x: position.x,
+            y: position.y,
+            prevPropsPosition: _objectSpread({}, position)
+          };
+        }
+        return null;
       }
-    }]), o;
-  }(l.Component);
-  r.default = Y, T(Y, "displayName", "Draggable"), T(Y, "propTypes", R(R({}, m.default.propTypes), {}, {
-    axis: e.default.oneOf(["both", "x", "y", "none"]),
-    bounds: e.default.oneOfType([e.default.shape({
-      left: e.default.number,
-      right: e.default.number,
-      top: e.default.number,
-      bottom: e.default.number
-    }), e.default.string, e.default.oneOf([!1])]),
-    defaultClassName: e.default.string,
-    defaultClassNameDragging: e.default.string,
-    defaultClassNameDragged: e.default.string,
-    defaultPosition: e.default.shape({
-      x: e.default.number,
-      y: e.default.number
+    }]);
+    return Draggable3;
+  }(React2.Component);
+  exports.default = Draggable2;
+  _defineProperty2(Draggable2, "displayName", "Draggable");
+  _defineProperty2(Draggable2, "propTypes", _objectSpread(_objectSpread({}, _DraggableCore.default.propTypes), {}, {
+    axis: _propTypes2.default.oneOf(["both", "x", "y", "none"]),
+    bounds: _propTypes2.default.oneOfType([_propTypes2.default.shape({
+      left: _propTypes2.default.number,
+      right: _propTypes2.default.number,
+      top: _propTypes2.default.number,
+      bottom: _propTypes2.default.number
+    }), _propTypes2.default.string, _propTypes2.default.oneOf([false])]),
+    defaultClassName: _propTypes2.default.string,
+    defaultClassNameDragging: _propTypes2.default.string,
+    defaultClassNameDragged: _propTypes2.default.string,
+    defaultPosition: _propTypes2.default.shape({
+      x: _propTypes2.default.number,
+      y: _propTypes2.default.number
     }),
-    positionOffset: e.default.shape({
-      x: e.default.oneOfType([e.default.number, e.default.string]),
-      y: e.default.oneOfType([e.default.number, e.default.string])
+    positionOffset: _propTypes2.default.shape({
+      x: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string]),
+      y: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string])
     }),
-    position: e.default.shape({
-      x: e.default.number,
-      y: e.default.number
+    position: _propTypes2.default.shape({
+      x: _propTypes2.default.number,
+      y: _propTypes2.default.number
     }),
-    className: v.dontSetMe,
-    style: v.dontSetMe,
-    transform: v.dontSetMe
-  })), T(Y, "defaultProps", R(R({}, m.default.defaultProps), {}, {
+    className: _shims2.dontSetMe,
+    style: _shims2.dontSetMe,
+    transform: _shims2.dontSetMe
+  }));
+  _defineProperty2(Draggable2, "defaultProps", _objectSpread(_objectSpread({}, _DraggableCore.default.defaultProps), {}, {
     axis: "both",
-    bounds: !1,
+    bounds: false,
     defaultClassName: "react-draggable",
     defaultClassNameDragging: "react-draggable-dragging",
     defaultClassNameDragged: "react-draggable-dragged",
@@ -704,11 +951,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     },
     scale: 1
   }));
-})(be);
-var _e = be, Se = _e.default, ze = _e.DraggableCore;
-re.exports = Se;
-re.exports.default = Se;
-re.exports.DraggableCore = ze;
+})(Draggable$1);
+var _require = Draggable$1, Draggable = _require.default, DraggableCore = _require.DraggableCore;
+cjs.exports = Draggable;
+cjs.exports.default = Draggable;
+cjs.exports.DraggableCore = DraggableCore;
 export {
-  re as c
+  cjs as c
 };