bitz-react-admin-ui 2.2.7 → 2.2.8

package/dist/node_modules/.store/react-draggable@4.4.6/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@15.8.1/node_modules/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
+});

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/cjs.mjs

@@ -0,0 +1,14 @@
+import { __module as r } from "../../../../../../../_virtual/cjs.mjs";
+import "./Draggable.mjs";
+import { __exports as e } from "../../../../../../../_virtual/Draggable.mjs";
+const {
+  default: o,
+  DraggableCore: a
+} = e;
+r.exports = o;
+r.exports.default = o;
+r.exports.DraggableCore = a;
+var g = r.exports;
+export {
+  g as c
+};

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/utils/domFns.mjs

@@ -0,0 +1,174 @@
+import { __exports as a } from "../../../../../../../../_virtual/domFns.mjs";
+import "./shims.mjs";
+import "./getPrefix.mjs";
+import { __exports as y } from "../../../../../../../../_virtual/shims.mjs";
+import { __exports as S } from "../../../../../../../../_virtual/getPrefix.mjs";
+Object.defineProperty(a, "__esModule", {
+  value: !0
+});
+a.addClassName = g;
+a.addEvent = w;
+a.addUserSelectStyles = B;
+a.createCSSTransform = b;
+a.createSVGTransform = M;
+a.getTouch = P;
+a.getTouchIdentifier = R;
+a.getTranslation = u;
+a.innerHeight = _;
+a.innerWidth = x;
+a.matchesSelector = h;
+a.matchesSelectorAndParentsTo = v;
+a.offsetXYFromParent = L;
+a.outerHeight = W;
+a.outerWidth = C;
+a.removeClassName = m;
+a.removeEvent = E;
+a.removeUserSelectStyles = D;
+var i = y, d = T(S);
+function f(e) {
+  if (typeof WeakMap != "function")
+    return null;
+  var t = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+  return (f = function(r) {
+    return r ? n : t;
+  })(e);
+}
+function T(e, t) {
+  if (!t && e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var n = f(t);
+  if (n && n.has(e))
+    return n.get(e);
+  var r = {}, o = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var c in e)
+    if (c !== "default" && Object.prototype.hasOwnProperty.call(e, c)) {
+      var s = o ? Object.getOwnPropertyDescriptor(e, c) : null;
+      s && (s.get || s.set) ? Object.defineProperty(r, c, s) : r[c] = e[c];
+    }
+  return r.default = e, n && n.set(e, r), r;
+}
+let l = "";
+function h(e, t) {
+  return l || (l = (0, i.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(n) {
+    return (0, i.isFunction)(e[n]);
+  })), (0, i.isFunction)(e[l]) ? e[l](t) : !1;
+}
+function v(e, t, n) {
+  let r = e;
+  do {
+    if (h(r, t))
+      return !0;
+    if (r === n)
+      return !1;
+    r = r.parentNode;
+  } while (r);
+  return !1;
+}
+function w(e, t, n, r) {
+  if (!e)
+    return;
+  const o = {
+    capture: !0,
+    ...r
+  };
+  e.addEventListener ? e.addEventListener(t, n, o) : e.attachEvent ? e.attachEvent("on" + t, n) : e["on" + t] = n;
+}
+function E(e, t, n, r) {
+  if (!e)
+    return;
+  const o = {
+    capture: !0,
+    ...r
+  };
+  e.removeEventListener ? e.removeEventListener(t, n, o) : e.detachEvent ? e.detachEvent("on" + t, n) : e["on" + t] = null;
+}
+function W(e) {
+  let t = e.clientHeight;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, i.int)(n.borderTopWidth), t += (0, i.int)(n.borderBottomWidth), t;
+}
+function C(e) {
+  let t = e.clientWidth;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t += (0, i.int)(n.borderLeftWidth), t += (0, i.int)(n.borderRightWidth), t;
+}
+function _(e) {
+  let t = e.clientHeight;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, i.int)(n.paddingTop), t -= (0, i.int)(n.paddingBottom), t;
+}
+function x(e) {
+  let t = e.clientWidth;
+  const n = e.ownerDocument.defaultView.getComputedStyle(e);
+  return t -= (0, i.int)(n.paddingLeft), t -= (0, i.int)(n.paddingRight), t;
+}
+function L(e, t, n) {
+  const o = t === t.ownerDocument.body ? {
+    left: 0,
+    top: 0
+  } : t.getBoundingClientRect(), c = (e.clientX + t.scrollLeft - o.left) / n, s = (e.clientY + t.scrollTop - o.top) / n;
+  return {
+    x: c,
+    y: s
+  };
+}
+function b(e, t) {
+  const n = u(e, t, "px");
+  return {
+    [(0, d.browserPrefixToKey)("transform", d.default)]: n
+  };
+}
+function M(e, t) {
+  return u(e, t, "");
+}
+function u(e, t, n) {
+  let {
+    x: r,
+    y: o
+  } = e, c = "translate(".concat(r).concat(n, ",").concat(o).concat(n, ")");
+  if (t) {
+    const s = "".concat(typeof t.x == "string" ? t.x : t.x + n), p = "".concat(typeof t.y == "string" ? t.y : t.y + n);
+    c = "translate(".concat(s, ", ").concat(p, ")") + c;
+  }
+  return c;
+}
+function P(e, t) {
+  return e.targetTouches && (0, i.findInArray)(e.targetTouches, (n) => t === n.identifier) || e.changedTouches && (0, i.findInArray)(e.changedTouches, (n) => t === n.identifier);
+}
+function R(e) {
+  if (e.targetTouches && e.targetTouches[0])
+    return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0])
+    return e.changedTouches[0].identifier;
+}
+function B(e) {
+  if (!e)
+    return;
+  let t = e.getElementById("react-draggable-style-el");
+  t || (t = e.createElement("style"), t.type = "text/css", t.id = "react-draggable-style-el", t.innerHTML = `.react-draggable-transparent-selection *::-moz-selection {all: inherit;}
+`, t.innerHTML += `.react-draggable-transparent-selection *::selection {all: inherit;}
+`, e.getElementsByTagName("head")[0].appendChild(t)), e.body && g(e.body, "react-draggable-transparent-selection");
+}
+function D(e) {
+  if (e)
+    try {
+      if (e.body && m(e.body, "react-draggable-transparent-selection"), e.selection)
+        e.selection.empty();
+      else {
+        const t = (e.defaultView || window).getSelection();
+        t && t.type !== "Caret" && t.removeAllRanges();
+      }
+    } catch {
+    }
+}
+function g(e, t) {
+  e.classList ? e.classList.add(t) : e.className.match(new RegExp("(?:^|\\s)".concat(t, "(?!\\S)"))) || (e.className += " ".concat(t));
+}
+function m(e, t) {
+  e.classList ? e.classList.remove(t) : e.className = e.className.replace(new RegExp("(?:^|\\s)".concat(t, "(?!\\S)"), "g"), "");
+}
+export {
+  a as default
+};

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/utils/getPrefix.mjs

