@sis-cc/dotstatsuite-visions 12.11.0 → 12.12.1

package/umd/@sis-cc/dotstatsuite-visions.js

@@ -1,5 +1,5 @@
 /*!
- * @sis-cc/dotstatsuite-visions v12.11.0 - https://visions-qa.siscc.org/#o
+ * @sis-cc/dotstatsuite-visions v12.12.1 - https://visions-qa.siscc.org/#o
  * MIT Licensed
  */
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -7571,23 +7571,54 @@ exports.findInArray = findInArray;
 exports.int = int;
 exports.isFunction = isFunction;
 exports.isNum = isNum;
+
 // @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc
-function findInArray(array /*: Array<any> | TouchList*/, callback /*: Function*/) /*: any*/{
-  for (let i = 0, length = array.length; i < length; i++) {
+function findInArray(array
+/*: Array<any> | TouchList*/
+, callback
+/*: Function*/
+)
+/*: any*/
+{
+  for (var i = 0, length = array.length; i < length; i++) {
     if (callback.apply(callback, [array[i], i, array])) return array[i];
   }
 }
-function isFunction(func /*: any*/) /*: boolean %checks*/{
+
+function isFunction(func
+/*: any*/
+)
+/*: boolean %checks*/
+{
   // $FlowIgnore[method-unbinding]
   return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';
 }
-function isNum(num /*: any*/) /*: boolean %checks*/{
+
+function isNum(num
+/*: any*/
+)
+/*: boolean %checks*/
+{
   return typeof num === 'number' && !isNaN(num);
 }
-function int(a /*: string*/) /*: number*/{
+
+function int(a
+/*: string*/
+)
+/*: number*/
+{
   return parseInt(a, 10);
 }
-function dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) /*: ?Error*/{
+
+function dontSetMe(props
+/*: Object*/
+, propName
+/*: string*/
+, componentName
+/*: string*/
+)
+/*: ?Error*/
+{
   if (props[propName]) {
     return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
   }
@@ -8545,6 +8576,8 @@ exports["default"] = ScalingCellSizeAndPositionManager;
 "use strict";
 
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -8566,46 +8599,83 @@ exports.outerWidth = outerWidth;
 exports.removeClassName = removeClassName;
 exports.removeEvent = removeEvent;
 exports.removeUserSelectStyles = removeUserSelectStyles;
+
 var _shims = __webpack_require__(108);
+
 var _getPrefix = _interopRequireWildcard(__webpack_require__(422));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-/*:: import type {ControlPosition, PositionOffsetControlPosition, MouseTouchEvent} from './types';*/
-let matchesSelectorFunc = '';
-function matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/{
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var matchesSelectorFunc = '';
+
+function matchesSelector(el
+/*: Node*/
+, selector
+/*: string*/
+)
+/*: boolean*/
+{
   if (!matchesSelectorFunc) {
     matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {
       // $FlowIgnore: Doesn't think elements are indexable
       return (0, _shims.isFunction)(el[method]);
     });
-  }
-
-  // Might not be found entirely (not an Element?) - in that case, bail
+  } // Might not be found entirely (not an Element?) - in that case, bail
   // $FlowIgnore: Doesn't think elements are indexable
-  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false;
 
-  // $FlowIgnore: Doesn't think elements are indexable
+
+  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable
+
   return el[matchesSelectorFunc](selector);
-}
+} // Works up the tree to the draggable itself attempting to match selector.
+
+
+function matchesSelectorAndParentsTo(el
+/*: Node*/
+, selector
+/*: string*/
+, baseNode
+/*: Node*/
+)
+/*: boolean*/
+{
+  var node = el;
 
-// Works up the tree to the draggable itself attempting to match selector.
-function matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/{
-  let node = el;
   do {
     if (matchesSelector(node, selector)) return true;
     if (node === baseNode) return false;
-    // $FlowIgnore[incompatible-type]
     node = node.parentNode;
   } while (node);
+
   return false;
 }
-function addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/, inputOptions /*: Object*/) /*: void*/{
+
+function addEvent(el
+/*: ?Node*/
+, event
+/*: string*/
+, handler
+/*: Function*/
+, inputOptions
+/*: Object*/
+)
+/*: void*/
+{
   if (!el) return;
-  const options = {
-    capture: true,
-    ...inputOptions
-  };
-  // $FlowIgnore[method-unbinding]
+
+  var options = _objectSpread({
+    capture: true
+  }, inputOptions); // $FlowIgnore[method-unbinding]
+
+
   if (el.addEventListener) {
     el.addEventListener(event, handler, options);
   } else if (el.attachEvent) {
@@ -8615,13 +8685,25 @@ function addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/, in
     el['on' + event] = handler;
   }
 }
-function removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/, inputOptions /*: Object*/) /*: void*/{
+
+function removeEvent(el
+/*: ?Node*/
+, event
+/*: string*/
+, handler
+/*: Function*/
+, inputOptions
+/*: Object*/
+)
+/*: void*/
+{
   if (!el) return;
-  const options = {
-    capture: true,
-    ...inputOptions
-  };
-  // $FlowIgnore[method-unbinding]
+
+  var options = _objectSpread({
+    capture: true
+  }, inputOptions); // $FlowIgnore[method-unbinding]
+
+
   if (el.removeEventListener) {
     el.removeEventListener(event, handler, options);
   } else if (el.detachEvent) {
@@ -8631,34 +8713,54 @@ function removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/,
     el['on' + event] = null;
   }
 }
-function outerHeight(node /*: HTMLElement*/) /*: number*/{
+
+function outerHeight(node
+/*: HTMLElement*/
+)
+/*: number*/
+{
   // This is deliberately excluding margin for our calculations, since we are using
   // offsetTop which is including margin. See getBoundPosition
-  let height = node.clientHeight;
-  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
   height += (0, _shims.int)(computedStyle.borderTopWidth);
   height += (0, _shims.int)(computedStyle.borderBottomWidth);
   return height;
 }
-function outerWidth(node /*: HTMLElement*/) /*: number*/{
+
+function outerWidth(node
+/*: HTMLElement*/
+)
+/*: number*/
+{
   // This is deliberately excluding margin for our calculations, since we are using
   // offsetLeft which is including margin. See getBoundPosition
-  let width = node.clientWidth;
-  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
   width += (0, _shims.int)(computedStyle.borderLeftWidth);
   width += (0, _shims.int)(computedStyle.borderRightWidth);
   return width;
 }
-function innerHeight(node /*: HTMLElement*/) /*: number*/{
-  let height = node.clientHeight;
-  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+
+function innerHeight(node
+/*: HTMLElement*/
+)
+/*: number*/
+{
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
   height -= (0, _shims.int)(computedStyle.paddingTop);
   height -= (0, _shims.int)(computedStyle.paddingBottom);
   return height;
 }
-function innerWidth(node /*: HTMLElement*/) /*: number*/{
-  let width = node.clientWidth;
-  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+
+function innerWidth(node
+/*: HTMLElement*/
+)
+/*: number*/
+{
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
   width -= (0, _shims.int)(computedStyle.paddingLeft);
   width -= (0, _shims.int)(computedStyle.paddingRight);
   return width;
@@ -8666,59 +8768,106 @@ function innerWidth(node /*: HTMLElement*/) /*: number*/{
 /*:: interface EventWithOffset {
   clientX: number, clientY: number
 }*/
+
+
 // Get from offsetParent
-function offsetXYFromParent(evt /*: EventWithOffset*/, offsetParent /*: HTMLElement*/, scale /*: number*/) /*: ControlPosition*/{
-  const isBody = offsetParent === offsetParent.ownerDocument.body;
-  const offsetParentRect = isBody ? {
+function offsetXYFromParent(evt
+/*: EventWithOffset*/
+, offsetParent
+/*: HTMLElement*/
+, scale
+/*: number*/
+)
+/*: ControlPosition*/
+{
+  var isBody = offsetParent === offsetParent.ownerDocument.body;
+  var offsetParentRect = isBody ? {
     left: 0,
     top: 0
   } : offsetParent.getBoundingClientRect();
-  const x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
-  const y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
   return {
-    x,
-    y
+    x: x,
+    y: y
   };
 }
-function createCSSTransform(controlPos /*: ControlPosition*/, positionOffset /*: PositionOffsetControlPosition*/) /*: Object*/{
-  const translation = getTranslation(controlPos, positionOffset, 'px');
-  return {
-    [(0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default)]: translation
-  };
+
+function createCSSTransform(controlPos
+/*: ControlPosition*/
+, positionOffset
+/*: PositionOffsetControlPosition*/
+)
+/*: Object*/
+{
+  var translation = getTranslation(controlPos, positionOffset, 'px');
+  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default), translation);
 }
-function createSVGTransform(controlPos /*: ControlPosition*/, positionOffset /*: PositionOffsetControlPosition*/) /*: string*/{
-  const translation = getTranslation(controlPos, positionOffset, '');
+
+function createSVGTransform(controlPos
+/*: ControlPosition*/
+, positionOffset
+/*: PositionOffsetControlPosition*/
+)
+/*: string*/
+{
+  var translation = getTranslation(controlPos, positionOffset, '');
   return translation;
 }
-function getTranslation(_ref /*:: */, positionOffset /*: PositionOffsetControlPosition*/, unitSuffix /*: string*/) /*: string*/{
-  let {
-    x,
-    y
-  } /*: ControlPosition*/ = _ref /*: ControlPosition*/;
-  let translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+
+function getTranslation(_ref2, positionOffset
+/*: PositionOffsetControlPosition*/
+, unitSuffix
+/*: string*/
+)
+/*: string*/
+{
+  var x = _ref2.x,
+      y = _ref2.y;
+  var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+
   if (positionOffset) {
-    const defaultX = "".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);
-    const defaultY = "".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);
+    var defaultX = "".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);
+    var defaultY = "".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);
     translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
   }
+
   return translation;
 }
-function getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/{
-  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, t => identifier === t.identifier) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, t => identifier === t.identifier);
+
+function getTouch(e
+/*: MouseTouchEvent*/
+, identifier
+/*: number*/
+)
+/*: ?{clientX: number, clientY: number}*/
+{
+  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {
+    return identifier === t.identifier;
+  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {
+    return identifier === t.identifier;
+  });
 }
-function getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/{
+
+function getTouchIdentifier(e
+/*: MouseTouchEvent*/
+)
+/*: ?number*/
+{
   if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
   if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
-}
-
-// User-select Hacks:
+} // User-select Hacks:
 //
 // Useful for preventing blue highlights all over everything when dragging.
-
 // Note we're passing `document` b/c we could be iframed
-function addUserSelectStyles(doc /*: ?Document*/) {
+
+
+function addUserSelectStyles(doc
+/*: ?Document*/
+) {
   if (!doc) return;
-  let styleEl = doc.getElementById('react-draggable-style-el');
+  var styleEl = doc.getElementById('react-draggable-style-el');
+
   if (!styleEl) {
     styleEl = doc.createElement('style');
     styleEl.type = 'text/css';
@@ -8727,29 +8876,39 @@ function addUserSelectStyles(doc /*: ?Document*/) {
     styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\n';
     doc.getElementsByTagName('head')[0].appendChild(styleEl);
   }
+
   if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');
 }
-function removeUserSelectStyles(doc /*: ?Document*/) {
+
+function removeUserSelectStyles(doc
+/*: ?Document*/
+) {
   if (!doc) return;
+
   try {
-    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection');
-    // $FlowIgnore: IE
+    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE
+
     if (doc.selection) {
       // $FlowIgnore: IE
       doc.selection.empty();
     } else {
       // Remove selection caused by scroll, unless it's a focused input
       // (we use doc.defaultView in case we're in an iframe)
-      const selection = (doc.defaultView || window).getSelection();
+      var selection = (doc.defaultView || window).getSelection();
+
       if (selection && selection.type !== 'Caret') {
         selection.removeAllRanges();
       }
     }
-  } catch (e) {
-    // probably IE
+  } catch (e) {// probably IE
   }
 }
-function addClassName(el /*: HTMLElement*/, className /*: string*/) {
+
+function addClassName(el
+/*: HTMLElement*/
+, className
+/*: string*/
+) {
   if (el.classList) {
     el.classList.add(className);
   } else {
@@ -8758,7 +8917,12 @@ function addClassName(el /*: HTMLElement*/, className /*: string*/) {
     }
   }
 }
-function removeClassName(el /*: HTMLElement*/, className /*: string*/) {
+
+function removeClassName(el
+/*: HTMLElement*/
+, className
+/*: string*/
+) {
   if (el.classList) {
     el.classList.remove(className);
   } else {
@@ -9187,7 +9351,7 @@ if (true) {
 /* 166 */
 /***/ (function(module) {
 
-module.exports = {"name":"@sis-cc/dotstatsuite-visions","version":"12.11.0","description":"Library of visual components","author":"OECD","homepage":"https://visions-qa.siscc.org/#o","license":"MIT","repository":"https://gitlab.com/sis-cc/.stat-suite/dotstatsuite-visions","main":"lib/index.js","module":"es/index.js","engines":{"node":">=14"},"files":["css","es","lib","umd"],"scripts":{"build":"nwb build-react-component --copy-files --no-demo && node scripts/doc && nwb build-demo","build:dev":"nwb build-react-component --copy-files --no-demo","clean":"nwb clean-module && nwb clean-demo","prepublishOnly":"npm run build","start":"nwb serve-react-demo","test":"jest","test:watch":"jest --watch --no-cache","lint":"eslint src/ --color","precommit":"lint-staged"},"dependencies":{"@emotion/react":"^11.13.0","@emotion/styled":"^11.13.0","@hello-pangea/dnd":"^16.6.0","@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","@mui/styles":"^5.16.5","@react-hook/size":"^2.1.1","classnames":"^2.2.6","cross-env":"^7.0.3","date-fns":"^1.30.1","isemail":"^3.2.0","numeral":"^2.0.6","prop-types":"^15.7.2","ramda":"^0.27.0","react-draggable":"^4.4.5","react-error-boundary":"^4.0.10","react-virtualized":"^9.21.2"},"peerDependencies":{"@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","react":"^18","react-dom":"^18"},"devDependencies":{"@babel/eslint-parser":"^7.5.4","@babel/plugin-syntax-dynamic-import":"^7.2.0","@cfaester/enzyme-adapter-react-18":"^0.7.0","@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","@testing-library/jest-dom":"^5.16.5","@testing-library/react":"^14.0.0","babel-jest":"^24.8.0","babel-preset-react-app":"^9.0.0","dox":"^0.9.0","eslint":"^8.39.0","eslint-plugin-import":"^2.27.5","eslint-plugin-jsx-a11y":"^6.7.1","eslint-plugin-prettier":"^4.2.1","eslint-plugin-react":"^7.32.2","eslint-plugin-react-hooks":"^4.6.0","husky":"^2.7.0","identity-obj-proxy":"^3.0.0","jest":"^24.8.0","jss":"^10.10.0","jss-rtl":"^0.2.3","lint-staged":"^8.2.1","mutationobserver-shim":"^0.3.7","nwb":"0.23.0","prettier":"^2.8.8","pretty-quick":"^3.1.3","react":"^18","react-a11y":"^1.1.0","react-dom":"^18","react-helmet":"^5.2.1","react-scrollable-anchor":"^0.6.1","react-syntax-highlighter":"^10.2.1","sanitize-html":"2.7.0","webpack":"^5.68.0","webpack-cli":"^4.9.2","webpack-dev-server":"^4.7.4"},"jest":{"verbose":true,"coverageDirectory":"coverage","collectCoverageFrom":["src/**/*.{js,jsx,ts,tsx}","!src/ScopeList/*.{js,jsx,ts,tsx}","!src/**/*.d.ts"],"setupFilesAfterEnv":["<rootDir>/tests/setup.js"],"testMatch":["**/tests/**/*.{spec,test}.{js,jsx,ts,tsx}","!**/tests/ScopeList.test.js"],"testEnvironment":"jsdom","transform":{"^.+\\.(js|jsx|ts|tsx)$":"<rootDir>/node_modules/babel-jest"},"transformIgnorePatterns":["[/\\\\]node_modules[/\\\\].+\\.(js|jsx|ts|tsx)$","^.+\\.module\\.(css|sass|scss)$"],"modulePaths":[],"moduleNameMapper":{"^react-native$":"react-native-web","^.+\\.module\\.(css|sass|scss)$":"identity-obj-proxy","\\.(jpg|jpeg|png)$":"identity-obj-proxy"},"moduleFileExtensions":["web.js","js","web.ts","ts","web.tsx","tsx","json","web.jsx","jsx","node"]},"babel":{"presets":["react-app"],"plugins":["@babel/plugin-syntax-dynamic-import"]},"eslintConfig":{"env":{"browser":true,"jest":true,"node":true,"es6":true},"extends":["eslint:recommended","plugin:react/recommended","plugin:jsx-a11y/recommended"],"parser":"@babel/eslint-parser","parserOptions":{"babelOptions":{"presets":[["babel-preset-react-app",false],"babel-preset-react-app/test"]},"ecmaFeatures":{"experimentalObjectRestSpread":true,"jsx":true},"sourceType":"module"},"plugins":["prettier","react","import","react-hooks","jsx-a11y"],"rules":{"no-console":"warn","no-unused-vars":"error","react/display-name":"off","react-hooks/rules-of-hooks":"error","react-hooks/exhaustive-deps":"warn","no-use-before-define":"error"}},"browserslist":{"production":[">0.2%","not dead","not op_mini all"],"development":["last 1 chrome version","last 1 firefox version","last 1 safari version"]},"husky":{"hooks":{"pre-commit":"lint-staged"}},"lint-staged":{"src/**/*.{js,css}":["prettier --write","git add","yarn lint"]},"prettier":{"endOfLine":"lf","useTabs":false,"printWidth":100,"tabWidth":2,"singleQuote":true,"trailingComma":"all","bracketSameLine":false,"bracketSpacing":true,"parser":"babel","semi":true,"arrowParens":"avoid"}};
+module.exports = {"name":"@sis-cc/dotstatsuite-visions","version":"12.12.1","description":"Library of visual components","author":"OECD","homepage":"https://visions-qa.siscc.org/#o","license":"MIT","repository":"https://gitlab.com/sis-cc/.stat-suite/dotstatsuite-visions","main":"lib/index.js","module":"es/index.js","engines":{"node":">=14"},"files":["css","es","lib","umd"],"scripts":{"build":"nwb build-react-component --copy-files --no-demo && node scripts/doc && nwb build-demo","build:dev":"nwb build-react-component --copy-files --no-demo","clean":"nwb clean-module && nwb clean-demo","prepublishOnly":"npm run build","start":"nwb serve-react-demo","test":"jest","test:watch":"jest --watch --no-cache","lint":"eslint src/ --color","precommit":"lint-staged"},"dependencies":{"@emotion/react":"^11.13.0","@emotion/styled":"^11.13.0","@hello-pangea/dnd":"^16.6.0","@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","@mui/styles":"^5.16.5","@react-hook/size":"^2.1.1","classnames":"^2.2.6","cross-env":"^7.0.3","date-fns":"^1.30.1","isemail":"^3.2.0","numeral":"^2.0.6","prop-types":"^15.7.2","ramda":"^0.27.0","react-draggable":"4.4.5","react-error-boundary":"^4.0.10","react-virtualized":"^9.21.2"},"peerDependencies":{"@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","react":"^18","react-dom":"^18"},"devDependencies":{"@babel/eslint-parser":"^7.5.4","@babel/plugin-syntax-dynamic-import":"^7.2.0","@cfaester/enzyme-adapter-react-18":"^0.7.0","@mui/icons-material":"^5.16.5","@mui/material":"^5.16.5","@testing-library/jest-dom":"^5.16.5","@testing-library/react":"^14.0.0","babel-jest":"^24.8.0","babel-preset-react-app":"^9.0.0","dox":"^0.9.0","eslint":"^8.39.0","eslint-plugin-import":"^2.27.5","eslint-plugin-jsx-a11y":"^6.7.1","eslint-plugin-prettier":"^4.2.1","eslint-plugin-react":"^7.32.2","eslint-plugin-react-hooks":"^4.6.0","husky":"^2.7.0","identity-obj-proxy":"^3.0.0","jest":"^24.8.0","jss":"^10.10.0","jss-rtl":"^0.2.3","lint-staged":"^8.2.1","mutationobserver-shim":"^0.3.7","nwb":"0.23.0","prettier":"^2.8.8","pretty-quick":"^3.1.3","react":"^18","react-a11y":"^1.1.0","react-dom":"^18","react-helmet":"^5.2.1","react-scrollable-anchor":"^0.6.1","react-syntax-highlighter":"^10.2.1","sanitize-html":"2.7.0","webpack":"^5.68.0","webpack-cli":"^4.9.2","webpack-dev-server":"^4.7.4"},"jest":{"verbose":true,"coverageDirectory":"coverage","collectCoverageFrom":["src/**/*.{js,jsx,ts,tsx}","!src/ScopeList/*.{js,jsx,ts,tsx}","!src/**/*.d.ts"],"setupFilesAfterEnv":["<rootDir>/tests/setup.js"],"testMatch":["**/tests/**/*.{spec,test}.{js,jsx,ts,tsx}","!**/tests/ScopeList.test.js"],"testEnvironment":"jsdom","transform":{"^.+\\.(js|jsx|ts|tsx)$":"<rootDir>/node_modules/babel-jest"},"transformIgnorePatterns":["[/\\\\]node_modules[/\\\\].+\\.(js|jsx|ts|tsx)$","^.+\\.module\\.(css|sass|scss)$"],"modulePaths":[],"moduleNameMapper":{"^react-native$":"react-native-web","^.+\\.module\\.(css|sass|scss)$":"identity-obj-proxy","\\.(jpg|jpeg|png)$":"identity-obj-proxy"},"moduleFileExtensions":["web.js","js","web.ts","ts","web.tsx","tsx","json","web.jsx","jsx","node"]},"babel":{"presets":["react-app"],"plugins":["@babel/plugin-syntax-dynamic-import"]},"eslintConfig":{"env":{"browser":true,"jest":true,"node":true,"es6":true},"extends":["eslint:recommended","plugin:react/recommended","plugin:jsx-a11y/recommended"],"parser":"@babel/eslint-parser","parserOptions":{"babelOptions":{"presets":[["babel-preset-react-app",false],"babel-preset-react-app/test"]},"ecmaFeatures":{"experimentalObjectRestSpread":true,"jsx":true},"sourceType":"module"},"plugins":["prettier","react","import","react-hooks","jsx-a11y"],"rules":{"no-console":"warn","no-unused-vars":"error","react/display-name":"off","react-hooks/rules-of-hooks":"error","react-hooks/exhaustive-deps":"warn","no-use-before-define":"error"}},"browserslist":{"production":[">0.2%","not dead","not op_mini all"],"development":["last 1 chrome version","last 1 firefox version","last 1 safari version"]},"husky":{"hooks":{"pre-commit":"lint-staged"}},"lint-staged":{"src/**/*.{js,css}":["prettier --write","git add","yarn lint"]},"prettier":{"endOfLine":"lf","useTabs":false,"printWidth":100,"tabWidth":2,"singleQuote":true,"trailingComma":"all","bracketSameLine":false,"bracketSpacing":true,"parser":"babel","semi":true,"arrowParens":"avoid"}};
 
 /***/ }),
 /* 167 */
@@ -11051,110 +11215,163 @@ exports.createDraggableData = createDraggableData;
 exports.getBoundPosition = getBoundPosition;
 exports.getControlPosition = getControlPosition;
 exports.snapToGrid = snapToGrid;
+
 var _shims = __webpack_require__(108);
+
 var _domFns = __webpack_require__(138);
-/*:: import type Draggable from '../Draggable';*/
-/*:: import type {Bounds, ControlPosition, DraggableData, MouseTouchEvent} from './types';*/
-/*:: import type DraggableCore from '../DraggableCore';*/
-function getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/{
+
+function getBoundPosition(draggable
+/*: Draggable*/
+, x
+/*: number*/
+, y
+/*: number*/
+)
+/*: [number, number]*/
+{
   // If no bounds, short-circuit and move on
-  if (!draggable.props.bounds) return [x, y];
+  if (!draggable.props.bounds) return [x, y]; // Clone new bounds
 
-  // Clone new bounds
-  let {
-    bounds
-  } = draggable.props;
+  var bounds = draggable.props.bounds;
   bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);
-  const node = findDOMNode(draggable);
+  var node = findDOMNode(draggable);
+
   if (typeof bounds === 'string') {
-    const {
-      ownerDocument
-    } = node;
-    const ownerWindow = ownerDocument.defaultView;
-    let boundNode;
+    var ownerDocument = node.ownerDocument;
+    var ownerWindow = ownerDocument.defaultView;
+    var boundNode;
+
     if (bounds === 'parent') {
       boundNode = node.parentNode;
     } else {
       boundNode = ownerDocument.querySelector(bounds);
     }
+
     if (!(boundNode instanceof ownerWindow.HTMLElement)) {
       throw new Error('Bounds selector "' + bounds + '" could not find an element.');
     }
-    const boundNodeEl /*: HTMLElement*/ = boundNode; // for Flow, can't seem to refine correctly
-    const nodeStyle = ownerWindow.getComputedStyle(node);
-    const boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);
-    // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.
+
+    var boundNodeEl
+    /*: HTMLElement*/
+    = boundNode; // for Flow, can't seem to refine correctly
+
+    var nodeStyle = ownerWindow.getComputedStyle(node);
+    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.
+
     bounds = {
       left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
       top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
       right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
       bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
     };
-  }
+  } // Keep x and y below right and bottom limits...
+
 
-  // Keep x and y below right and bottom limits...
   if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);
-  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);
+  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom); // But above left and top limits.
 
-  // But above left and top limits.
   if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);
   if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);
   return [x, y];
 }
-function snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/{
-  const x = Math.round(pendingX / grid[0]) * grid[0];
-  const y = Math.round(pendingY / grid[1]) * grid[1];
+
+function snapToGrid(grid
+/*: [number, number]*/
+, pendingX
+/*: number*/
+, pendingY
+/*: number*/
+)
+/*: [number, number]*/
+{
+  var x = Math.round(pendingX / grid[0]) * grid[0];
+  var y = Math.round(pendingY / grid[1]) * grid[1];
   return [x, y];
 }
-function canDragX(draggable /*: Draggable*/) /*: boolean*/{
+
+function canDragX(draggable
+/*: Draggable*/
+)
+/*: boolean*/
+{
   return draggable.props.axis === 'both' || draggable.props.axis === 'x';
 }
-function canDragY(draggable /*: Draggable*/) /*: boolean*/{
+
+function canDragY(draggable
+/*: Draggable*/
+)
+/*: boolean*/
+{
   return draggable.props.axis === 'both' || draggable.props.axis === 'y';
-}
+} // Get {x, y} positions from event.
 
-// Get {x, y} positions from event.
-function getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/{
-  const touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
+
+function getControlPosition(e
+/*: MouseTouchEvent*/
+, touchIdentifier
+/*: ?number*/
+, draggableCore
+/*: DraggableCore*/
+)
+/*: ?ControlPosition*/
+{
+  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
   if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch
-  const node = findDOMNode(draggableCore);
-  // User can provide an offsetParent if desired.
-  const offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+
+  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.
+
+  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
   return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
-}
+} // Create an data object exposed by <DraggableCore>'s events
+
+
+function createCoreData(draggable
+/*: DraggableCore*/
+, x
+/*: number*/
+, y
+/*: number*/
+)
+/*: DraggableData*/
+{
+  var state = draggable.state;
+  var isStart = !(0, _shims.isNum)(state.lastX);
+  var node = findDOMNode(draggable);
 
-// Create an data object exposed by <DraggableCore>'s events
-function createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/{
-  const isStart = !(0, _shims.isNum)(draggable.lastX);
-  const node = findDOMNode(draggable);
   if (isStart) {
     // If this is our first move, use the x and y as last coords.
     return {
-      node,
+      node: node,
       deltaX: 0,
       deltaY: 0,
       lastX: x,
       lastY: y,
-      x,
-      y
+      x: x,
+      y: y
     };
   } else {
     // Otherwise calculate proper values.
     return {
-      node,
-      deltaX: x - draggable.lastX,
-      deltaY: y - draggable.lastY,
-      lastX: draggable.lastX,
-      lastY: draggable.lastY,
-      x,
-      y
+      node: node,
+      deltaX: x - state.lastX,
+      deltaY: y - state.lastY,
+      lastX: state.lastX,
+      lastY: state.lastY,
+      x: x,
+      y: y
     };
   }
-}
+} // Create an data exposed by <Draggable>'s events
+
 
-// Create an data exposed by <Draggable>'s events
-function createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/{
-  const scale = draggable.props.scale;
+function createDraggableData(draggable
+/*: Draggable*/
+, coreData
+/*: DraggableData*/
+)
+/*: DraggableData*/
+{
+  var scale = draggable.props.scale;
   return {
     node: coreData.node,
     x: draggable.state.x + coreData.deltaX / scale,
@@ -11164,10 +11381,14 @@ function createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableDa
     lastX: draggable.state.x,
     lastY: draggable.state.y
   };
-}
+} // A lot faster than stringify/parse
+
 
-// A lot faster than stringify/parse
-function cloneBounds(bounds /*: Bounds*/) /*: Bounds*/{
+function cloneBounds(bounds
+/*: Bounds*/
+)
+/*: Bounds*/
+{
   return {
     left: bounds.left,
     top: bounds.top,
@@ -11175,12 +11396,19 @@ function cloneBounds(bounds /*: Bounds*/) /*: Bounds*/{
     bottom: bounds.bottom
   };
 }
-function findDOMNode(draggable /*: Draggable | DraggableCore*/) /*: HTMLElement*/{
-  const node = draggable.findDOMNode();
+
+function findDOMNode(draggable
+/*: Draggable | DraggableCore*/
+)
+/*: HTMLElement*/
+{
+  var node = draggable.findDOMNode();
+
   if (!node) {
     throw new Error('<DraggableCore>: Unmounted during event!');
-  }
-  // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME
+  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME
+
+
   return node;
 }
 
@@ -11195,9 +11423,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = log;
+
 /*eslint no-console:0*/
 function log() {
-  if (undefined) console.log(...arguments);
+  var _console;
+
+  if (undefined) (_console = console).log.apply(_console, arguments);
 }
 
 /***/ }),
@@ -13215,14 +13446,13 @@ var _default = exports.default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _
 "use strict";
 
 
-const {
-  default: Draggable,
-  DraggableCore
-} = __webpack_require__(420);
-
-// Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.
+var _require = __webpack_require__(420),
+    Draggable = _require.default,
+    DraggableCore = _require.DraggableCore; // Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.
 // See https://github.com/mzabriskie/react-draggable/pull/254
 // and https://github.com/mzabriskie/react-draggable/issues/266
+
+
 module.exports = Draggable;
 module.exports.default = Draggable;
 module.exports.DraggableCore = DraggableCore;
@@ -24558,174 +24788,196 @@ function defaultOverscanIndicesGetter(_ref) {
 "use strict";
 
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "DraggableCore", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _DraggableCore.default;
   }
 });
 exports.default = void 0;
+
 var React = _interopRequireWildcard(__webpack_require__(0));
+
 var _propTypes = _interopRequireDefault(__webpack_require__(1));
+
 var _reactDom = _interopRequireDefault(__webpack_require__(38));
-var _clsx = _interopRequireDefault(__webpack_require__(421));
+
+var _clsx2 = _interopRequireDefault(__webpack_require__(421));
+
 var _domFns = __webpack_require__(138);
+
 var _positionFns = __webpack_require__(210);
+
 var _shims = __webpack_require__(108);
+
 var _DraggableCore = _interopRequireDefault(__webpack_require__(423));
+
 var _log = _interopRequireDefault(__webpack_require__(211));
+
+var _excluded = ["axis", "bounds", "children", "defaultPosition", "defaultClassName", "defaultClassNameDragging", "defaultClassNameDragged", "position", "positionOffset", "scale"];
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /*:: 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,
-};*/
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 //
 // 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);
+var Draggable = /*#__PURE__*/function (_React$Component) {
+  _inherits(Draggable, _React$Component);
+
+  var _super = _createSuper(Draggable);
+
+  function Draggable(props
+  /*: DraggableProps*/
+  ) {
+    var _this;
+
+    _classCallCheck(this, Draggable);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "onDragStart", function (e, coreData) {
+      (0, _log.default)('Draggable: onDragStart: %j', coreData); // Short-circuit if user's callback killed it.
+
+      var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData)); // Kills start event on core as well, so move handlers are never bound.
+
 
-      // 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({
+
+      _this.setState({
         dragging: true,
         dragged: true
       });
     });
-    _defineProperty(this, "onDrag", (e, coreData) => {
-      if (!this.state.dragging) return false;
+
+    _defineProperty(_assertThisInitialized(_this), "onDrag", function (e, coreData) {
+      if (!_this.state.dragging) return false;
       (0, _log.default)('Draggable: onDrag: %j', coreData);
-      const uiData = (0, _positionFns.createDraggableData)(this, coreData);
-      const newState = {
+      var uiData = (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData);
+      var newState
+      /*: $Shape<DraggableState>*/
+      = {
         x: uiData.x,
-        y: uiData.y,
-        slackX: 0,
-        slackY: 0
-      };
+        y: uiData.y
+      }; // Keep within bounds.
 
-      // Keep within bounds.
-      if (this.props.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
+        var x = newState.x,
+            y = newState.y; // 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 += _this.state.slackX;
+        newState.y += _this.state.slackY; // Get bound position. This will ceil/floor the x and y within the boundaries.
+
+        var _getBoundPosition = (0, _positionFns.getBoundPosition)(_assertThisInitialized(_this), newState.x, newState.y),
+            _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2),
+            newStateX = _getBoundPosition2[0],
+            newStateY = _getBoundPosition2[1];
+
         newState.x = newStateX;
-        newState.y = newStateY;
+        newState.y = newStateY; // Recalculate slack by noting how much was shaved by the boundPosition handler.
 
-        // 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);
+        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.
 
-        // 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;
-      }
+        uiData.deltaX = newState.x - _this.state.x;
+        uiData.deltaY = newState.y - _this.state.y;
+      } // Short-circuit if user's callback killed it.
+
+
+      var shouldUpdate = _this.props.onDrag(e, uiData);
 
-      // Short-circuit if user's callback killed it.
-      const shouldUpdate = this.props.onDrag(e, uiData);
       if (shouldUpdate === false) return false;
-      this.setState(newState);
+
+      _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));
+    _defineProperty(_assertThisInitialized(_this), "onDragStop", function (e, coreData) {
+      if (!_this.state.dragging) return false; // Short-circuit if user's callback killed it.
+
+      var shouldContinue = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData));
+
       if (shouldContinue === false) return false;
       (0, _log.default)('Draggable: onDragStop: %j', coreData);
-      const newState /*: Partial<DraggableState>*/ = {
+      var newState
+      /*: $Shape<DraggableState>*/
+      = {
         dragging: false,
         slackX: 0,
         slackY: 0
-      };
-
-      // If this is a controlled component, the result of this operation will be to
+      }; // 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);
+
+      var controlled = Boolean(_this.props.position);
+
       if (controlled) {
-        const {
-          x,
-          y
-        } = this.props.position;
+        var _this$props$position = _this.props.position,
+            x = _this$props$position.x,
+            y = _this$props$position.y;
         newState.x = x;
         newState.y = y;
       }
-      this.setState(newState);
+
+      _this.setState(newState);
     });
-    this.state = {
+
+    _this.state = {
       // Whether or not we are currently dragging.
       dragging: false,
       // Whether or not we have been dragged before.
@@ -24733,106 +24985,142 @@ class Draggable extends React.Component /*:: <DraggableProps, DraggableState>*/{
       // 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
-      },
+      prevPropsPosition: _objectSpread({}, 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.');
     }
+
+    return _this;
   }
-  componentDidMount() {
-    // Check to see if the element passed is an instanceof SVGElement
-    if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {
+
+  _createClass(Draggable, [{
+    key: "componentDidMount",
+    value: function 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
+        });
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
       this.setState({
-        isElementSVG: true
-      });
+        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.
+
+  }, {
+    key: "findDOMNode",
+    value: function findDOMNode()
+    /*: ?HTMLElement*/
+    {
+      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;
+
+      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);
     }
-  }
-  componentWillUnmount() {
-    this.setState({
-      dragging: false
-    }); // prevents invariant if unmounted while dragging
-  }
+  }, {
+    key: "render",
+    value: function render()
+    /*: ReactElement<any>*/
+    {
+      var _clsx;
 
-  // 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*/{
-    var _this$props$nodeRef$c, _this$props;
-    return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 || (_this$props = _this$props.nodeRef) === null || _this$props === void 0 ? void 0 : _this$props.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _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
-    };
+      var _this$props2 = this.props,
+          axis = _this$props2.axis,
+          bounds = _this$props2.bounds,
+          children = _this$props2.children,
+          defaultPosition = _this$props2.defaultPosition,
+          defaultClassName = _this$props2.defaultClassName,
+          defaultClassNameDragging = _this$props2.defaultClassNameDragging,
+          defaultClassNameDragged = _this$props2.defaultClassNameDragged,
+          position = _this$props2.position,
+          positionOffset = _this$props2.positionOffset,
+          scale = _this$props2.scale,
+          draggableCoreProps = _objectWithoutProperties(_this$props2, _excluded);
+
+      var style = {};
+      var svgTransform = null; // If this is controlled, we don't want to move it - unless it's dragging.
+
+      var controlled = Boolean(position);
+      var draggable = !controlled || this.state.dragging;
+      var validPosition = position || defaultPosition;
+      var 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
+
+
+      var className = (0, _clsx2.default)(children.props.className || '', defaultClassName, (_clsx = {}, _defineProperty(_clsx, defaultClassNameDragging, this.state.dragging), _defineProperty(_clsx, defaultClassNameDragged, this.state.dragged), _clsx)); // 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: _objectSpread(_objectSpread({}, children.props.style), style),
+        transform: svgTransform
+      }));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: // React 16.3+
+    // Arity (props, state)
+    function getDerivedStateFromProps(_ref, _ref2)
+    /*: ?$Shape<DraggableState>*/
+    {
+      var position = _ref.position;
+      var prevPropsPosition = _ref2.prevPropsPosition;
+
+      // 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: position,
+          prevPropsPosition: prevPropsPosition
+        });
+        return {
+          x: position.x,
+          y: position.y,
+          prevPropsPosition: _objectSpread({}, position)
+        };
+      }
 
-    // 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);
+      return null;
     }
+  }]);
 
-    // Mark with class while dragging
-    const className = (0, _clsx.default)(children.props.className || '', defaultClassName, {
-      [defaultClassNameDragging]: this.state.dragging,
-      [defaultClassNameDragged]: this.state.dragged
-    });
+  return Draggable;
+}(React.Component);
 
