@m4l/components 0.1.11 → 0.1.13

package/react-draggable.20e95c61.js

@@ -0,0 +1,714 @@
+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);
+}
+Object.defineProperty(L, "__esModule", {
+  value: !0
+});
+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 };
+}
+function De(r) {
+  if (typeof WeakMap != "function")
+    return null;
+  var a = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap();
+  return (De = function(d) {
+    return d ? l : a;
+  })(r);
+}
+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];
+    }
+  return e.default = r, l && l.set(r, e), e;
+}
+function fe(r, a) {
+  return Xe(r) || Fe(r, a) || qe(r, a) || $e();
+}
+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 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 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 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;
+    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;
+    } finally {
+      try {
+        !d && l.return != null && l.return();
+      } finally {
+        if (p)
+          throw s;
+      }
+    }
+    return e;
+  }
+}
+function Xe(r) {
+  if (Array.isArray(r))
+    return r;
+}
+function Ye(r, a) {
+  if (!(r instanceof a))
+    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 Be(r, a, l) {
+  return a && ce(r.prototype, a), l && ce(r, l), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function He(r, a) {
+  if (typeof a != "function" && a !== 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);
+}
+function te(r, a) {
+  return te = Object.setPrototypeOf || function(e, d) {
+    return e.__proto__ = d, e;
+  }, te(r, a);
+}
+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 Ge(r, a) {
+  if (a && (V(a) === "object" || typeof a == "function"))
+    return a;
+  if (a !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return S(r);
+}
+function S(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function Le() {
+  if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+    return !1;
+  if (typeof Proxy == "function")
+    return !0;
+  try {
+    return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    })), !0;
+  } catch {
+    return !1;
+  }
+}
+function G(r) {
+  return G = Object.setPrototypeOf ? Object.getPrototypeOf : function(l) {
+    return l.__proto__ || Object.getPrototypeOf(l);
+  }, G(r);
+}
+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;
+}
+var N = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    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,
+      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)
+        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);
+          }
+          return;
+        }
+        e.setState({
+          lastX: m,
+          lastY: D
+        });
+      }
+    }), 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));
+        }
+      }
+    }), 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
+      });
+    }
+  }, {
+    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);
+      }
+    }
+  }, {
+    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);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      return /* @__PURE__ */ Z.cloneElement(Z.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)
+      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
+});
+P(z, "defaultProps", {
+  allowAnyClick: !1,
+  disabled: !1,
+  enableUserSelectHack: !0,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  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;
+    }
+  }), 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")
+      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];
+      }
+    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]);
+      }
+      return t;
+    }, x.apply(this, arguments);
+  }
+  function $(t, n) {
+    if (t == null)
+      return {};
+    var o = C(t, n), i, u;
+    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]));
+    }
+    return o;
+  }
+  function C(t, n) {
+    if (t == 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;
+  }
+  function K(t, n) {
+    var o = Object.keys(t);
+    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);
+    }
+    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 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);
+    }
+  }
+  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;
+      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;
+      } finally {
+        try {
+          !u && o.return != null && o.return();
+        } finally {
+          if (f)
+            throw y;
+        }
+      }
+      return i;
+    }
+  }
+  function Ne(t) {
+    if (Array.isArray(t))
+      return t;
+  }
+  function Me(t, n) {
+    if (!(t instanceof n))
+      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 Ce(t, n, o) {
+    return n && oe(t.prototype, n), o && oe(t, o), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+  }
+  function Ee(t, n) {
+    if (typeof n != "function" && n !== 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);
+    };
+  }
+  function Re(t, n) {
+    if (n && (a(n) === "object" || typeof n == "function"))
+      return n;
+    if (n !== void 0)
+      throw new TypeError("Derived constructors may only return object or undefined");
+    return A(t);
+  }
+  function A(t) {
+    if (t === 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;
+    try {
+      return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      })), !0;
+    } catch {
+      return !1;
+    }
+  }
+  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
+        });
+      }), 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
+        };
+        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;
+        }
+        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,
+          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;
+        }
+        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),
+        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;
+    }
+    return Ce(o, [{
+      key: "componentDidMount",
+      value: function() {
+        typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
+          isElementSVG: !0
+        });
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function() {
+        this.setState({
+          dragging: !1
+        });
+      }
+    }, {
+      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);
+      }
+    }, {
+      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
+        };
+        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, {
+          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
+        }));
+      }
+    }], [{
+      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;
+      }
+    }]), 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
+    }),
+    positionOffset: e.default.shape({
+      x: e.default.oneOfType([e.default.number, e.default.string]),
+      y: e.default.oneOfType([e.default.number, e.default.string])
+    }),
+    position: e.default.shape({
+      x: e.default.number,
+      y: e.default.number
+    }),
+    className: v.dontSetMe,
+    style: v.dontSetMe,
+    transform: v.dontSetMe
+  })), T(Y, "defaultProps", R(R({}, m.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);
+var _e = be, Se = _e.default, ze = _e.DraggableCore;
+re.exports = Se;
+re.exports.default = Se;
+re.exports.DraggableCore = ze;
+export {
+  re as c
+};