bitz-react-admin-ui 2.7.4 → 2.7.5

package/dist/node_modules/react-dom/client.mjs

@@ -0,0 +1,26 @@
+import { __exports as e } from "../../_virtual/client.mjs";
+import i from "react-dom";
+var t = i;
+if (process.env.NODE_ENV === "production")
+  e.createRoot = t.createRoot, e.hydrateRoot = t.hydrateRoot;
+else {
+  var o = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  e.createRoot = function(r, n) {
+    o.usingClientEntryPoint = !0;
+    try {
+      return t.createRoot(r, n);
+    } finally {
+      o.usingClientEntryPoint = !1;
+    }
+  }, e.hydrateRoot = function(r, n, a) {
+    o.usingClientEntryPoint = !0;
+    try {
+      return t.hydrateRoot(r, n, a);
+    } finally {
+      o.usingClientEntryPoint = !1;
+    }
+  };
+}
+export {
+  e as default
+};

package/dist/node_modules/react-draggable/build/cjs/Draggable.mjs

@@ -0,0 +1,343 @@
+import { __exports as F } from "../../../../_virtual/Draggable.mjs";
+import G from "react";
+import { p as V } from "../../../prop-types/index.mjs";
+import W from "react-dom";
+import $ from "../../../../_virtual/clsx.m.mjs";
+import "./utils/domFns.mjs";
+import "./utils/positionFns.mjs";
+import "./utils/shims.mjs";
+import "./DraggableCore.mjs";
+import "./utils/log.mjs";
+import { __exports as q } from "../../../../_virtual/domFns.mjs";
+import { __exports as B } from "../../../../_virtual/positionFns.mjs";
+import { __exports as U } from "../../../../_virtual/shims.mjs";
+import { __exports as A } from "../../../../_virtual/DraggableCore.mjs";
+import { __exports as I } from "../../../../_virtual/log.mjs";
+(function(p) {
+  Object.defineProperty(p, "__esModule", {
+    value: !0
+  }), Object.defineProperty(p, "DraggableCore", {
+    enumerable: !0,
+    get: function() {
+      return m.default;
+    }
+  }), p.default = void 0;
+  var c = E(G), n = d(V), M = d(W), T = d($), S = q, l = B, v = U, m = d(A), h = d(I);
+  function d(t) {
+    return t && t.__esModule ? t : { default: t };
+  }
+  function _(t) {
+    if (typeof WeakMap != "function")
+      return null;
+    var e = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+    return (_ = function(a) {
+      return a ? r : e;
+    })(t);
+  }
+  function E(t, e) {
+    if (!e && t && t.__esModule)
+      return t;
+    if (t === null || typeof t != "object" && typeof t != "function")
+      return { default: t };
+    var r = _(e);
+    if (r && r.has(t))
+      return r.get(t);
+    var a = {}, o = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var s in t)
+      if (s !== "default" && Object.prototype.hasOwnProperty.call(t, s)) {
+        var i = o ? Object.getOwnPropertyDescriptor(t, s) : null;
+        i && (i.get || i.set) ? Object.defineProperty(a, s, i) : a[s] = t[s];
+      }
+    return a.default = t, r && r.set(t, a), a;
+  }
+  function b() {
+    return b = Object.assign ? Object.assign.bind() : function(t) {
+      for (var e = 1; e < arguments.length; e++) {
+        var r = arguments[e];
+        for (var a in r)
+          Object.prototype.hasOwnProperty.call(r, a) && (t[a] = r[a]);
+      }
+      return t;
+    }, b.apply(this, arguments);
+  }
+  function f(t, e, r) {
+    return e = X(e), e in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+  }
+  function X(t) {
+    var e = Y(t, "string");
+    return typeof e == "symbol" ? e : String(e);
+  }
+  function Y(t, e) {
+    if (typeof t != "object" || t === null)
+      return t;
+    var r = t[Symbol.toPrimitive];
+    if (r !== void 0) {
+      var a = r.call(t, e || "default");
+      if (typeof a != "object")
+        return a;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (e === "string" ? String : Number)(t);
+  }
+  class y extends c.Component {
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps(e, r) {
+      let {
+        position: a
+      } = e, {
+        prevPropsPosition: o
+      } = r;
+      return a && (!o || a.x !== o.x || a.y !== o.y) ? ((0, h.default)("Draggable: getDerivedStateFromProps %j", {
+        position: a,
+        prevPropsPosition: o
+      }), {
+        x: a.x,
+        y: a.y,
+        prevPropsPosition: {
+          ...a
+        }
+      }) : null;
+    }
+    constructor(e) {
+      super(e), f(this, "onDragStart", (r, a) => {
+        if ((0, h.default)("Draggable: onDragStart: %j", a), this.props.onStart(r, (0, l.createDraggableData)(this, a)) === !1)
+          return !1;
+        this.setState({
+          dragging: !0,
+          dragged: !0
+        });
+      }), f(this, "onDrag", (r, a) => {
+        if (!this.state.dragging)
+          return !1;
+        (0, h.default)("Draggable: onDrag: %j", a);
+        const o = (0, l.createDraggableData)(this, a), s = {
+          x: o.x,
+          y: o.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x: g,
+            y: u
+          } = s;
+          s.x += this.state.slackX, s.y += this.state.slackY;
+          const [D, x] = (0, l.getBoundPosition)(this, s.x, s.y);
+          s.x = D, s.y = x, s.slackX = this.state.slackX + (g - s.x), s.slackY = this.state.slackY + (u - s.y), o.x = s.x, o.y = s.y, o.deltaX = s.x - this.state.x, o.deltaY = s.y - this.state.y;
+        }
+        if (this.props.onDrag(r, o) === !1)
+          return !1;
+        this.setState(s);
+      }), f(this, "onDragStop", (r, a) => {
+        if (!this.state.dragging || this.props.onStop(r, (0, l.createDraggableData)(this, a)) === !1)
+          return !1;
+        (0, h.default)("Draggable: onDragStop: %j", a);
+        const s = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const {
+            x: g,
+            y: u
+          } = this.props.position;
+          s.x = g, s.y = u;
+        }
+        this.setState(s);
+      }), 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: e.position ? e.position.x : e.defaultPosition.x,
+        y: e.position ? e.position.y : e.defaultPosition.y,
+        prevPropsPosition: {
+          ...e.position
+        },
+        // Used for compensating for out-of-bounds drags
+        slackX: 0,
+        slackY: 0,
+        // Can only determine if SVG after mounting
+        isElementSVG: !1
+      }, e.position && !(e.onDrag || e.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 e, r;
+      return (e = (r = this.props) === null || r === void 0 || (r = r.nodeRef) === null || r === void 0 ? void 0 : r.current) !== null && e !== void 0 ? e : M.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis: e,
+        bounds: r,
+        children: a,
+        defaultPosition: o,
+        defaultClassName: s,
+        defaultClassNameDragging: i,
+        defaultClassNameDragged: g,
+        position: u,
+        positionOffset: D,
+        scale: x,
+        ...R
+      } = this.props;
+      let P = {}, O = null;
+      const w = !!!u || this.state.dragging, C = u || o, N = {
+        // Set left if horizontal drag is enabled
+        x: (0, l.canDragX)(this) && w ? this.state.x : C.x,
+        // Set top if vertical drag is enabled
+        y: (0, l.canDragY)(this) && w ? this.state.y : C.y
+      };
+      this.state.isElementSVG ? O = (0, S.createSVGTransform)(N, D) : P = (0, S.createCSSTransform)(N, D);
+      const k = (0, T.default)(a.props.className || "", s, {
+        [i]: this.state.dragging,
+        [g]: this.state.dragged
+      });
+      return /* @__PURE__ */ c.createElement(m.default, b({}, R, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ c.cloneElement(c.Children.only(a), {
+        className: k,
+        style: {
+          ...a.props.style,
+          ...P
+        },
+        transform: O
+      }));
+    }
+  }
+  p.default = y, f(y, "displayName", "Draggable"), f(y, "propTypes", {
+    // Accepts all props <DraggableCore> accepts.
+    ...m.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: v.dontSetMe,
+    style: v.dontSetMe,
+    transform: v.dontSetMe
+  }), f(y, "defaultProps", {
+    ...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
+  });
+})(F);