-    // 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,
+
+_defineProperty(Draggable, "propTypes", _objectSpread(_objectSpread({}, _DraggableCore.default.propTypes), {}, {
   /**
    * `axis` determines which axis the draggable can move.
    *
@@ -24847,6 +25135,7 @@ _defineProperty(Draggable, "propTypes", {
    * Defaults to 'both'.
    */
   axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),
+
   /**
    * `bounds` determines the range of movement available to the element.
    * Available values are:
@@ -24882,6 +25171,7 @@ _defineProperty(Draggable, "propTypes", {
   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
    *
@@ -24907,6 +25197,7 @@ _defineProperty(Draggable, "propTypes", {
     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.
    *
@@ -24931,15 +25222,16 @@ _defineProperty(Draggable, "propTypes", {
     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,
+}));
+
+_defineProperty(Draggable, "defaultProps", _objectSpread(_objectSpread({}, _DraggableCore.default.defaultProps), {}, {
   axis: 'both',
   bounds: false,
   defaultClassName: 'react-draggable',
@@ -24950,7 +25242,7 @@ _defineProperty(Draggable, "defaultProps", {
     y: 0
   },
   scale: 1
-});
+}));
 
 /***/ }),
 /* 421 */
@@ -24975,34 +25267,61 @@ exports.browserPrefixToKey = browserPrefixToKey;
 exports.browserPrefixToStyle = browserPrefixToStyle;
 exports.default = void 0;
 exports.getPrefix = getPrefix;