@@ -0,0 +1,35 @@
+import { __exports as o } from "../../../../../../../../_virtual/getPrefix.mjs";
+Object.defineProperty(o, "__esModule", {
+  value: !0
+});
+o.browserPrefixToKey = f;
+o.browserPrefixToStyle = l;
+o.default = void 0;
+o.getPrefix = u;
+const i = ["Moz", "Webkit", "O", "ms"];
+function u() {
+  var e;
+  let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window > "u")
+    return "";
+  const r = (e = window.document) === null || e === void 0 || (e = e.documentElement) === null || e === void 0 ? void 0 : e.style;
+  if (!r || t in r)
+    return "";
+  for (let n = 0; n < i.length; n++)
+    if (f(t, i[n]) in r)
+      return i[n];
+  return "";
+}
+function f(e, t) {
+  return t ? "".concat(t).concat(s(e)) : e;
+}
+function l(e, t) {
+  return t ? "-".concat(t.toLowerCase(), "-").concat(e) : e;
+}
+function s(e) {
+  let t = "", r = !0;
+  for (let n = 0; n < e.length; n++)
+    r ? (t += e[n].toUpperCase(), r = !1) : e[n] === "-" ? r = !0 : t += e[n];
+  return t;
+}
+o.default = u();

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/utils/log.mjs

@@ -0,0 +1,7 @@
+import { __exports as e } from "../../../../../../../../_virtual/log.mjs";
+Object.defineProperty(e, "__esModule", {
+  value: !0
+});
+e.default = o;
+function o() {
+}

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/utils/positionFns.mjs

