zmdms-webui 2.5.0 → 2.5.1

package/dist/es/node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,190 @@
+import { __exports as reactIs_development } from '../../../../../_virtual/react-is.development.js';
+
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_development;
+
+function requireReactIs_development () {
+	if (hasRequiredReactIs_development) return reactIs_development;
+	hasRequiredReactIs_development = 1;
+
+
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+	// nor polyfill, then a plain number is used for performance.
+	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+	// (unstable) APIs that have been removed. Can we remove the symbols?
+
+	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+	var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+	var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+	var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+	var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+	var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+	function isValidElementType(type) {
+	  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+	  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+	}
+
+	function typeOf(object) {
+	  if (typeof object === 'object' && object !== null) {
+	    var $$typeof = object.$$typeof;
+
+	    switch ($$typeof) {
+	      case REACT_ELEMENT_TYPE:
+	        var type = object.type;
+
+	        switch (type) {
+	          case REACT_ASYNC_MODE_TYPE:
+	          case REACT_CONCURRENT_MODE_TYPE:
+	          case REACT_FRAGMENT_TYPE:
+	          case REACT_PROFILER_TYPE:
+	          case REACT_STRICT_MODE_TYPE:
+	          case REACT_SUSPENSE_TYPE:
+	            return type;
+
+	          default:
+	            var $$typeofType = type && type.$$typeof;
+
+	            switch ($$typeofType) {
+	              case REACT_CONTEXT_TYPE:
+	              case REACT_FORWARD_REF_TYPE:
+	              case REACT_LAZY_TYPE:
+	              case REACT_MEMO_TYPE:
+	              case REACT_PROVIDER_TYPE:
+	                return $$typeofType;
+
+	              default:
+	                return $$typeof;
+	            }
+
+	        }
+
+	      case REACT_PORTAL_TYPE:
+	        return $$typeof;
+	    }
+	  }
+
+	  return undefined;
+	} // AsyncMode is deprecated along with isAsyncMode
+
+	var AsyncMode = REACT_ASYNC_MODE_TYPE;
+	var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+	var ContextConsumer = REACT_CONTEXT_TYPE;
+	var ContextProvider = REACT_PROVIDER_TYPE;
+	var Element = REACT_ELEMENT_TYPE;
+	var ForwardRef = REACT_FORWARD_REF_TYPE;
+	var Fragment = REACT_FRAGMENT_TYPE;
+	var Lazy = REACT_LAZY_TYPE;
+	var Memo = REACT_MEMO_TYPE;
+	var Portal = REACT_PORTAL_TYPE;
+	var Profiler = REACT_PROFILER_TYPE;
+	var StrictMode = REACT_STRICT_MODE_TYPE;
+	var Suspense = REACT_SUSPENSE_TYPE;
+	var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+	function isAsyncMode(object) {
+	  {
+	    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+	      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+	      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+	    }
+	  }
+
+	  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+	}
+	function isConcurrentMode(object) {
+	  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+	}
+	function isContextConsumer(object) {
+	  return typeOf(object) === REACT_CONTEXT_TYPE;
+	}
+	function isContextProvider(object) {
+	  return typeOf(object) === REACT_PROVIDER_TYPE;
+	}
+	function isElement(object) {
+	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	function isForwardRef(object) {
+	  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+	}
+	function isFragment(object) {
+	  return typeOf(object) === REACT_FRAGMENT_TYPE;
+	}
+	function isLazy(object) {
+	  return typeOf(object) === REACT_LAZY_TYPE;
+	}
+	function isMemo(object) {
+	  return typeOf(object) === REACT_MEMO_TYPE;
+	}
+	function isPortal(object) {
+	  return typeOf(object) === REACT_PORTAL_TYPE;
+	}
+	function isProfiler(object) {
+	  return typeOf(object) === REACT_PROFILER_TYPE;
+	}
+	function isStrictMode(object) {
+	  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+	}
+	function isSuspense(object) {
+	  return typeOf(object) === REACT_SUSPENSE_TYPE;
+	}
+
+	reactIs_development.AsyncMode = AsyncMode;
+	reactIs_development.ConcurrentMode = ConcurrentMode;
+	reactIs_development.ContextConsumer = ContextConsumer;
+	reactIs_development.ContextProvider = ContextProvider;
+	reactIs_development.Element = Element;
+	reactIs_development.ForwardRef = ForwardRef;
+	reactIs_development.Fragment = Fragment;
+	reactIs_development.Lazy = Lazy;
+	reactIs_development.Memo = Memo;
+	reactIs_development.Portal = Portal;
+	reactIs_development.Profiler = Profiler;
+	reactIs_development.StrictMode = StrictMode;
+	reactIs_development.Suspense = Suspense;
+	reactIs_development.isAsyncMode = isAsyncMode;
+	reactIs_development.isConcurrentMode = isConcurrentMode;
+	reactIs_development.isContextConsumer = isContextConsumer;
+	reactIs_development.isContextProvider = isContextProvider;
+	reactIs_development.isElement = isElement;
+	reactIs_development.isForwardRef = isForwardRef;
+	reactIs_development.isFragment = isFragment;
+	reactIs_development.isLazy = isLazy;
+	reactIs_development.isMemo = isMemo;
+	reactIs_development.isPortal = isPortal;
+	reactIs_development.isProfiler = isProfiler;
+	reactIs_development.isStrictMode = isStrictMode;
+	reactIs_development.isSuspense = isSuspense;
+	reactIs_development.isValidElementType = isValidElementType;
+	reactIs_development.typeOf = typeOf;
+	  })();
+	}
+	return reactIs_development;
+}
+
+export { requireReactIs_development as __require };