-const prefixes = ['Moz', 'Webkit', 'O', 'ms'];
-function getPrefix() /*: string*/{
-  var _window$document;
-  let prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
+var prefixes = ['Moz', 'Webkit', 'O', 'ms'];
+
+function getPrefix()
+/*: string*/
+{
+  var _window$document, _window$document$docu;
+
+  var prop
+  /*: string*/
+  = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
   // Ensure we're running in an environment where there is actually a global
   // `window` obj
-  if (typeof window === 'undefined') return '';
-
-  // If we're in a pseudo-browser server-side environment, this access
+  if (typeof window === 'undefined') return ''; // If we're in a pseudo-browser server-side environment, this access
   // path may not exist, so bail out if it doesn't.
-  const style = (_window$document = window.document) === null || _window$document === void 0 || (_window$document = _window$document.documentElement) === null || _window$document === void 0 ? void 0 : _window$document.style;
+
+  var style = (_window$document = window.document) === null || _window$document === void 0 ? void 0 : (_window$document$docu = _window$document.documentElement) === null || _window$document$docu === void 0 ? void 0 : _window$document$docu.style;
   if (!style) return '';
   if (prop in style) return '';
-  for (let i = 0; i < prefixes.length; i++) {
+
+  for (var i = 0; i < prefixes.length; i++) {
     if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];
   }
+
   return '';
 }
-function browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/{
+
+function browserPrefixToKey(prop
+/*: string*/
+, prefix
+/*: string*/
+)
+/*: string*/
+{
   return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
 }
-function browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/{
+
+function browserPrefixToStyle(prop
+/*: string*/
+, prefix
+/*: string*/
+)
+/*: string*/
+{
   return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
 }
-function kebabToTitleCase(str /*: string*/) /*: string*/{
-  let out = '';
-  let shouldCapitalize = true;
-  for (let i = 0; i < str.length; i++) {
+
+function kebabToTitleCase(str
+/*: string*/
+)
+/*: string*/
+{
+  var out = '';
+  var shouldCapitalize = true;
+
+  for (var i = 0; i < str.length; i++) {
     if (shouldCapitalize) {
       out += str[i].toUpperCase();
       shouldCapitalize = false;
@@ -25012,13 +25331,18 @@ function kebabToTitleCase(str /*: string*/) /*: string*/{
       out += str[i];
     }
   }
-  return out;
-}
 
-// Default export is the prefix itself, like 'Moz', 'Webkit', etc
+  return out;
+} // Default export is the prefix itself, like 'Moz', 'Webkit', etc
 // Note that you may have to re-test for certain things; for instance, Chrome 50
 // can handle unprefixed `transform`, but not unprefixed `user-select`
-var _default = exports.default = (getPrefix() /*: string*/);
+
+
+var _default = (getPrefix()
+/*: string*/
+);
+
+exports.default = _default;
 
 /***/ }),
 /* 423 */
@@ -25027,27 +25351,69 @@ var _default = exports.default = (getPrefix() /*: string*/);
 "use strict";
 
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var React = _interopRequireWildcard(__webpack_require__(0));
+
 var _propTypes = _interopRequireDefault(__webpack_require__(1));
+
 var _reactDom = _interopRequireDefault(__webpack_require__(38));
+
 var _domFns = __webpack_require__(138);
+
 var _positionFns = __webpack_require__(210);
+
 var _shims = __webpack_require__(108);
+
 var _log = _interopRequireDefault(__webpack_require__(211));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/*:: import type {EventHandler, MouseTouchEvent} from './utils/types';*/
-/*:: import type {Element as ReactElement} from 'react';*/
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 // Simple abstraction for dragging events names.
-const eventsFor = {
+var eventsFor = {
   touch: {
     start: 'touchstart',
     move: 'touchmove',
@@ -25058,19 +25424,29 @@ const eventsFor = {
     move: 'mousemove',
     stop: 'mouseup'
   }
-};
+}; // Default to mouse events.
+
+var dragEventFor = eventsFor.mouse;
+/*:: type DraggableCoreState = {
+  dragging: boolean,
+  lastX: number,
+  lastY: number,
+  touchIdentifier: ?number
+};*/
 
-// Default to mouse events.
-let dragEventFor = eventsFor.mouse;
 /*:: export type DraggableData = {
   node: HTMLElement,
   x: number, y: number,
   deltaX: number, deltaY: number,
   lastX: number, lastY: number,
 };*/
+
 /*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void | false;*/
+
 /*:: export type ControlPosition = {x: number, y: number};*/
+
 /*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/
+
 /*:: export type DraggableCoreDefaultProps = {
   allowAnyClick: boolean,
   disabled: boolean,
@@ -25081,6 +25457,7 @@ let dragEventFor = eventsFor.mouse;
   onMouseDown: (e: MouseEvent) => void,
   scale: number,
 };*/
+
 /*:: export type DraggableCoreProps = {
   ...DraggableCoreDefaultProps,
   cancel: string,
@@ -25090,240 +25467,305 @@ let dragEventFor = eventsFor.mouse;
   handle: string,
   nodeRef?: ?React.ElementRef<any>,
 };*/
+
 //
 // Define <DraggableCore>.
 //
 // <DraggableCore> is for advanced usage of <Draggable>. It maintains minimal internal state so it can
 // work well with libraries that require more control over the element.
 //
+var DraggableCore = /*#__PURE__*/function (_React$Component) {
+  _inherits(DraggableCore, _React$Component);
 
-class DraggableCore extends React.Component /*:: <DraggableCoreProps>*/{
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "dragging", false);
-    // Used while dragging to determine deltas.
-    _defineProperty(this, "lastX", NaN);
-    _defineProperty(this, "lastY", NaN);
-    _defineProperty(this, "touchIdentifier", null);
-    _defineProperty(this, "mounted", false);
-    _defineProperty(this, "handleDragStart", e => {
+  var _super = _createSuper(DraggableCore);
+
+  function DraggableCore() {
+    var _this;
+
+    _classCallCheck(this, DraggableCore);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      dragging: false,
+      // Used while dragging to determine deltas.
+      lastX: NaN,
+      lastY: NaN,
+      touchIdentifier: null
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "mounted", false);
+
+    _defineProperty(_assertThisInitialized(_this), "handleDragStart", function (e) {
       // Make it possible to attach event handlers on top of this one.
-      this.props.onMouseDown(e);
+      _this.props.onMouseDown(e); // Only accept left-clicks.
+
 
-      // Only accept left-clicks.
-      if (!this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;
+      if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false; // Get nodes. Be sure to grab relative document (could be iframed)
+
+      var thisNode = _this.findDOMNode();
 
-      // Get nodes. Be sure to grab relative document (could be iframed)
-      const thisNode = this.findDOMNode();
       if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {
         throw new Error('<DraggableCore> not mounted on DragStart!');
       }
-      const {
-        ownerDocument
-      } = thisNode;
 
-      // Short circuit if handle or cancel prop was provided and selector doesn't match.
-      if (this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.handle, thisNode) || this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.cancel, thisNode)) {
-        return;
-      }
+      var ownerDocument = thisNode.ownerDocument; // Short circuit if handle or cancel prop was provided and selector doesn't match.
 
-      // Prevent scrolling on mobile devices, like ipad/iphone.
+      if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {
+        return;
+      } // Prevent scrolling on mobile devices, like ipad/iphone.
       // Important that this is after handle/cancel.
-      if (e.type === 'touchstart') e.preventDefault();
 
-      // Set touch identifier in component state if this is a touch event. This allows us to
+
+      if (e.type === 'touchstart') e.preventDefault(); // Set touch identifier in component state if this is a touch event. This allows us to
       // distinguish between individual touches on multitouch screens by identifying which
       // touchpoint was set to this element.
-      const touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
-      this.touchIdentifier = touchIdentifier;
 
-      // Get the current drag point from the event. This is used as the offset.
-      const position = (0, _positionFns.getControlPosition)(e, touchIdentifier, this);
+      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
+
+      _this.setState({
+        touchIdentifier: touchIdentifier
+      }); // Get the current drag point from the event. This is used as the offset.
+
+
+      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));
       if (position == null) return; // not possible but satisfies flow
-      const {
-        x,
-        y
-      } = position;
 
-      // Create an event object with all the data parents need to make a decision here.
-      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
-      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent);
+      var x = position.x,
+          y = position.y; // Create an event object with all the data parents need to make a decision here.
+
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
+      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent); // Call event handler. If it returns explicit false, cancel.
+
+      (0, _log.default)('calling', _this.props.onStart);
 
-      // Call event handler. If it returns explicit false, cancel.
-      (0, _log.default)('calling', this.props.onStart);
-      const shouldUpdate = this.props.onStart(e, coreEvent);
-      if (shouldUpdate === false || this.mounted === false) return;
+      var shouldUpdate = _this.props.onStart(e, coreEvent);
 
-      // Add a style to the body to disable user-select. This prevents text from
+      if (shouldUpdate === false || _this.mounted === false) return; // Add a style to the body to disable user-select. This prevents text from
       // being selected all over the page.
-      if (this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument);
 
-      // Initiate dragging. Set the current x and y as offsets
+      if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument); // Initiate dragging. Set the current x and y as offsets
       // so we know how much we've moved during the drag. This allows us
       // to drag elements around even if they have been moved, without issue.
-      this.dragging = true;
-      this.lastX = x;
-      this.lastY = y;
 
-      // Add events to the document directly so we catch when the user's mouse/touch moves outside of
+      _this.setState({
+        dragging: true,
+        lastX: x,
+        lastY: y
+      }); // Add events to the document directly so we catch when the user's mouse/touch moves outside of
       // this element. We use different events depending on whether or not we have detected that this
       // is a touch-capable device.
-      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, this.handleDrag);
-      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, this.handleDragStop);
+
+
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);
     });