@@ -0,0 +1,107 @@
+import { __exports as i } from "../../../../../../../../_virtual/positionFns.mjs";
+import "./shims.mjs";
+import "./domFns.mjs";
+import { __exports as h } from "../../../../../../../../_virtual/shims.mjs";
+import { __exports as X } from "../../../../../../../../_virtual/domFns.mjs";
+Object.defineProperty(i, "__esModule", {
+  value: !0
+});
+i.canDragX = N;
+i.canDragY = M;
+i.createCoreData = w;
+i.createDraggableData = P;
+i.getBoundPosition = Y;
+i.getControlPosition = _;
+i.snapToGrid = D;
+var r = h, f = X;
+function Y(t, o, e) {
+  if (!t.props.bounds)
+    return [o, e];
+  let {
+    bounds: n
+  } = t.props;
+  n = typeof n == "string" ? n : y(n);
+  const s = d(t);
+  if (typeof n == "string") {
+    const {
+      ownerDocument: a
+    } = s, m = a.defaultView;
+    let u;
+    if (n === "parent" ? u = s.parentNode : u = a.querySelector(n), !(u instanceof m.HTMLElement))
+      throw new Error('Bounds selector "' + n + '" could not find an element.');
+    const c = u, p = m.getComputedStyle(s), l = m.getComputedStyle(c);
+    n = {
+      left: -s.offsetLeft + (0, r.int)(l.paddingLeft) + (0, r.int)(p.marginLeft),
+      top: -s.offsetTop + (0, r.int)(l.paddingTop) + (0, r.int)(p.marginTop),
+      right: (0, f.innerWidth)(c) - (0, f.outerWidth)(s) - s.offsetLeft + (0, r.int)(l.paddingRight) - (0, r.int)(p.marginRight),
+      bottom: (0, f.innerHeight)(c) - (0, f.outerHeight)(s) - s.offsetTop + (0, r.int)(l.paddingBottom) - (0, r.int)(p.marginBottom)
+    };
+  }
+  return (0, r.isNum)(n.right) && (o = Math.min(o, n.right)), (0, r.isNum)(n.bottom) && (e = Math.min(e, n.bottom)), (0, r.isNum)(n.left) && (o = Math.max(o, n.left)), (0, r.isNum)(n.top) && (e = Math.max(e, n.top)), [o, e];
+}
+function D(t, o, e) {
+  const n = Math.round(o / t[0]) * t[0], s = Math.round(e / t[1]) * t[1];
+  return [n, s];
+}
+function N(t) {
+  return t.props.axis === "both" || t.props.axis === "x";
+}
+function M(t) {
+  return t.props.axis === "both" || t.props.axis === "y";
+}
+function _(t, o, e) {
+  const n = typeof o == "number" ? (0, f.getTouch)(t, o) : null;
+  if (typeof o == "number" && !n)
+    return null;
+  const s = d(e), a = e.props.offsetParent || s.offsetParent || s.ownerDocument.body;
+  return (0, f.offsetXYFromParent)(n || t, a, e.props.scale);
+}
+function w(t, o, e) {
+  const n = !(0, r.isNum)(t.lastX), s = d(t);
+  return n ? {
+    node: s,
+    deltaX: 0,
+    deltaY: 0,
+    lastX: o,
+    lastY: e,
+    x: o,
+    y: e
+  } : {
+    node: s,
+    deltaX: o - t.lastX,
+    deltaY: e - t.lastY,
+    lastX: t.lastX,
+    lastY: t.lastY,
+    x: o,
+    y: e
+  };
+}
+function P(t, o) {
+  const e = t.props.scale;
+  return {
+    node: o.node,
+    x: t.state.x + o.deltaX / e,
+    y: t.state.y + o.deltaY / e,
+    deltaX: o.deltaX / e,
+    deltaY: o.deltaY / e,
+    lastX: t.state.x,
+    lastY: t.state.y
+  };
+}
+function y(t) {
+  return {
+    left: t.left,
+    top: t.top,
+    right: t.right,
+    bottom: t.bottom
+  };
+}
+function d(t) {
+  const o = t.findDOMNode();
+  if (!o)
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  return o;
+}
+export {
+  i as default
+};

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/utils/shims.mjs

@@ -0,0 +1,30 @@
+import { __exports as e } from "../../../../../../../../_virtual/shims.mjs";
+Object.defineProperty(e, "__esModule", {
+  value: !0
+});
+e.dontSetMe = f;
+e.findInArray = r;
+e.int = c;
+e.isFunction = u;
+e.isNum = s;
+function r(t, o) {
+  for (let n = 0, i = t.length; n < i; n++)
+    if (o.apply(o, [t[n], n, t]))
+      return t[n];
+}
+function u(t) {
+  return typeof t == "function" || Object.prototype.toString.call(t) === "[object Function]";
+}
+function s(t) {
+  return typeof t == "number" && !isNaN(t);
+}
+function c(t) {
+  return parseInt(t, 10);
+}
+function f(t, o, n) {
+  if (t[o])
+    return new Error("Invalid prop ".concat(o, " passed to ").concat(n, " - do not set this, set it on the child."));
+}
+export {
+  e as default
+};