package/dist/es/node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,26 @@
+import { __exports as reactIs_production_min } from '../../../../../_virtual/react-is.production.min.js';
+
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_production_min;
+
+function requireReactIs_production_min () {
+	if (hasRequiredReactIs_production_min) return reactIs_production_min;
+	hasRequiredReactIs_production_min = 1;
+var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+	Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+	function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
+	reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
+	reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
+	reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
+	return reactIs_production_min;
+}
+
+export { requireReactIs_production_min as __require };

package/dist/es/node_modules/prop-types/node_modules/react-is/index.js

@@ -0,0 +1,19 @@
+import { __module as reactIs } from '../../../../_virtual/index3.js';
+import { __require as requireReactIs_production_min } from './cjs/react-is.production.min.js';
+import { __require as requireReactIs_development } from './cjs/react-is.development.js';
+
+var hasRequiredReactIs;
+
+function requireReactIs () {
+	if (hasRequiredReactIs) return reactIs.exports;
+	hasRequiredReactIs = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  reactIs.exports = requireReactIs_production_min();
+	} else {
+	  reactIs.exports = requireReactIs_development();
+	}
+	return reactIs.exports;
+}
+
+export { requireReactIs as __require };

package/dist/es/node_modules/rc-util/es/Dom/findDOMNode.js

@@ -1,5 +1,5 @@
 import React__default from 'react';
-import ReactDOM from 'react-dom';
+import require$$2 from 'react-dom';
 
 function isDOM(node) {
   // https://developer.mozilla.org/en-US/docs/Web/API/Element
@@ -15,7 +15,7 @@ function findDOMNode(node) {
     return node;
   }
   if (node instanceof React__default.Component) {
-    return ReactDOM.findDOMNode(node);
+    return require$$2.findDOMNode(node);
   }
   return null;
 }

package/dist/es/node_modules/react-draggable/build/cjs/Draggable.js