package/dist/node_modules/react-draggable/build/cjs/DraggableCore.mjs

@@ -0,0 +1,324 @@
+import { __exports as y } from "../../../../_virtual/DraggableCore.mjs";
+import M from "react";
+import { p as b } from "../../../prop-types/index.mjs";
+import E from "react-dom";
+import "./utils/domFns.mjs";
+import "./utils/positionFns.mjs";
+import "./utils/shims.mjs";
+import "./utils/log.mjs";
+import { __exports as N } from "../../../../_virtual/domFns.mjs";
+import { __exports as C } from "../../../../_virtual/shims.mjs";
+import { __exports as P } from "../../../../_virtual/log.mjs";
+import { __exports as O } from "../../../../_virtual/positionFns.mjs";
+Object.defineProperty(y, "__esModule", {
+  value: !0
+});
+y.default = void 0;
+var D = U(M), u = w(b), T = w(E), n = N, c = O, S = C, m = w(P);
+function w(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function _(e) {
+  if (typeof WeakMap != "function")
+    return null;
+  var t = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
+  return (_ = function(r) {
+    return r ? o : t;
+  })(e);
+}
+function U(e, t) {
+  if (!t && e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var o = _(t);
+  if (o && o.has(e))
+    return o.get(e);
+  var r = {}, d = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var s in e)
+    if (s !== "default" && Object.prototype.hasOwnProperty.call(e, s)) {
+      var f = d ? Object.getOwnPropertyDescriptor(e, s) : null;
+      f && (f.get || f.set) ? Object.defineProperty(r, s, f) : r[s] = e[s];
+    }
+  return r.default = e, o && o.set(e, r), r;
+}
+function a(e, t, o) {
+  return t = R(t), t in e ? Object.defineProperty(e, t, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = o, e;
+}
+function R(e) {
+  var t = x(e, "string");
+  return typeof t == "symbol" ? t : String(t);
+}
+function x(e, t) {
+  if (typeof e != "object" || e === null)
+    return e;
+  var o = e[Symbol.toPrimitive];
+  if (o !== void 0) {
+    var r = o.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 h = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    move: "mousemove",
+    stop: "mouseup"
+  }
+};
+let p = h.mouse;
+class v extends D.Component {
+  constructor() {
+    super(...arguments), a(this, "dragging", !1), a(this, "lastX", NaN), a(this, "lastY", NaN), a(this, "touchIdentifier", null), a(this, "mounted", !1), a(this, "handleDragStart", (t) => {
+      if (this.props.onMouseDown(t), !this.props.allowAnyClick && typeof t.button == "number" && t.button !== 0)
+        return !1;
+      const o = this.findDOMNode();
+      if (!o || !o.ownerDocument || !o.ownerDocument.body)
+        throw new Error("<DraggableCore> not mounted on DragStart!");
+      const {
+        ownerDocument: r
+      } = o;
+      if (this.props.disabled || !(t.target instanceof r.defaultView.Node) || this.props.handle && !(0, n.matchesSelectorAndParentsTo)(t.target, this.props.handle, o) || this.props.cancel && (0, n.matchesSelectorAndParentsTo)(t.target, this.props.cancel, o))
+        return;
+      t.type === "touchstart" && t.preventDefault();
+      const d = (0, n.getTouchIdentifier)(t);
+      this.touchIdentifier = d;
+      const s = (0, c.getControlPosition)(t, d, this);
+      if (s == null)
+        return;
+      const {
+        x: f,
+        y: i
+      } = s, l = (0, c.createCoreData)(this, f, i);
+      (0, m.default)("DraggableCore: handleDragStart: %j", l), (0, m.default)("calling", this.props.onStart), !(this.props.onStart(t, l) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && (0, n.addUserSelectStyles)(r), this.dragging = !0, this.lastX = f, this.lastY = i, (0, n.addEvent)(r, p.move, this.handleDrag), (0, n.addEvent)(r, p.stop, this.handleDragStop));
+    }), a(this, "handleDrag", (t) => {
+      const o = (0, c.getControlPosition)(t, this.touchIdentifier, this);
+      if (o == null)
+        return;
+      let {
+        x: r,
+        y: d
+      } = o;
+      if (Array.isArray(this.props.grid)) {
+        let i = r - this.lastX, l = d - this.lastY;
+        if ([i, l] = (0, c.snapToGrid)(this.props.grid, i, l), !i && !l)
+          return;
+        r = this.lastX + i, d = this.lastY + l;
+      }
+      const s = (0, c.createCoreData)(this, r, d);
+      if ((0, m.default)("DraggableCore: handleDrag: %j", s), this.props.onDrag(t, s) === !1 || this.mounted === !1) {
+        try {
+          this.handleDragStop(new MouseEvent("mouseup"));
+        } catch {
+          const l = document.createEvent("MouseEvents");
+          l.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(l);
+        }
+        return;
+      }
+      this.lastX = r, this.lastY = d;
+    }), a(this, "handleDragStop", (t) => {
+      if (!this.dragging)
+        return;
+      const o = (0, c.getControlPosition)(t, this.touchIdentifier, this);
+      if (o == null)
+        return;
+      let {
+        x: r,
+        y: d
+      } = o;
+      if (Array.isArray(this.props.grid)) {
+        let l = r - this.lastX || 0, g = d - this.lastY || 0;
+        [l, g] = (0, c.snapToGrid)(this.props.grid, l, g), r = this.lastX + l, d = this.lastY + g;
+      }
+      const s = (0, c.createCoreData)(this, r, d);
+      if (this.props.onStop(t, s) === !1 || this.mounted === !1)
+        return !1;
+      const i = this.findDOMNode();
+      i && this.props.enableUserSelectHack && (0, n.removeUserSelectStyles)(i.ownerDocument), (0, m.default)("DraggableCore: handleDragStop: %j", s), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, i && ((0, m.default)("DraggableCore: Removing handlers"), (0, n.removeEvent)(i.ownerDocument, p.move, this.handleDrag), (0, n.removeEvent)(i.ownerDocument, p.stop, this.handleDragStop));
+    }), a(this, "onMouseDown", (t) => (p = h.mouse, this.handleDragStart(t))), a(this, "onMouseUp", (t) => (p = h.mouse, this.handleDragStop(t))), a(this, "onTouchStart", (t) => (p = h.touch, this.handleDragStart(t))), a(this, "onTouchEnd", (t) => (p = h.touch, this.handleDragStop(t)));
+  }
+  componentDidMount() {
+    this.mounted = !0;
+    const t = this.findDOMNode();
+    t && (0, n.addEvent)(t, h.touch.start, this.onTouchStart, {
+      passive: !1
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+    const t = this.findDOMNode();
+    if (t) {
+      const {
+        ownerDocument: o
+      } = t;
+      (0, n.removeEvent)(o, h.mouse.move, this.handleDrag), (0, n.removeEvent)(o, h.touch.move, this.handleDrag), (0, n.removeEvent)(o, h.mouse.stop, this.handleDragStop), (0, n.removeEvent)(o, h.touch.stop, this.handleDragStop), (0, n.removeEvent)(t, h.touch.start, this.onTouchStart, {
+        passive: !1
+      }), this.props.enableUserSelectHack && (0, n.removeUserSelectStyles)(o);
+    }
+  }
+  // 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, o;
+    return (t = this.props) !== null && t !== void 0 && t.nodeRef ? (o = this.props) === null || o === void 0 || (o = o.nodeRef) === null || o === void 0 ? void 0 : o.current : T.default.findDOMNode(this);
+  }
+  render() {
+    return /* @__PURE__ */ D.cloneElement(D.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
+    });
+  }
+}
+y.default = v;
+a(v, "displayName", "DraggableCore");
+a(v, "propTypes", {
+  /**
+   * `allowAnyClick` allows dragging using any mouse button.
+   * By default, we only accept the left button.
+   *
+   * Defaults to `false`.
+   */
+  allowAnyClick: u.default.bool,
+  children: u.default.node.isRequired,
+  /**
+   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+   * with the exception of `onMouseDown`, will not fire.
+   */
+  disabled: u.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: u.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: u.default.arrayOf(u.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: u.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: u.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: u.default.object,
+  /**
+   * Called when dragging starts.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onStart: u.default.func,
+  /**
+   * Called while dragging.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onDrag: u.default.func,
+  /**
+   * Called when dragging stops.
+   * If this function returns the boolean false, the drag will remain active.
+   */
+  onStop: u.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: u.default.func,
+  /**
+   * `scale`, if set, applies scaling while dragging an element
+   */
+  scale: u.default.number,
+  /**
+   * These properties should be defined on the child, not here.
+   */
+  className: S.dontSetMe,
+  style: S.dontSetMe,
+  transform: S.dontSetMe
+});
+a(v, "defaultProps", {
+  allowAnyClick: !1,
+  // by default only accept left click
+  disabled: !1,
+  enableUserSelectHack: !0,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  scale: 1
+});