-    _defineProperty(this, "handleDrag", e => {
+
+    _defineProperty(_assertThisInitialized(_this), "handleDrag", function (e) {
       // Get the current drag point from the event. This is used as the offset.
-      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
       if (position == null) return;
-      let {
-        x,
-        y
-      } = position;
-
-      // Snap to grid if prop has been provided
-      if (Array.isArray(this.props.grid)) {
-        let deltaX = x - this.lastX,
-          deltaY = y - this.lastY;
-        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
+      var x = position.x,
+          y = position.y; // Snap to grid if prop has been provided
+
+      if (Array.isArray(_this.props.grid)) {
+        var deltaX = x - _this.state.lastX,
+            deltaY = y - _this.state.lastY;
+
+        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
+
+        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);
+
+        deltaX = _snapToGrid2[0];
+        deltaY = _snapToGrid2[1];
         if (!deltaX && !deltaY) return; // skip useless drag
-        x = this.lastX + deltaX, y = this.lastY + deltaY;
+
+        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
       }
-      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
-      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent);
 
-      // Call event handler. If it returns explicit false, trigger end.
-      const shouldUpdate = this.props.onDrag(e, coreEvent);
-      if (shouldUpdate === false || this.mounted === false) {
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
+      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent); // Call event handler. If it returns explicit false, trigger end.
+
+      var shouldUpdate = _this.props.onDrag(e, coreEvent);
+
+      if (shouldUpdate === false || _this.mounted === false) {
         try {
           // $FlowIgnore
-          this.handleDragStop(new MouseEvent('mouseup'));
+          _this.handleDragStop(new MouseEvent('mouseup'));
         } catch (err) {
           // Old browsers
-          const event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);
-          // I see why this insanity was deprecated
+          var event = ((document.createEvent('MouseEvents')
+          /*: any*/
+          )
+          /*: MouseTouchEvent*/
+          ); // I see why this insanity was deprecated
           // $FlowIgnore
+
           event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
-          this.handleDragStop(event);
+
+          _this.handleDragStop(event);
         }
+
         return;
       }
-      this.lastX = x;
-      this.lastY = y;
+
+      _this.setState({
+        lastX: x,
+        lastY: y
+      });
     });