@@ -0,0 +1,412 @@
+import { __exports as Draggable } from '../../../../_virtual/Draggable.js';
+import React__default from 'react';
+import { p as propTypesExports } from '../../../prop-types/index.js';
+import require$$2 from 'react-dom';
+import { c as clsxExports } from '../../node_modules/clsx/dist/clsx.js';
+import './utils/domFns.js';
+import './utils/positionFns.js';
+import './utils/shims.js';
+import './DraggableCore.js';
+import './utils/log.js';
+import { __exports as domFns } from '../../../../_virtual/domFns.js';
+import { __exports as positionFns } from '../../../../_virtual/positionFns.js';
+import { __exports as shims } from '../../../../_virtual/shims.js';
+import { __exports as DraggableCore } from '../../../../_virtual/DraggableCore.js';
+import { __exports as log } from '../../../../_virtual/log.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	Object.defineProperty(exports, "DraggableCore", {
+	  enumerable: true,
+	  get: function () {
+	    return _DraggableCore.default;
+	  }
+	});
+	exports.default = void 0;
+	var React = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(propTypesExports);
+	var _reactDom = _interopRequireDefault(require$$2);
+	var _clsx = clsxExports;
+	var _domFns = domFns;
+	var _positionFns = positionFns;
+	var _shims = shims;
+	var _DraggableCore = _interopRequireDefault(DraggableCore);
+	var _log = _interopRequireDefault(log);
+	function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+	function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+	function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+	function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+	function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+	function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /*:: import type {ControlPosition, PositionOffsetControlPosition, DraggableCoreProps, DraggableCoreDefaultProps} from './DraggableCore';*/
+	/*:: import type {Bounds, DraggableEventHandler} from './utils/types';*/
+	/*:: import type {Element as ReactElement} from 'react';*/
+	/*:: type DraggableState = {
+	  dragging: boolean,
+	  dragged: boolean,
+	  x: number, y: number,
+	  slackX: number, slackY: number,
+	  isElementSVG: boolean,
+	  prevPropsPosition: ?ControlPosition,
+	};*/
+	/*:: export type DraggableDefaultProps = {
+	  ...DraggableCoreDefaultProps,
+	  axis: 'both' | 'x' | 'y' | 'none',
+	  bounds: Bounds | string | false,
+	  defaultClassName: string,
+	  defaultClassNameDragging: string,
+	  defaultClassNameDragged: string,
+	  defaultPosition: ControlPosition,
+	  scale: number,
+	};*/
+	/*:: export type DraggableProps = {
+	  ...DraggableCoreProps,
+	  ...DraggableDefaultProps,
+	  positionOffset: PositionOffsetControlPosition,
+	  position: ControlPosition,
+	};*/
+	//
+	// Define <Draggable>
+	//
+	class Draggable extends React.Component /*:: <DraggableProps, DraggableState>*/{
+	  // React 16.3+
+	  // Arity (props, state)
+	  static getDerivedStateFromProps(_ref /*:: */, _ref2 /*:: */) /*: ?Partial<DraggableState>*/{
+	    let {
+	      position
+	    } /*: DraggableProps*/ = _ref /*: DraggableProps*/;
+	    let {
+	      prevPropsPosition
+	    } /*: DraggableState*/ = _ref2 /*: DraggableState*/;
+	    // Set x/y if a new position is provided in props that is different than the previous.
+	    if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {
+	      (0, _log.default)('Draggable: getDerivedStateFromProps %j', {
+	        position,
+	        prevPropsPosition
+	      });
+	      return {
+	        x: position.x,
+	        y: position.y,
+	        prevPropsPosition: {
+	          ...position
+	        }
+	      };
+	    }
+	    return null;
+	  }
+	  constructor(props /*: DraggableProps*/) {
+	    super(props);
+	    _defineProperty(this, "onDragStart", (e, coreData) => {
+	      (0, _log.default)('Draggable: onDragStart: %j', coreData);
+
+	      // Short-circuit if user's callback killed it.
+	      const shouldStart = this.props.onStart(e, (0, _positionFns.createDraggableData)(this, coreData));
+	      // Kills start event on core as well, so move handlers are never bound.
+	      if (shouldStart === false) return false;
+	      this.setState({
+	        dragging: true,
+	        dragged: true
+	      });
+	    });
+	    _defineProperty(this, "onDrag", (e, coreData) => {
+	      if (!this.state.dragging) return false;
+	      (0, _log.default)('Draggable: onDrag: %j', coreData);
+	      const uiData = (0, _positionFns.createDraggableData)(this, coreData);
+	      const newState = {
+	        x: uiData.x,
+	        y: uiData.y,
+	        slackX: 0,
+	        slackY: 0
+	      };
+
+	      // Keep within bounds.
+	      if (this.props.bounds) {
+	        // Save original x and y.
+	        const {
+	          x,
+	          y
+	        } = newState;
+
+	        // Add slack to the values used to calculate bound position. This will ensure that if
+	        // we start removing slack, the element won't react to it right away until it's been
+	        // completely removed.
+	        newState.x += this.state.slackX;
+	        newState.y += this.state.slackY;
+
+	        // Get bound position. This will ceil/floor the x and y within the boundaries.
+	        const [newStateX, newStateY] = (0, _positionFns.getBoundPosition)(this, newState.x, newState.y);
+	        newState.x = newStateX;
+	        newState.y = newStateY;
+
+	        // Recalculate slack by noting how much was shaved by the boundPosition handler.
+	        newState.slackX = this.state.slackX + (x - newState.x);
+	        newState.slackY = this.state.slackY + (y - newState.y);
+
+	        // Update the event we fire to reflect what really happened after bounds took effect.
+	        uiData.x = newState.x;
+	        uiData.y = newState.y;
+	        uiData.deltaX = newState.x - this.state.x;
+	        uiData.deltaY = newState.y - this.state.y;
+	      }
+
+	      // Short-circuit if user's callback killed it.
+	      const shouldUpdate = this.props.onDrag(e, uiData);
+	      if (shouldUpdate === false) return false;
+	      this.setState(newState);
+	    });
+	    _defineProperty(this, "onDragStop", (e, coreData) => {
+	      if (!this.state.dragging) return false;
+
+	      // Short-circuit if user's callback killed it.
+	      const shouldContinue = this.props.onStop(e, (0, _positionFns.createDraggableData)(this, coreData));
+	      if (shouldContinue === false) return false;
+	      (0, _log.default)('Draggable: onDragStop: %j', coreData);
+	      const newState /*: Partial<DraggableState>*/ = {
+	        dragging: false,
+	        slackX: 0,
+	        slackY: 0
+	      };
+
+	      // If this is a controlled component, the result of this operation will be to
+	      // revert back to the old position. We expect a handler on `onDragStop`, at the least.
+	      const controlled = Boolean(this.props.position);
+	      if (controlled) {
+	        const {
+	          x,
+	          y
+	        } = this.props.position;
+	        newState.x = x;
+	        newState.y = y;
+	      }
+	      this.setState(newState);
+	    });
+	    this.state = {
+	      // Whether or not we are currently dragging.
+	      dragging: false,
+	      // Whether or not we have been dragged before.
+	      dragged: false,
+	      // Current transform x and y.
+	      x: props.position ? props.position.x : props.defaultPosition.x,
+	      y: props.position ? props.position.y : props.defaultPosition.y,
+	      prevPropsPosition: {
+	        ...props.position
+	      },
+	      // Used for compensating for out-of-bounds drags
+	      slackX: 0,
+	      slackY: 0,
+	      // Can only determine if SVG after mounting
+	      isElementSVG: false
+	    };
+	    if (props.position && !(props.onDrag || props.onStop)) {
+	      // eslint-disable-next-line no-console
+	      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() {
+	    // Check to see if the element passed is an instanceof SVGElement
+	    if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {
+	      this.setState({
+	        isElementSVG: true
+	      });
+	    }
+	  }
+	  componentWillUnmount() {
+	    if (this.state.dragging) {
+	      this.setState({
+	        dragging: false
+	      }); // prevents invariant if unmounted while dragging
+	    }
+	  }
+
+	  // 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() /*: ?HTMLElement*/{
+	    return this.props?.nodeRef?.current ?? _reactDom.default.findDOMNode(this);
+	  }
+	  render() /*: ReactElement<any>*/{
+	    const {
+	      axis,
+	      bounds,
+	      children,
+	      defaultPosition,
+	      defaultClassName,
+	      defaultClassNameDragging,
+	      defaultClassNameDragged,
+	      position,
+	      positionOffset,
+	      scale,
+	      ...draggableCoreProps
+	    } = this.props;
+	    let style = {};
+	    let svgTransform = null;
+
+	    // If this is controlled, we don't want to move it - unless it's dragging.
+	    const controlled = Boolean(position);
+	    const draggable = !controlled || this.state.dragging;
+	    const validPosition = position || defaultPosition;
+	    const transformOpts = {
+	      // Set left if horizontal drag is enabled
+	      x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,
+	      // Set top if vertical drag is enabled
+	      y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y
+	    };
+
+	    // If this element was SVG, we use the `transform` attribute.
+	    if (this.state.isElementSVG) {
+	      svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);
+	    } else {
+	      // Add a CSS transform to move the element around. This allows us to move the element around
+	      // without worrying about whether or not it is relatively or absolutely positioned.
+	      // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>
+	      // has a clean slate.
+	      style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);
+	    }
+
+	    // Mark with class while dragging
+	    const className = (0, _clsx.clsx)(children.props.className || '', defaultClassName, {
+	      [defaultClassNameDragging]: this.state.dragging,
+	      [defaultClassNameDragged]: this.state.dragged
+	    });
+
+	    // Reuse the child provided
+	    // This makes it flexible to use whatever element is wanted (div, ul, etc)
+	    return /*#__PURE__*/React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {
+	      onStart: this.onDragStart,
+	      onDrag: this.onDrag,
+	      onStop: this.onDragStop
+	    }), /*#__PURE__*/React.cloneElement(React.Children.only(children), {
+	      className: className,
+	      style: {
+	        ...children.props.style,
+	        ...style
+	      },
+	      transform: svgTransform
+	    }));
+	  }
+	}
+	exports.default = Draggable;
+	_defineProperty(Draggable, "displayName", 'Draggable');
+	_defineProperty(Draggable, "propTypes", {
+	  // Accepts all props <DraggableCore> accepts.
+	  ..._DraggableCore.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: _propTypes.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: _propTypes.default.oneOfType([_propTypes.default.shape({
+	    left: _propTypes.default.number,
+	    right: _propTypes.default.number,
+	    top: _propTypes.default.number,
+	    bottom: _propTypes.default.number
+	  }), _propTypes.default.string, _propTypes.default.oneOf([false])]),
+	  defaultClassName: _propTypes.default.string,
+	  defaultClassNameDragging: _propTypes.default.string,
+	  defaultClassNameDragged: _propTypes.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: _propTypes.default.shape({
+	    x: _propTypes.default.number,
+	    y: _propTypes.default.number
+	  }),
+	  positionOffset: _propTypes.default.shape({
+	    x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
+	    y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.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: _propTypes.default.shape({
+	    x: _propTypes.default.number,
+	    y: _propTypes.default.number
+	  }),
+	  /**
+	   * These properties should be defined on the child, not here.
+	   */
+	  className: _shims.dontSetMe,
+	  style: _shims.dontSetMe,
+	  transform: _shims.dontSetMe
+	});
+	_defineProperty(Draggable, "defaultProps", {
+	  ..._DraggableCore.default.defaultProps,
+	  axis: 'both',
+	  bounds: false,
+	  defaultClassName: 'react-draggable',
+	  defaultClassNameDragging: 'react-draggable-dragging',
+	  defaultClassNameDragged: 'react-draggable-dragged',
+	  defaultPosition: {
+	    x: 0,
+	    y: 0
+	  },
+	  scale: 1
+	}); 
+} (Draggable));