zmdms-webui 2.5.1 → 2.5.3

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

@@ -1,190 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/react-draggable/build/cjs/Draggable.js

@@ -1,412 +0,0 @@
-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));