-    _defineProperty(this, "handleDragStop", e => {
-      if (!this.dragging) return;
-      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+
+    _defineProperty(_assertThisInitialized(_this), "handleDragStop", function (e) {
+      if (!_this.state.dragging) return;
+      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
       if (position == null) return;
-      let {
-        x,
-        y
-      } = position;
-
-      // Snap to grid if prop has been provided
-      if (Array.isArray(this.props.grid)) {
-        let deltaX = x - this.lastX || 0;
-        let deltaY = y - this.lastY || 0;
-        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
-        x = this.lastX + deltaX, y = this.lastY + deltaY;
-      }
-      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
-
-      // Call event handler
-      const shouldContinue = this.props.onStop(e, coreEvent);
-      if (shouldContinue === false || this.mounted === false) return false;
-      const thisNode = this.findDOMNode();
+      var x = position.x,
+          y = position.y; // Snap to grid if prop has been provided
+
+      if (Array.isArray(_this.props.grid)) {
+        var deltaX = x - _this.state.lastX || 0;
+        var deltaY = y - _this.state.lastY || 0;
+
+        var _snapToGrid3 = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
+
+        var _snapToGrid4 = _slicedToArray(_snapToGrid3, 2);
+
+        deltaX = _snapToGrid4[0];
+        deltaY = _snapToGrid4[1];
+        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
+      }
+
+      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y); // Call event handler
+
+      var shouldContinue = _this.props.onStop(e, coreEvent);
+
+      if (shouldContinue === false || _this.mounted === false) return false;
+
+      var thisNode = _this.findDOMNode();
+
       if (thisNode) {
         // Remove user-select hack
-        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
+        if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
       }
-      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent);
 
-      // Reset the el.
-      this.dragging = false;
-      this.lastX = NaN;
-      this.lastY = NaN;
+      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent); // Reset the el.
+
+      _this.setState({
+        dragging: false,
+        lastX: NaN,
+        lastY: NaN
+      });
+
       if (thisNode) {
         // Remove event handlers
         (0, _log.default)('DraggableCore: Removing handlers');
-        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, this.handleDrag);
-        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, this.handleDragStop);
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);
       }
     });
