@apipass/design-system 1.17.0 → 1.18.1

package/dist/lib/vendor/react-draggable/build/cjs/Draggable.js

@@ -0,0 +1,755 @@
+import z from "react";
+import { __require as K } from "../../../prop-types/index.js";
+import J from "react-dom";
+import { __require as Xt } from "../../../clsx/dist/clsx2.js";
+var R, Q;
+function Lt() {
+  if (Q) return R;
+  Q = 1;
+  var Z = Object.create, w = Object.defineProperty, tt = Object.getOwnPropertyDescriptor, et = Object.getOwnPropertyNames, nt = Object.getPrototypeOf, ot = Object.prototype.hasOwnProperty, st = (t, e) => {
+    for (var n in e)
+      w(t, n, { get: e[n], enumerable: !0 });
+  }, U = (t, e, n, o) => {
+    if (e && typeof e == "object" || typeof e == "function")
+      for (let s of et(e))
+        !ot.call(t, s) && s !== n && w(t, s, { get: () => e[s], enumerable: !(o = tt(e, s)) || o.enumerable });
+    return t;
+  }, y = (t, e, n) => (n = t != null ? Z(nt(t)) : {}, U(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    !t || !t.__esModule ? w(n, "default", { value: t, enumerable: !0 }) : n,
+    t
+  )), rt = (t) => U(w({}, "__esModule", { value: !0 }), t), $ = {};
+  st($, {
+    DraggableCore: () => g,
+    default: () => N
+  }), R = rt($);
+  var v = y(z), a = y(/* @__PURE__ */ K()), at = y(J), it = Xt();
+  function _(t, e) {
+    for (let n = 0, o = t.length; n < o; n++)
+      if (e.apply(e, [t[n], n, t])) return t[n];
+  }
+  function L(t) {
+    return typeof t == "function" || Object.prototype.toString.call(t) === "[object Function]";
+  }
+  function S(t) {
+    return typeof t == "number" && !isNaN(t);
+  }
+  function u(t) {
+    return parseInt(t, 10);
+  }
+  function b(t, e, n) {
+    if (t[e])
+      return new Error(`Invalid prop ${e} passed to ${n} - do not set this, set it on the child.`);
+  }
+  var x = ["Moz", "Webkit", "O", "ms"];
+  function lt(t = "transform") {
+    var e, n;
+    if (typeof window > "u") return "";
+    const o = (n = (e = window.document) == null ? void 0 : e.documentElement) == null ? void 0 : n.style;
+    if (!o || t in o) return "";
+    for (let s = 0; s < x.length; s++)
+      if (B(t, x[s]) in o) return x[s];
+    return "";
+  }
+  function B(t, e) {
+    return e ? `${e}${ut(t)}` : t;
+  }
+  function ut(t) {
+    let e = "", n = !0;
+    for (let o = 0; o < t.length; o++)
+      n ? (e += t[o].toUpperCase(), n = !1) : t[o] === "-" ? n = !0 : e += t[o];
+    return e;
+  }
+  var dt = lt(), M = "";
+  function ct(t, e) {
+    var n;
+    M || (M = (n = _([
+      "matches",
+      "webkitMatchesSelector",
+      "mozMatchesSelector",
+      "msMatchesSelector",
+      "oMatchesSelector"
+    ], function(s) {
+      return L(t[s]);
+    })) != null ? n : "");
+    const o = t[M];
+    return L(o) ? !!o.call(t, e) : !1;
+  }
+  function A(t, e, n) {
+    let o = t;
+    do {
+      if (ct(o, e)) return !0;
+      if (o === n) return !1;
+      o = o.parentNode;
+    } while (o);
+    return !1;
+  }
+  function T(t, e, n, o) {
+    if (!t) return;
+    const s = { capture: !0, ...o }, i = n;
+    t.addEventListener ? t.addEventListener(e, i, s) : t.attachEvent ? t.attachEvent("on" + e, i) : t["on" + e] = i;
+  }
+  function p(t, e, n, o) {
+    if (!t) return;
+    const s = { capture: !0, ...o }, i = n;
+    t.removeEventListener ? t.removeEventListener(e, i, s) : t.detachEvent ? t.detachEvent("on" + e, i) : t["on" + e] = null;
+  }
+  function ft(t) {
+    let e = t.clientHeight;
+    const n = t.ownerDocument.defaultView.getComputedStyle(t);
+    return e += u(n.borderTopWidth), e += u(n.borderBottomWidth), e;
+  }
+  function ht(t) {
+    let e = t.clientWidth;
+    const n = t.ownerDocument.defaultView.getComputedStyle(t);
+    return e += u(n.borderLeftWidth), e += u(n.borderRightWidth), e;
+  }
+  function pt(t) {
+    let e = t.clientHeight;
+    const n = t.ownerDocument.defaultView.getComputedStyle(t);
+    return e -= u(n.paddingTop), e -= u(n.paddingBottom), e;
+  }
+  function gt(t) {
+    let e = t.clientWidth;
+    const n = t.ownerDocument.defaultView.getComputedStyle(t);
+    return e -= u(n.paddingLeft), e -= u(n.paddingRight), e;
+  }
+  function mt(t, e, n) {
+    const s = e === e.ownerDocument.body ? { left: 0, top: 0 } : e.getBoundingClientRect(), i = (t.clientX + e.scrollLeft - s.left) / n, r = (t.clientY + e.scrollTop - s.top) / n;
+    return { x: i, y: r };
+  }
+  function yt(t, e) {
+    const n = V(t, e, "px");
+    return { [B("transform", dt)]: n };
+  }
+  function bt(t, e) {
+    return V(t, e, "");
+  }
+  function V({ x: t, y: e }, n, o) {
+    let s = `translate(${t}${o},${e}${o})`;
+    if (n) {
+      const i = `${typeof n.x == "string" ? n.x : n.x + o}`, r = `${typeof n.y == "string" ? n.y : n.y + o}`;
+      s = `translate(${i}, ${r})` + s;
+    }
+    return s;
+  }
+  function Dt(t, e) {
+    return t.targetTouches && _(t.targetTouches, (n) => e === n.identifier) || t.changedTouches && _(t.changedTouches, (n) => e === n.identifier);
+  }
+  function St(t) {
+    if (t.targetTouches && t.targetTouches[0]) return t.targetTouches[0].identifier;
+    if (t.changedTouches && t.changedTouches[0]) return t.changedTouches[0].identifier;
+  }
+  function wt() {
+    return typeof __webpack_nonce__ < "u" ? __webpack_nonce__ : void 0;
+  }
+  function vt(t, e) {
+    if (!t) return;
+    let n = t.getElementById("react-draggable-style-el");
+    if (!n) {
+      n = t.createElement("style"), n.type = "text/css", n.id = "react-draggable-style-el";
+      const o = e ?? wt();
+      o && n.setAttribute("nonce", o), n.innerHTML = `.react-draggable-transparent-selection *::-moz-selection {all: inherit;}
+`, n.innerHTML += `.react-draggable-transparent-selection *::selection {all: inherit;}
+`, t.getElementsByTagName("head")[0].appendChild(n);
+    }
+    t.body && Nt(t.body, "react-draggable-transparent-selection");
+  }
+  function j(t) {
+    window.requestAnimationFrame ? window.requestAnimationFrame(() => {
+      q(t);
+    }) : q(t);
+  }
+  function q(t) {
+    if (t)
+      try {
+        t.body && _t(t.body, "react-draggable-transparent-selection");
+        const e = t.selection;
+        if (e)
+          e.empty();
+        else {
+          const n = (t.defaultView || window).getSelection();
+          n && n.type !== "Caret" && n.removeAllRanges();
+        }
+      } catch {
+      }
+  }
+  function Nt(t, e) {
+    t.classList ? t.classList.add(e) : t.className.match(new RegExp(`(?:^|\\s)${e}(?!\\S)`)) || (t.className += ` ${e}`);
+  }
+  function _t(t, e) {
+    t.classList ? t.classList.remove(e) : t.className = t.className.replace(new RegExp(`(?:^|\\s)${e}(?!\\S)`, "g"), "");
+  }
+  function xt(t, e, n) {
+    if (!t.props.bounds) return [e, n];
+    let { bounds: o } = t.props;
+    o = typeof o == "string" ? o : Ct(o);
+    const s = P(t);
+    if (typeof o == "string") {
+      const { ownerDocument: i } = s, r = i.defaultView;
+      if (!r)
+        throw new Error("Cannot resolve the owner window of the draggable node.");
+      let l;
+      if (o === "parent" ? l = s.parentNode : l = s.getRootNode().querySelector(o), !(l instanceof r.HTMLElement))
+        throw new Error('Bounds selector "' + o + '" could not find an element.');
+      const c = l, m = r.getComputedStyle(s), D = r.getComputedStyle(c);
+      o = {
+        left: -s.offsetLeft + u(D.paddingLeft) + u(m.marginLeft),
+        top: -s.offsetTop + u(D.paddingTop) + u(m.marginTop),
+        right: gt(c) - ht(s) - s.offsetLeft + u(D.paddingRight) - u(m.marginRight),
+        bottom: pt(c) - ft(s) - s.offsetTop + u(D.paddingBottom) - u(m.marginBottom)
+      };
+    }
+    return S(o.right) && (e = Math.min(e, o.right)), S(o.bottom) && (n = Math.min(n, o.bottom)), S(o.left) && (e = Math.max(e, o.left)), S(o.top) && (n = Math.max(n, o.top)), [e, n];
+  }
+  function H(t, e, n) {
+    const o = Math.round(e / t[0]) * t[0], s = Math.round(n / t[1]) * t[1];
+    return [o, s];
+  }
+  function Mt(t) {
+    return t.props.axis === "both" || t.props.axis === "x";
+  }
+  function Tt(t) {
+    return t.props.axis === "both" || t.props.axis === "y";
+  }
+  function C(t, e, n) {
+    const o = typeof e == "number" ? Dt(t, e) : null;
+    if (typeof e == "number" && !o) return null;
+    const s = P(n), i = n.props.offsetParent || s.offsetParent || s.ownerDocument.body;
+    return mt(o || t, i, n.props.scale);
+  }
+  function E(t, e, n) {
+    const o = !S(t.lastX), s = P(t);
+    return o ? {
+      node: s,
+      deltaX: 0,
+      deltaY: 0,
+      lastX: e,
+      lastY: n,
+      x: e,
+      y: n
+    } : {
+      node: s,
+      deltaX: e - t.lastX,
+      deltaY: n - t.lastY,
+      lastX: t.lastX,
+      lastY: t.lastY,
+      x: e,
+      y: n
+    };
+  }
+  function O(t, e) {
+    const n = t.props.scale;
+    return {
+      node: e.node,
+      x: t.state.x + e.deltaX / n,
+      y: t.state.y + e.deltaY / n,
+      deltaX: e.deltaX / n,
+      deltaY: e.deltaY / n,
+      lastX: t.state.x,
+      lastY: t.state.y
+    };
+  }
+  function Ct(t) {
+    return {
+      left: t.left,
+      top: t.top,
+      right: t.right,
+      bottom: t.bottom
+    };
+  }
+  function P(t) {
+    const e = t.findDOMNode();
+    if (!e)
+      throw new Error("<DraggableCore>: Unmounted during event!");
+    return e;
+  }
+  var X = y(z), d = y(/* @__PURE__ */ K()), Et = y(J);
+  function Ot(...t) {
+  }
+  var f = {
+    touch: {
+      start: "touchstart",
+      move: "touchmove",
+      stop: "touchend"
+    },
+    mouse: {
+      start: "mousedown",
+      move: "mousemove",
+      stop: "mouseup"
+    }
+  }, h = f.mouse, g = class extends X.Component {
+    constructor() {
+      super(...arguments), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, this.touchIdentifier = null, this.mounted = !1, this.handleDragStart = (t) => {
+        if (this.props.onMouseDown(t), !this.props.allowAnyClick && (typeof t.button == "number" && t.button !== 0 || t.ctrlKey)) return !1;
+        const e = this.findDOMNode();
+        if (!e || !e.ownerDocument || !e.ownerDocument.body)
+          throw new Error("<DraggableCore> not mounted on DragStart!");
+        const { ownerDocument: n } = e;
+        if (this.props.disabled || !(t.target instanceof n.defaultView.Node) || this.props.handle && !A(t.target, this.props.handle, e) || this.props.cancel && A(t.target, this.props.cancel, e))
+          return;
+        t.type === "touchstart" && !this.props.allowMobileScroll && t.preventDefault();
+        const o = St(t);
+        this.touchIdentifier = o;
+        const s = C(t, o, this);
+        if (s == null) return;
+        const { x: i, y: r } = s, l = E(this, i, r);
+        Ot("calling", this.props.onStart), !(this.props.onStart(t, l) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && vt(n, this.props.nonce), this.dragging = !0, this.lastX = i, this.lastY = r, T(n, h.move, this.handleDrag), T(n, h.stop, this.handleDragStop));
+      }, this.handleDrag = (t) => {
+        const e = C(t, this.touchIdentifier, this);
+        if (e == null) return;
+        let { x: n, y: o } = e;
+        if (Array.isArray(this.props.grid)) {
+          let r = n - this.lastX, l = o - this.lastY;
+          if ([r, l] = H(this.props.grid, r, l), !r && !l) return;
+          n = this.lastX + r, o = this.lastY + l;
+        }
+        const s = E(this, n, o);
+        if (this.props.onDrag(t, s) === !1 || this.mounted === !1) {
+          try {
+            this.handleDragStop(new MouseEvent("mouseup"));
+          } catch {
+            const r = document.createEvent("MouseEvents");
+            r.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(r);
+          }
+          return;
+        }
+        this.lastX = n, this.lastY = o;
+      }, this.handleDragStop = (t) => {
+        if (!this.dragging) return;
+        const e = C(t, this.touchIdentifier, this);
+        if (e == null) return;
+        let { x: n, y: o } = e;
+        if (Array.isArray(this.props.grid)) {
+          let l = n - this.lastX || 0, c = o - this.lastY || 0;
+          [l, c] = H(this.props.grid, l, c), n = this.lastX + l, o = this.lastY + c;
+        }
+        const s = E(this, n, o);
+        if (this.props.onStop(t, s) === !1 || this.mounted === !1) return !1;
+        const r = this.findDOMNode();
+        r && this.props.enableUserSelectHack && j(r.ownerDocument), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, r && (p(r.ownerDocument, h.move, this.handleDrag), p(r.ownerDocument, h.stop, this.handleDragStop));
+      }, this.onMouseDown = (t) => (h = f.mouse, this.handleDragStart(t)), this.onMouseUp = (t) => (h = f.mouse, this.handleDragStop(t)), this.onTouchStart = (t) => (h = f.touch, this.handleDragStart(t)), this.onTouchEnd = (t) => (h = f.touch, this.handleDragStop(t));
+    }
+    componentDidMount() {
+      this.mounted = !0;
+      const t = this.findDOMNode();
+      t && T(t, f.touch.start, this.onTouchStart, { passive: !1 });
+    }
+    componentWillUnmount() {
+      this.mounted = !1;
+      const t = this.findDOMNode();
+      if (t) {
+        const { ownerDocument: e } = t;
+        p(e, f.mouse.move, this.handleDrag), p(e, f.touch.move, this.handleDrag), p(e, f.mouse.stop, this.handleDragStop), p(e, f.touch.stop, this.handleDragStop), p(t, f.touch.start, this.onTouchStart, { passive: !1 }), this.props.enableUserSelectHack && j(e);
+      }
+    }
+    // React 19 removed ReactDOM.findDOMNode, so nodeRef is now required.
+    // For backward compatibility with React 18 and earlier, we still support findDOMNode if available.
+    findDOMNode() {
+      var t;
+      if ((t = this.props) != null && t.nodeRef)
+        return this.props.nodeRef.current;
+      const e = Et.default;
+      return typeof e.findDOMNode == "function" ? e.findDOMNode(this) : null;
+    }
+    render() {
+      return X.cloneElement(X.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
+      });
+    }
+  };
+  g.displayName = "DraggableCore", g.propTypes = {
+    /**
+     * `allowAnyClick` allows dragging using any mouse button.
+     * By default, we only accept the left button.
+     *
+     * Defaults to `false`.
+     */
+    allowAnyClick: d.default.bool,
+    /**
+     * `allowMobileScroll` turns off cancellation of the 'touchstart' event
+     * on mobile devices. Only enable this if you are having trouble with click
+     * events. Prefer using 'handle' / 'cancel' instead.
+     *
+     * Defaults to `false`.
+     */
+    allowMobileScroll: d.default.bool,
+    children: d.default.node.isRequired,
+    /**
+     * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+     * with the exception of `onMouseDown`, will not fire.
+     */
+    disabled: d.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: d.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: d.default.arrayOf(d.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: d.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: d.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: d.default.object,
+    /**
+     * `nonce` is applied to the dynamically-injected <style> element used by the
+     * user-select hack, so it isn't blocked under a strict Content Security
+     * Policy (`style-src` without `'unsafe-inline'`). If omitted, webpack's
+     * `__webpack_nonce__` global is used when available.
+     */
+    nonce: d.default.string,
+    /**
+     * Called when dragging starts.
+     * If this function returns the boolean false, dragging will be canceled.
+     */
+    onStart: d.default.func,
+    /**
+     * Called while dragging.
+     * If this function returns the boolean false, dragging will be canceled.
+     */
+    onDrag: d.default.func,
+    /**
+     * Called when dragging stops.
+     * If this function returns the boolean false, the drag will remain active.
+     */
+    onStop: d.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: d.default.func,
+    /**
+     * `scale`, if set, applies scaling while dragging an element
+     */
+    scale: d.default.number,
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: b,
+    style: b,
+    transform: b
+  }, g.defaultProps = {
+    allowAnyClick: !1,
+    // by default only accept left click
+    allowMobileScroll: !1,
+    disabled: !1,
+    enableUserSelectHack: !0,
+    onStart: function() {
+    },
+    onDrag: function() {
+    },
+    onStop: function() {
+    },
+    onMouseDown: function() {
+    },
+    scale: 1
+  };
+  var N = class extends v.Component {
+    constructor(t) {
+      super(t), this.onDragStart = (e, n) => {
+        if (this.props.onStart(e, O(this, n)) === !1) return !1;
+        this.setState({ dragging: !0, dragged: !0 });
+      }, this.onDrag = (e, n) => {
+        if (!this.state.dragging) return !1;
+        const o = O(this, n), s = {
+          x: o.x,
+          y: o.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const { x: r, y: l } = s;
+          s.x += this.state.slackX, s.y += this.state.slackY;
+          const [c, m] = xt(this, s.x, s.y);
+          s.x = c, s.y = m, s.slackX = this.state.slackX + (r - s.x), s.slackY = this.state.slackY + (l - 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(e, o) === !1) return !1;
+        this.setState(s);
+      }, this.onDragStop = (e, n) => {
+        if (!this.state.dragging || this.props.onStop(e, O(this, n)) === !1) return !1;
+        const s = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const { x: r, y: l } = this.props.position;
+          s.x = r, s.y = l;
+        }
+        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: 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.");
+    }
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps({ position: t }, { prevPropsPosition: e }) {
+      return t && (!e || t.x !== e.x || t.y !== e.y) ? {
+        x: t.x,
+        y: t.y,
+        prevPropsPosition: { ...t }
+      } : null;
+    }
+    componentDidMount() {
+      typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({ isElementSVG: !0 });
+    }
+    componentWillUnmount() {
+      this.state.dragging && this.setState({ dragging: !1 });
+    }
+    // React 19 removed ReactDOM.findDOMNode, so nodeRef is now required.
+    // For backward compatibility with React 18 and earlier, we still support findDOMNode if available.
+    findDOMNode() {
+      var t;
+      if ((t = this.props) != null && t.nodeRef)
+        return this.props.nodeRef.current;
+      const e = at.default;
+      return typeof e.findDOMNode == "function" ? e.findDOMNode(this) : null;
+    }
+    render() {
+      const {
+        axis: t,
+        bounds: e,
+        children: n,
+        defaultPosition: o,
+        defaultClassName: s,
+        defaultClassNameDragging: i,
+        defaultClassNameDragged: r,
+        position: l,
+        positionOffset: c,
+        scale: m,
+        ...D
+      } = this.props;
+      let Y = {}, W = null;
+      const F = !!!l || this.state.dragging, I = l || o, G = {
+        // Set left if horizontal drag is enabled
+        x: Mt(this) && F ? this.state.x : I.x,
+        // Set top if vertical drag is enabled
+        y: Tt(this) && F ? this.state.y : I.y
+      };
+      this.state.isElementSVG ? W = bt(G, c) : Y = yt(G, c);
+      const k = v.Children.only(n), Pt = (0, it.clsx)(k.props.className || "", s, {
+        [i]: this.state.dragging,
+        [r]: this.state.dragged
+      });
+      return /* @__PURE__ */ v.createElement(g, { ...D, onStart: this.onDragStart, onDrag: this.onDrag, onStop: this.onDragStop }, v.cloneElement(k, {
+        className: Pt,
+        style: { ...k.props.style, ...Y },
+        transform: W
+      }));
+    }
+  };
+  return N.displayName = "Draggable", N.propTypes = {
+    // Accepts all props <DraggableCore> accepts.
+    ...g.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: a.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: a.default.oneOfType([
+      a.default.shape({
+        left: a.default.number,
+        right: a.default.number,
+        top: a.default.number,
+        bottom: a.default.number
+      }),
+      a.default.string,
+      a.default.oneOf([!1])
+    ]),
+    defaultClassName: a.default.string,
+    defaultClassNameDragging: a.default.string,
+    defaultClassNameDragged: a.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: a.default.shape({
+      x: a.default.number,
+      y: a.default.number
+    }),
+    positionOffset: a.default.shape({
+      x: a.default.oneOfType([a.default.number, a.default.string]),
+      y: a.default.oneOfType([a.default.number, a.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: a.default.shape({
+      x: a.default.number,
+      y: a.default.number
+    }),
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: b,
+    style: b,
+    transform: b
+  }, N.defaultProps = {
+    ...g.defaultProps,
+    axis: "both",
+    bounds: !1,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: { x: 0, y: 0 },
+    scale: 1
+  }, R;
+}
+export {
+  Lt as __require
+};
+//# sourceMappingURL=Draggable.js.map