@bynder/compact-view 5.2.3 → 5.2.4

package/Draggable.js

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

package/Draggable2.js

@@ -0,0 +1,4 @@
+var a = {};
+export {
+  a as __exports
+};

package/DraggableCore.js

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

package/DraggableCore2.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};