-    _defineProperty(this, "onMouseDown", e => {
+
+    _defineProperty(_assertThisInitialized(_this), "onMouseDown", function (e) {
       dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse
 
-      return this.handleDragStart(e);
+      return _this.handleDragStart(e);
     });
-    _defineProperty(this, "onMouseUp", e => {
+
+    _defineProperty(_assertThisInitialized(_this), "onMouseUp", function (e) {
       dragEventFor = eventsFor.mouse;
-      return this.handleDragStop(e);
+      return _this.handleDragStop(e);
     });
-    // Same as onMouseDown (start drag), but now consider this a touch device.
-    _defineProperty(this, "onTouchStart", e => {
+
+    _defineProperty(_assertThisInitialized(_this), "onTouchStart", function (e) {
       // We're on a touch device now, so change the event handlers
       dragEventFor = eventsFor.touch;
-      return this.handleDragStart(e);
+      return _this.handleDragStart(e);
     });
-    _defineProperty(this, "onTouchEnd", e => {
+
+    _defineProperty(_assertThisInitialized(_this), "onTouchEnd", function (e) {
       // We're on a touch device now, so change the event handlers
       dragEventFor = eventsFor.touch;
-      return this.handleDragStop(e);
+      return _this.handleDragStop(e);
     });
+
+    return _this;
   }
-  componentDidMount() {
-    this.mounted = true;
-    // Touch handlers must be added with {passive: false} to be cancelable.
-    // https://developers.google.com/web/updates/2017/01/scrolling-intervention
-    const thisNode = this.findDOMNode();
-    if (thisNode) {
-      (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
-        passive: false
-      });
+
+  _createClass(DraggableCore, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.mounted = true; // Touch handlers must be added with {passive: false} to be cancelable.
+      // https://developers.google.com/web/updates/2017/01/scrolling-intervention
+
+      var thisNode = this.findDOMNode();
+
+      if (thisNode) {
+        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+          passive: false
+        });
+      }
     }
-  }
-  componentWillUnmount() {
-    this.mounted = false;
-    // Remove any leftover event handlers. Remove both touch and mouse handlers in case
-    // some browser quirk caused a touch event to fire during a mouse move, or vice versa.
-    const thisNode = this.findDOMNode();
-    if (thisNode) {
-      const {
-        ownerDocument
-      } = thisNode;
-      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
-      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
-      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
-      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
-      (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
-        passive: false
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.mounted = false; // Remove any leftover event handlers. Remove both touch and mouse handlers in case
+      // some browser quirk caused a touch event to fire during a mouse move, or vice versa.
+
+      var thisNode = this.findDOMNode();
+
+      if (thisNode) {
+        var ownerDocument = thisNode.ownerDocument;
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
+        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
+        (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+          passive: false
+        });
+        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);
+      }
+    } // 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.
+
+  }, {
+    key: "findDOMNode",
+    value: function findDOMNode()
+    /*: ?HTMLElement*/
+    {
+      var _this$props, _this$props2, _this$props2$nodeRef;
+
+      return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 ? void 0 : (_this$props2$nodeRef = _this$props2.nodeRef) === null || _this$props2$nodeRef === void 0 ? void 0 : _this$props2$nodeRef.current : _reactDom.default.findDOMNode(this);
+    }
+  }, {
+    key: "render",
+    value: function render()
+    /*: React.Element<any>*/
+    {
+      // Reuse the child provided
+      // This makes it flexible to use whatever element is wanted (div, ul, etc)
+      return /*#__PURE__*/React.cloneElement(React.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
       });
-      if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);
-    }
-  }
-
-  // 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*/{
-    var _this$props, _this$props2;
-    return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 || (_this$props2 = _this$props2.nodeRef) === null || _this$props2 === void 0 ? void 0 : _this$props2.current : _reactDom.default.findDOMNode(this);
-  }
-  render() /*: React.Element<any>*/{
-    // Reuse the child provided
-    // This makes it flexible to use whatever element is wanted (div, ul, etc)
-    return /*#__PURE__*/React.cloneElement(React.Children.only(this.props.children), {
-      // Note: mouseMove handler is attached to document so it will still function
-      // when the user drags quickly and leaves the bounds of the element.
-      onMouseDown: this.onMouseDown,
-      onMouseUp: this.onMouseUp,
-      // onTouchStart is added on `componentDidMount` so they can be added with
-      // {passive: false}, which allows it to cancel. See
-      // https://developers.google.com/web/updates/2017/01/scrolling-intervention
-      onTouchEnd: this.onTouchEnd
-    });
-  }
-}
+    }
+  }]);
+
+  return DraggableCore;
+}(React.Component);
+
 exports.default = DraggableCore;
+
 _defineProperty(DraggableCore, "displayName", 'DraggableCore');
+
 _defineProperty(DraggableCore, "propTypes", {
   /**
    * `allowAnyClick` allows dragging using any mouse button.
@@ -25332,31 +25774,39 @@ _defineProperty(DraggableCore, "propTypes", {
    * Defaults to `false`.
    */
   allowAnyClick: _propTypes.default.bool,
-  children: _propTypes.default.node.isRequired,
+
   /**
    * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
    * with the exception of `onMouseDown`, will not fire.
    */
   disabled: _propTypes.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: _propTypes.default.bool,
+
   /**
    * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
    * instead of using the parent node.
    */
-  offsetParent: function (props /*: DraggableCoreProps*/, propName /*: $Keys<DraggableCoreProps>*/) {
+  offsetParent: function offsetParent(props
+  /*: DraggableCoreProps*/
+  , propName
+  /*: $Keys<DraggableCoreProps>*/
+  ) {
     if (props[propName] && props[propName].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: _propTypes.default.arrayOf(_propTypes.default.number),
+
   /**
    * `handle` specifies a selector to be used as the handle that initiates drag.
    *
@@ -25378,6 +25828,7 @@ _defineProperty(DraggableCore, "propTypes", {
    * ```
    */
   handle: _propTypes.default.string,
+
   /**
    * `cancel` specifies a selector to be used to prevent drag initialization.
    *
@@ -25399,6 +25850,7 @@ _defineProperty(DraggableCore, "propTypes", {
    * ```
    */
   cancel: _propTypes.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`
@@ -25417,30 +25869,36 @@ _defineProperty(DraggableCore, "propTypes", {
    * pointing to the actual child DOM node and not a custom component.
    */
   nodeRef: _propTypes.default.object,
+
   /**
    * Called when dragging starts.
    * If this function returns the boolean false, dragging will be canceled.
    */
   onStart: _propTypes.default.func,
+
   /**
    * Called while dragging.
    * If this function returns the boolean false, dragging will be canceled.
    */
   onDrag: _propTypes.default.func,
+
   /**
    * Called when dragging stops.
    * If this function returns the boolean false, the drag will remain active.
    */
   onStop: _propTypes.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: _propTypes.default.func,
+
   /**
    * `scale`, if set, applies scaling while dragging an element
    */
   scale: _propTypes.default.number,
+
   /**
    * These properties should be defined on the child, not here.
    */
@@ -25448,15 +25906,16 @@ _defineProperty(DraggableCore, "propTypes", {
   style: _shims.dontSetMe,
   transform: _shims.dontSetMe
 });
+
 _defineProperty(DraggableCore, "defaultProps", {
   allowAnyClick: false,
   // by default only accept left click
   disabled: false,
   enableUserSelectHack: true,
-  onStart: function () {},
-  onDrag: function () {},
-  onStop: function () {},
-  onMouseDown: function () {},
+  onStart: function onStart() {},
+  onDrag: function onDrag() {},
+  onStop: function onStop() {},
+  onMouseDown: function onMouseDown() {},
   scale: 1
 });
 
@@ -56476,8 +56935,7 @@ var sisccTheme = function sisccTheme(_ref) {
       share: {
         title: {
           fontWeight: 400,
-          fontFamily: "'Roboto Slab', serif",
-          fontSize: 18
+          fontFamily: "'Roboto Slab', serif"
         }
       },
       spotlight: {