planning

node_modules/react-dnd-html5-backend/dist/cjs/BrowserDetector.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isSafari = exports.isFirefox = void 0;
+
+var _js_utils = require("./utils/js_utils");
+
+var isFirefox = (0, _js_utils.memoize)(function () {
+  return /firefox/i.test(navigator.userAgent);
+});
+exports.isFirefox = isFirefox;
+var isSafari = (0, _js_utils.memoize)(function () {
+  return Boolean(window.safari);
+});
+exports.isSafari = isSafari;

node_modules/react-dnd-html5-backend/dist/cjs/EnterLeaveCounter.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EnterLeaveCounter = void 0;
+
+var _js_utils = require("./utils/js_utils");
+
+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); return Constructor; }
+
+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 EnterLeaveCounter = /*#__PURE__*/function () {
+  function EnterLeaveCounter(isNodeInDocument) {
+    _classCallCheck(this, EnterLeaveCounter);
+
+    _defineProperty(this, "entered", []);
+
+    _defineProperty(this, "isNodeInDocument", void 0);
+
+    this.isNodeInDocument = isNodeInDocument;
+  }
+
+  _createClass(EnterLeaveCounter, [{
+    key: "enter",
+    value: function enter(enteringNode) {
+      var _this = this;
+
+      var previousLength = this.entered.length;
+
+      var isNodeEntered = function isNodeEntered(node) {
+        return _this.isNodeInDocument(node) && (!node.contains || node.contains(enteringNode));
+      };
+
+      this.entered = (0, _js_utils.union)(this.entered.filter(isNodeEntered), [enteringNode]);
+      return previousLength === 0 && this.entered.length > 0;
+    }
+  }, {
+    key: "leave",
+    value: function leave(leavingNode) {
+      var previousLength = this.entered.length;
+      this.entered = (0, _js_utils.without)(this.entered.filter(this.isNodeInDocument), leavingNode);
+      return previousLength > 0 && this.entered.length === 0;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.entered = [];
+    }
+  }]);
+
+  return EnterLeaveCounter;
+}();
+
+exports.EnterLeaveCounter = EnterLeaveCounter;

node_modules/react-dnd-html5-backend/dist/cjs/HTML5BackendImpl.js

@@ -0,0 +1,747 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HTML5BackendImpl = void 0;
+
+var _EnterLeaveCounter = require("./EnterLeaveCounter");
+
+var _OffsetUtils = require("./OffsetUtils");
+
+var _NativeDragSources = require("./NativeDragSources");
+
+var NativeTypes = _interopRequireWildcard(require("./NativeTypes"));
+
+var _OptionsReader = require("./OptionsReader");
+
+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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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); return Constructor; }
+
+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 HTML5BackendImpl = /*#__PURE__*/function () {
+  // React-Dnd Components
+  // Internal State
+  function HTML5BackendImpl(manager, globalContext, options) {
+    var _this = this;
+
+    _classCallCheck(this, HTML5BackendImpl);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "actions", void 0);
+
+    _defineProperty(this, "monitor", void 0);
+
+    _defineProperty(this, "registry", void 0);
+
+    _defineProperty(this, "enterLeaveCounter", void 0);
+
+    _defineProperty(this, "sourcePreviewNodes", new Map());
+
+    _defineProperty(this, "sourcePreviewNodeOptions", new Map());
+
+    _defineProperty(this, "sourceNodes", new Map());
+
+    _defineProperty(this, "sourceNodeOptions", new Map());
+
+    _defineProperty(this, "dragStartSourceIds", null);
+
+    _defineProperty(this, "dropTargetIds", []);
+
+    _defineProperty(this, "dragEnterTargetIds", []);
+
+    _defineProperty(this, "currentNativeSource", null);
+
+    _defineProperty(this, "currentNativeHandle", null);
+
+    _defineProperty(this, "currentDragSourceNode", null);
+
+    _defineProperty(this, "altKeyPressed", false);
+
+    _defineProperty(this, "mouseMoveTimeoutTimer", null);
+
+    _defineProperty(this, "asyncEndDragFrameId", null);
+
+    _defineProperty(this, "dragOverTargetIds", null);
+
+    _defineProperty(this, "lastClientOffset", null);
+
+    _defineProperty(this, "hoverRafId", null);
+
+    _defineProperty(this, "getSourceClientOffset", function (sourceId) {
+      var source = _this.sourceNodes.get(sourceId);
+
+      return source && (0, _OffsetUtils.getNodeClientOffset)(source) || null;
+    });
+
+    _defineProperty(this, "endDragNativeItem", function () {
+      if (!_this.isDraggingNativeItem()) {
+        return;
+      }
+
+      _this.actions.endDrag();
+
+      if (_this.currentNativeHandle) {
+        _this.registry.removeSource(_this.currentNativeHandle);
+      }
+
+      _this.currentNativeHandle = null;
+      _this.currentNativeSource = null;
+    });
+
+    _defineProperty(this, "isNodeInDocument", function (node) {
+      // Check the node either in the main document or in the current context
+      return Boolean(node && _this.document && _this.document.body && _this.document.body.contains(node));
+    });
+
+    _defineProperty(this, "endDragIfSourceWasRemovedFromDOM", function () {
+      var node = _this.currentDragSourceNode;
+
+      if (node == null || _this.isNodeInDocument(node)) {
+        return;
+      }
+
+      if (_this.clearCurrentDragSourceNode() && _this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragStartCapture", function () {
+      _this.clearCurrentDragSourceNode();
+
+      _this.dragStartSourceIds = [];
+    });
+
+    _defineProperty(this, "handleTopDragStart", function (e) {
+      if (e.defaultPrevented) {
+        return;
+      }
+
+      var dragStartSourceIds = _this.dragStartSourceIds;
+      _this.dragStartSourceIds = null;
+      var clientOffset = (0, _OffsetUtils.getEventClientOffset)(e); // Avoid crashing if we missed a drop event or our previous drag died
+
+      if (_this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      } // Don't publish the source just yet (see why below)
+
+
+      _this.actions.beginDrag(dragStartSourceIds || [], {
+        publishSource: false,
+        getSourceClientOffset: _this.getSourceClientOffset,
+        clientOffset: clientOffset
+      });
+
+      var dataTransfer = e.dataTransfer;
+      var nativeType = (0, _NativeDragSources.matchNativeItemType)(dataTransfer);
+
+      if (_this.monitor.isDragging()) {
+        if (dataTransfer && typeof dataTransfer.setDragImage === 'function') {
+          // Use custom drag image if user specifies it.
+          // If child drag source refuses drag but parent agrees,
+          // use parent's node as drag image. Neither works in IE though.
+          var sourceId = _this.monitor.getSourceId();
+
+          var sourceNode = _this.sourceNodes.get(sourceId);
+
+          var dragPreview = _this.sourcePreviewNodes.get(sourceId) || sourceNode;
+
+          if (dragPreview) {
+            var _this$getCurrentSourc = _this.getCurrentSourcePreviewNodeOptions(),
+                anchorX = _this$getCurrentSourc.anchorX,
+                anchorY = _this$getCurrentSourc.anchorY,
+                offsetX = _this$getCurrentSourc.offsetX,
+                offsetY = _this$getCurrentSourc.offsetY;
+
+            var anchorPoint = {
+              anchorX: anchorX,
+              anchorY: anchorY
+            };
+            var offsetPoint = {
+              offsetX: offsetX,
+              offsetY: offsetY
+            };
+            var dragPreviewOffset = (0, _OffsetUtils.getDragPreviewOffset)(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint);
+            dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
+          }
+        }
+
+        try {
+          // Firefox won't drag without setting data
+          dataTransfer === null || dataTransfer === void 0 ? void 0 : dataTransfer.setData('application/json', {});
+        } catch (err) {// IE doesn't support MIME types in setData
+        } // Store drag source node so we can check whether
+        // it is removed from DOM and trigger endDrag manually.
+
+
+        _this.setCurrentDragSourceNode(e.target); // Now we are ready to publish the drag source.. or are we not?
+
+
+        var _this$getCurrentSourc2 = _this.getCurrentSourcePreviewNodeOptions(),
+            captureDraggingState = _this$getCurrentSourc2.captureDraggingState;
+
+        if (!captureDraggingState) {
+          // Usually we want to publish it in the next tick so that browser
+          // is able to screenshot the current (not yet dragging) state.
+          //
+          // It also neatly avoids a situation where render() returns null
+          // in the same tick for the source element, and browser freaks out.
+          setTimeout(function () {
+            return _this.actions.publishDragSource();
+          }, 0);
+        } else {
+          // In some cases the user may want to override this behavior, e.g.
+          // to work around IE not supporting custom drag previews.
+          //
+          // When using a custom drag layer, the only way to prevent
+          // the default drag preview from drawing in IE is to screenshot
+          // the dragging state in which the node itself has zero opacity
+          // and height. In this case, though, returning null from render()
+          // will abruptly end the dragging, which is not obvious.
+          //
+          // This is the reason such behavior is strictly opt-in.
+          _this.actions.publishDragSource();
+        }
+      } else if (nativeType) {
+        // A native item (such as URL) dragged from inside the document
+        _this.beginDragNativeItem(nativeType);
+      } else if (dataTransfer && !dataTransfer.types && (e.target && !e.target.hasAttribute || !e.target.hasAttribute('draggable'))) {
+        // Looks like a Safari bug: dataTransfer.types is null, but there was no draggable.
+        // Just let it drag. It's a native type (URL or text) and will be picked up in
+        // dragenter handler.
+        return;
+      } else {
+        // If by this time no drag source reacted, tell browser not to drag.
+        e.preventDefault();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEndCapture", function () {
+      if (_this.clearCurrentDragSourceNode() && _this.monitor.isDragging()) {
+        // Firefox can dispatch this event in an infinite loop
+        // if dragend handler does something like showing an alert.
+        // Only proceed if we have not handled it already.
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEnterCapture", function (e) {
+      _this.dragEnterTargetIds = [];
+
+      var isFirstEnter = _this.enterLeaveCounter.enter(e.target);
+
+      if (!isFirstEnter || _this.monitor.isDragging()) {
+        return;
+      }
+
+      var dataTransfer = e.dataTransfer;
+      var nativeType = (0, _NativeDragSources.matchNativeItemType)(dataTransfer);
+
+      if (nativeType) {
+        // A native item (such as file or URL) dragged from outside the document
+        _this.beginDragNativeItem(nativeType, dataTransfer);
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEnter", function (e) {
+      var dragEnterTargetIds = _this.dragEnterTargetIds;
+      _this.dragEnterTargetIds = [];
+
+      if (!_this.monitor.isDragging()) {
+        // This is probably a native item type we don't understand.
+        return;
+      }
+
+      _this.altKeyPressed = e.altKey; // If the target changes position as the result of `dragenter`, `dragover` might still
+      // get dispatched despite target being no longer there. The easy solution is to check
+      // whether there actually is a target before firing `hover`.
+
+      if (dragEnterTargetIds.length > 0) {
+        _this.actions.hover(dragEnterTargetIds, {
+          clientOffset: (0, _OffsetUtils.getEventClientOffset)(e)
+        });
+      }
+
+      var canDrop = dragEnterTargetIds.some(function (targetId) {
+        return _this.monitor.canDropOnTarget(targetId);
+      });
+
+      if (canDrop) {
+        // IE requires this to fire dragover events
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = _this.getCurrentDropEffect();
+        }
+      }
+    });
+
+    _defineProperty(this, "handleTopDragOverCapture", function () {
+      _this.dragOverTargetIds = [];
+    });
+
+    _defineProperty(this, "handleTopDragOver", function (e) {
+      var dragOverTargetIds = _this.dragOverTargetIds;
+      _this.dragOverTargetIds = [];
+
+      if (!_this.monitor.isDragging()) {
+        // This is probably a native item type we don't understand.
+        // Prevent default "drop and blow away the whole document" action.
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = 'none';
+        }
+
+        return;
+      }
+
+      _this.altKeyPressed = e.altKey;
+      _this.lastClientOffset = (0, _OffsetUtils.getEventClientOffset)(e);
+
+      if (_this.hoverRafId === null && typeof requestAnimationFrame !== 'undefined') {
+        _this.hoverRafId = requestAnimationFrame(function () {
+          if (_this.monitor.isDragging()) {
+            _this.actions.hover(dragOverTargetIds || [], {
+              clientOffset: _this.lastClientOffset
+            });
+          }
+
+          _this.hoverRafId = null;
+        });
+      }
+
+      var canDrop = (dragOverTargetIds || []).some(function (targetId) {
+        return _this.monitor.canDropOnTarget(targetId);
+      });
+
+      if (canDrop) {
+        // Show user-specified drop effect.
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = _this.getCurrentDropEffect();
+        }
+      } else if (_this.isDraggingNativeItem()) {
+        // Don't show a nice cursor but still prevent default
+        // "drop and blow away the whole document" action.
+        e.preventDefault();
+      } else {
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = 'none';
+        }
+      }
+    });
+
+    _defineProperty(this, "handleTopDragLeaveCapture", function (e) {
+      if (_this.isDraggingNativeItem()) {
+        e.preventDefault();
+      }
+
+      var isLastLeave = _this.enterLeaveCounter.leave(e.target);
+
+      if (!isLastLeave) {
+        return;
+      }
+
+      if (_this.isDraggingNativeItem()) {
+        setTimeout(function () {
+          return _this.endDragNativeItem();
+        }, 0);
+      }
+    });
+
+    _defineProperty(this, "handleTopDropCapture", function (e) {
+      _this.dropTargetIds = [];
+
+      if (_this.isDraggingNativeItem()) {
+        var _this$currentNativeSo;
+
+        e.preventDefault();
+        (_this$currentNativeSo = _this.currentNativeSource) === null || _this$currentNativeSo === void 0 ? void 0 : _this$currentNativeSo.loadDataTransfer(e.dataTransfer);
+      } else if ((0, _NativeDragSources.matchNativeItemType)(e.dataTransfer)) {
+        // Dragging some elements, like <a> and <img> may still behave like a native drag event,
+        // even if the current drag event matches a user-defined type.
+        // Stop the default behavior when we're not expecting a native item to be dropped.
+        e.preventDefault();
+      }
+
+      _this.enterLeaveCounter.reset();
+    });
+
+    _defineProperty(this, "handleTopDrop", function (e) {
+      var dropTargetIds = _this.dropTargetIds;
+      _this.dropTargetIds = [];
+
+      _this.actions.hover(dropTargetIds, {
+        clientOffset: (0, _OffsetUtils.getEventClientOffset)(e)
+      });
+
+      _this.actions.drop({
+        dropEffect: _this.getCurrentDropEffect()
+      });
+
+      if (_this.isDraggingNativeItem()) {
+        _this.endDragNativeItem();
+      } else if (_this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleSelectStart", function (e) {
+      var target = e.target; // Only IE requires us to explicitly say
+      // we want drag drop operation to start
+
+      if (typeof target.dragDrop !== 'function') {
+        return;
+      } // Inputs and textareas should be selectable
+
+
+      if (target.tagName === 'INPUT' || target.tagName === 'SELECT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
+        return;
+      } // For other targets, ask IE
+      // to enable drag and drop
+
+
+      e.preventDefault();
+      target.dragDrop();
+    });
+
+    this.options = new _OptionsReader.OptionsReader(globalContext, options);
+    this.actions = manager.getActions();
+    this.monitor = manager.getMonitor();
+    this.registry = manager.getRegistry();
+    this.enterLeaveCounter = new _EnterLeaveCounter.EnterLeaveCounter(this.isNodeInDocument);
+  }
+  /**
+   * Generate profiling statistics for the HTML5Backend.
+   */
+
+
+  _createClass(HTML5BackendImpl, [{
+    key: "profile",
+    value: function profile() {
+      var _this$dragStartSource, _this$dragOverTargetI;
+
+      return {
+        sourcePreviewNodes: this.sourcePreviewNodes.size,
+        sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+        sourceNodeOptions: this.sourceNodeOptions.size,
+        sourceNodes: this.sourceNodes.size,
+        dragStartSourceIds: ((_this$dragStartSource = this.dragStartSourceIds) === null || _this$dragStartSource === void 0 ? void 0 : _this$dragStartSource.length) || 0,
+        dropTargetIds: this.dropTargetIds.length,
+        dragEnterTargetIds: this.dragEnterTargetIds.length,
+        dragOverTargetIds: ((_this$dragOverTargetI = this.dragOverTargetIds) === null || _this$dragOverTargetI === void 0 ? void 0 : _this$dragOverTargetI.length) || 0
+      };
+    } // public for test
+
+  }, {
+    key: "window",
+    get: function get() {
+      return this.options.window;
+    }
+  }, {
+    key: "document",
+    get: function get() {
+      return this.options.document;
+    }
+    /**
+     * Get the root element to use for event subscriptions
+     */
+
+  }, {
+    key: "rootElement",
+    get: function get() {
+      return this.options.rootElement;
+    }
+  }, {
+    key: "setup",
+    value: function setup() {
+      var root = this.rootElement;
+
+      if (root === undefined) {
+        return;
+      }
+
+      if (root.__isReactDndBackendSetUp) {
+        throw new Error('Cannot have two HTML5 backends at the same time.');
+      }
+
+      root.__isReactDndBackendSetUp = true;
+      this.addEventListeners(root);
+    }
+  }, {
+    key: "teardown",
+    value: function teardown() {
+      var root = this.rootElement;
+
+      if (root === undefined) {
+        return;
+      }
+
+      root.__isReactDndBackendSetUp = false;
+      this.removeEventListeners(this.rootElement);
+      this.clearCurrentDragSourceNode();
+
+      if (this.asyncEndDragFrameId) {
+        var _this$window;
+
+        (_this$window = this.window) === null || _this$window === void 0 ? void 0 : _this$window.cancelAnimationFrame(this.asyncEndDragFrameId);
+      }
+    }
+  }, {
+    key: "connectDragPreview",
+    value: function connectDragPreview(sourceId, node, options) {
+      var _this2 = this;
+
+      this.sourcePreviewNodeOptions.set(sourceId, options);
+      this.sourcePreviewNodes.set(sourceId, node);
+      return function () {
+        _this2.sourcePreviewNodes.delete(sourceId);
+
+        _this2.sourcePreviewNodeOptions.delete(sourceId);
+      };
+    }
+  }, {
+    key: "connectDragSource",
+    value: function connectDragSource(sourceId, node, options) {
+      var _this3 = this;
+
+      this.sourceNodes.set(sourceId, node);
+      this.sourceNodeOptions.set(sourceId, options);
+
+      var handleDragStart = function handleDragStart(e) {
+        return _this3.handleDragStart(e, sourceId);
+      };
+
+      var handleSelectStart = function handleSelectStart(e) {
+        return _this3.handleSelectStart(e);
+      };
+
+      node.setAttribute('draggable', 'true');
+      node.addEventListener('dragstart', handleDragStart);
+      node.addEventListener('selectstart', handleSelectStart);
+      return function () {
+        _this3.sourceNodes.delete(sourceId);
+
+        _this3.sourceNodeOptions.delete(sourceId);
+
+        node.removeEventListener('dragstart', handleDragStart);
+        node.removeEventListener('selectstart', handleSelectStart);
+        node.setAttribute('draggable', 'false');
+      };
+    }
+  }, {
+    key: "connectDropTarget",
+    value: function connectDropTarget(targetId, node) {
+      var _this4 = this;
+
+      var handleDragEnter = function handleDragEnter(e) {
+        return _this4.handleDragEnter(e, targetId);
+      };
+
+      var handleDragOver = function handleDragOver(e) {
+        return _this4.handleDragOver(e, targetId);
+      };
+
+      var handleDrop = function handleDrop(e) {
+        return _this4.handleDrop(e, targetId);
+      };
+
+      node.addEventListener('dragenter', handleDragEnter);
+      node.addEventListener('dragover', handleDragOver);
+      node.addEventListener('drop', handleDrop);
+      return function () {
+        node.removeEventListener('dragenter', handleDragEnter);
+        node.removeEventListener('dragover', handleDragOver);
+        node.removeEventListener('drop', handleDrop);
+      };
+    }
+  }, {
+    key: "addEventListeners",
+    value: function addEventListeners(target) {
+      // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
+      if (!target.addEventListener) {
+        return;
+      }
+
+      target.addEventListener('dragstart', this.handleTopDragStart);
+      target.addEventListener('dragstart', this.handleTopDragStartCapture, true);
+      target.addEventListener('dragend', this.handleTopDragEndCapture, true);
+      target.addEventListener('dragenter', this.handleTopDragEnter);
+      target.addEventListener('dragenter', this.handleTopDragEnterCapture, true);
+      target.addEventListener('dragleave', this.handleTopDragLeaveCapture, true);
+      target.addEventListener('dragover', this.handleTopDragOver);
+      target.addEventListener('dragover', this.handleTopDragOverCapture, true);
+      target.addEventListener('drop', this.handleTopDrop);
+      target.addEventListener('drop', this.handleTopDropCapture, true);
+    }
+  }, {
+    key: "removeEventListeners",
+    value: function removeEventListeners(target) {
+      // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
+      if (!target.removeEventListener) {
+        return;
+      }
+
+      target.removeEventListener('dragstart', this.handleTopDragStart);
+      target.removeEventListener('dragstart', this.handleTopDragStartCapture, true);
+      target.removeEventListener('dragend', this.handleTopDragEndCapture, true);
+      target.removeEventListener('dragenter', this.handleTopDragEnter);
+      target.removeEventListener('dragenter', this.handleTopDragEnterCapture, true);
+      target.removeEventListener('dragleave', this.handleTopDragLeaveCapture, true);
+      target.removeEventListener('dragover', this.handleTopDragOver);
+      target.removeEventListener('dragover', this.handleTopDragOverCapture, true);
+      target.removeEventListener('drop', this.handleTopDrop);
+      target.removeEventListener('drop', this.handleTopDropCapture, true);
+    }
+  }, {
+    key: "getCurrentSourceNodeOptions",
+    value: function getCurrentSourceNodeOptions() {
+      var sourceId = this.monitor.getSourceId();
+      var sourceNodeOptions = this.sourceNodeOptions.get(sourceId);
+      return _objectSpread({
+        dropEffect: this.altKeyPressed ? 'copy' : 'move'
+      }, sourceNodeOptions || {});
+    }
+  }, {
+    key: "getCurrentDropEffect",
+    value: function getCurrentDropEffect() {
+      if (this.isDraggingNativeItem()) {
+        // It makes more sense to default to 'copy' for native resources
+        return 'copy';
+      }
+
+      return this.getCurrentSourceNodeOptions().dropEffect;
+    }
+  }, {
+    key: "getCurrentSourcePreviewNodeOptions",
+    value: function getCurrentSourcePreviewNodeOptions() {
+      var sourceId = this.monitor.getSourceId();
+      var sourcePreviewNodeOptions = this.sourcePreviewNodeOptions.get(sourceId);
+      return _objectSpread({
+        anchorX: 0.5,
+        anchorY: 0.5,
+        captureDraggingState: false
+      }, sourcePreviewNodeOptions || {});
+    }
+  }, {
+    key: "isDraggingNativeItem",
+    value: function isDraggingNativeItem() {
+      var itemType = this.monitor.getItemType();
+      return Object.keys(NativeTypes).some(function (key) {
+        return NativeTypes[key] === itemType;
+      });
+    }
+  }, {
+    key: "beginDragNativeItem",
+    value: function beginDragNativeItem(type, dataTransfer) {
+      this.clearCurrentDragSourceNode();
+      this.currentNativeSource = (0, _NativeDragSources.createNativeDragSource)(type, dataTransfer);
+      this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
+      this.actions.beginDrag([this.currentNativeHandle]);
+    }
+  }, {
+    key: "setCurrentDragSourceNode",
+    value: function setCurrentDragSourceNode(node) {
+      var _this5 = this;
+
+      this.clearCurrentDragSourceNode();
+      this.currentDragSourceNode = node; // A timeout of > 0 is necessary to resolve Firefox issue referenced
+      // See:
+      //   * https://github.com/react-dnd/react-dnd/pull/928
+      //   * https://github.com/react-dnd/react-dnd/issues/869
+
+      var MOUSE_MOVE_TIMEOUT = 1000; // Receiving a mouse event in the middle of a dragging operation
+      // means it has ended and the drag source node disappeared from DOM,
+      // so the browser didn't dispatch the dragend event.
+      //
+      // We need to wait before we start listening for mousemove events.
+      // This is needed because the drag preview needs to be drawn or else it fires an 'mousemove' event
+      // immediately in some browsers.
+      //
+      // See:
+      //   * https://github.com/react-dnd/react-dnd/pull/928
+      //   * https://github.com/react-dnd/react-dnd/issues/869
+      //
+
+      this.mouseMoveTimeoutTimer = setTimeout(function () {
+        var _this5$rootElement;
+
+        return (_this5$rootElement = _this5.rootElement) === null || _this5$rootElement === void 0 ? void 0 : _this5$rootElement.addEventListener('mousemove', _this5.endDragIfSourceWasRemovedFromDOM, true);
+      }, MOUSE_MOVE_TIMEOUT);
+    }
+  }, {
+    key: "clearCurrentDragSourceNode",
+    value: function clearCurrentDragSourceNode() {
+      if (this.currentDragSourceNode) {
+        this.currentDragSourceNode = null;
+
+        if (this.rootElement) {
+          var _this$window2;
+
+          (_this$window2 = this.window) === null || _this$window2 === void 0 ? void 0 : _this$window2.clearTimeout(this.mouseMoveTimeoutTimer || undefined);
+          this.rootElement.removeEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
+        }
+
+        this.mouseMoveTimeoutTimer = null;
+        return true;
+      }
+
+      return false;
+    }
+  }, {
+    key: "handleDragStart",
+    value: function handleDragStart(e, sourceId) {
+      if (e.defaultPrevented) {
+        return;
+      }
+
+      if (!this.dragStartSourceIds) {
+        this.dragStartSourceIds = [];
+      }
+
+      this.dragStartSourceIds.unshift(sourceId);
+    }
+  }, {
+    key: "handleDragEnter",
+    value: function handleDragEnter(e, targetId) {
+      this.dragEnterTargetIds.unshift(targetId);
+    }
+  }, {
+    key: "handleDragOver",
+    value: function handleDragOver(e, targetId) {
+      if (this.dragOverTargetIds === null) {
+        this.dragOverTargetIds = [];
+      }
+
+      this.dragOverTargetIds.unshift(targetId);
+    }
+  }, {
+    key: "handleDrop",
+    value: function handleDrop(e, targetId) {
+      this.dropTargetIds.unshift(targetId);
+    }
+  }]);
+
+  return HTML5BackendImpl;
+}();
+
+exports.HTML5BackendImpl = HTML5BackendImpl;

node_modules/react-dnd-html5-backend/dist/cjs/MonotonicInterpolant.js

@@ -0,0 +1,141 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MonotonicInterpolant = void 0;
+
+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); return Constructor; }
+
+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 MonotonicInterpolant = /*#__PURE__*/function () {
+  function MonotonicInterpolant(xs, ys) {
+    _classCallCheck(this, MonotonicInterpolant);
+
+    _defineProperty(this, "xs", void 0);
+
+    _defineProperty(this, "ys", void 0);
+
+    _defineProperty(this, "c1s", void 0);
+
+    _defineProperty(this, "c2s", void 0);
+
+    _defineProperty(this, "c3s", void 0);
+
+    var length = xs.length; // Rearrange xs and ys so that xs is sorted
+
+    var indexes = [];
+
+    for (var i = 0; i < length; i++) {
+      indexes.push(i);
+    }
+
+    indexes.sort(function (a, b) {
+      return xs[a] < xs[b] ? -1 : 1;
+    }); // Get consecutive differences and slopes
+
+    var dys = [];
+    var dxs = [];
+    var ms = [];
+    var dx;
+    var dy;
+
+    for (var _i = 0; _i < length - 1; _i++) {
+      dx = xs[_i + 1] - xs[_i];
+      dy = ys[_i + 1] - ys[_i];
+      dxs.push(dx);
+      dys.push(dy);
+      ms.push(dy / dx);
+    } // Get degree-1 coefficients
+
+
+    var c1s = [ms[0]];
+
+    for (var _i2 = 0; _i2 < dxs.length - 1; _i2++) {
+      var m2 = ms[_i2];
+      var mNext = ms[_i2 + 1];
+
+      if (m2 * mNext <= 0) {
+        c1s.push(0);
+      } else {
+        dx = dxs[_i2];
+        var dxNext = dxs[_i2 + 1];
+        var common = dx + dxNext;
+        c1s.push(3 * common / ((common + dxNext) / m2 + (common + dx) / mNext));
+      }
+    }
+
+    c1s.push(ms[ms.length - 1]); // Get degree-2 and degree-3 coefficients
+
+    var c2s = [];
+    var c3s = [];
+    var m;
+
+    for (var _i3 = 0; _i3 < c1s.length - 1; _i3++) {
+      m = ms[_i3];
+      var c1 = c1s[_i3];
+      var invDx = 1 / dxs[_i3];
+
+      var _common = c1 + c1s[_i3 + 1] - m - m;
+
+      c2s.push((m - c1 - _common) * invDx);
+      c3s.push(_common * invDx * invDx);
+    }
+
+    this.xs = xs;
+    this.ys = ys;
+    this.c1s = c1s;
+    this.c2s = c2s;
+    this.c3s = c3s;
+  }
+
+  _createClass(MonotonicInterpolant, [{
+    key: "interpolate",
+    value: function interpolate(x) {
+      var xs = this.xs,
+          ys = this.ys,
+          c1s = this.c1s,
+          c2s = this.c2s,
+          c3s = this.c3s; // The rightmost point in the dataset should give an exact result
+
+      var i = xs.length - 1;
+
+      if (x === xs[i]) {
+        return ys[i];
+      } // Search for the interval x is in, returning the corresponding y if x is one of the original xs
+
+
+      var low = 0;
+      var high = c3s.length - 1;
+      var mid;
+
+      while (low <= high) {
+        mid = Math.floor(0.5 * (low + high));
+        var xHere = xs[mid];
+
+        if (xHere < x) {
+          low = mid + 1;
+        } else if (xHere > x) {
+          high = mid - 1;
+        } else {
+          return ys[mid];
+        }
+      }
+
+      i = Math.max(0, high); // Interpolate
+
+      var diff = x - xs[i];
+      var diffSq = diff * diff;
+      return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
+    }
+  }]);
+
+  return MonotonicInterpolant;
+}();
+
+exports.MonotonicInterpolant = MonotonicInterpolant;

node_modules/react-dnd-html5-backend/dist/cjs/NativeDragSources/NativeDragSource.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativeDragSource = void 0;
+
+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); return Constructor; }
+
+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 NativeDragSource = /*#__PURE__*/function () {
+  function NativeDragSource(config) {
+    _classCallCheck(this, NativeDragSource);
+
+    _defineProperty(this, "item", void 0);
+
+    _defineProperty(this, "config", void 0);
+
+    this.config = config;
+    this.item = {};
+    this.initializeExposedProperties();
+  }
+
+  _createClass(NativeDragSource, [{
+    key: "initializeExposedProperties",
+    value: function initializeExposedProperties() {
+      var _this = this;
+
+      Object.keys(this.config.exposeProperties).forEach(function (property) {
+        Object.defineProperty(_this.item, property, {
+          configurable: true,
+          enumerable: true,
+          get: function get() {
+            // eslint-disable-next-line no-console
+            console.warn("Browser doesn't allow reading \"".concat(property, "\" until the drop event."));
+            return null;
+          }
+        });
+      });
+    }
+  }, {
+    key: "loadDataTransfer",
+    value: function loadDataTransfer(dataTransfer) {
+      var _this2 = this;
+
+      if (dataTransfer) {
+        var newProperties = {};
+        Object.keys(this.config.exposeProperties).forEach(function (property) {
+          newProperties[property] = {
+            value: _this2.config.exposeProperties[property](dataTransfer, _this2.config.matchesTypes),
+            configurable: true,
+            enumerable: true
+          };
+        });
+        Object.defineProperties(this.item, newProperties);
+      }
+    }
+  }, {
+    key: "canDrag",
+    value: function canDrag() {
+      return true;
+    }
+  }, {
+    key: "beginDrag",
+    value: function beginDrag() {
+      return this.item;
+    }
+  }, {
+    key: "isDragging",
+    value: function isDragging(monitor, handle) {
+      return handle === monitor.getSourceId();
+    }
+  }, {
+    key: "endDrag",
+    value: function endDrag() {// empty
+    }
+  }]);
+
+  return NativeDragSource;
+}();
+
+exports.NativeDragSource = NativeDragSource;

node_modules/react-dnd-html5-backend/dist/cjs/NativeDragSources/getDataFromDataTransfer.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDataFromDataTransfer = getDataFromDataTransfer;
+
+function getDataFromDataTransfer(dataTransfer, typesToTry, defaultValue) {
+  var result = typesToTry.reduce(function (resultSoFar, typeToTry) {
+    return resultSoFar || dataTransfer.getData(typeToTry);
+  }, '');
+  return result != null ? result : defaultValue;
+}

node_modules/react-dnd-html5-backend/dist/cjs/NativeDragSources/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNativeDragSource = createNativeDragSource;
+exports.matchNativeItemType = matchNativeItemType;
+
+var _nativeTypesConfig = require("./nativeTypesConfig");
+
+var _NativeDragSource = require("./NativeDragSource");
+
+function createNativeDragSource(type, dataTransfer) {
+  var result = new _NativeDragSource.NativeDragSource(_nativeTypesConfig.nativeTypesConfig[type]);
+  result.loadDataTransfer(dataTransfer);
+  return result;
+}
+
+function matchNativeItemType(dataTransfer) {
+  if (!dataTransfer) {
+    return null;
+  }
+
+  var dataTransferTypes = Array.prototype.slice.call(dataTransfer.types || []);
+  return Object.keys(_nativeTypesConfig.nativeTypesConfig).filter(function (nativeItemType) {
+    var matchesTypes = _nativeTypesConfig.nativeTypesConfig[nativeItemType].matchesTypes;
+    return matchesTypes.some(function (t) {
+      return dataTransferTypes.indexOf(t) > -1;
+    });
+  })[0] || null;
+}

node_modules/react-dnd-html5-backend/dist/cjs/NativeDragSources/nativeTypesConfig.js

@@ -0,0 +1,66 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nativeTypesConfig = void 0;
+
+var NativeTypes = _interopRequireWildcard(require("../NativeTypes"));
+
+var _getDataFromDataTransfer = require("./getDataFromDataTransfer");
+
+var _nativeTypesConfig;
+
+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 _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 nativeTypesConfig = (_nativeTypesConfig = {}, _defineProperty(_nativeTypesConfig, NativeTypes.FILE, {
+  exposeProperties: {
+    files: function files(dataTransfer) {
+      return Array.prototype.slice.call(dataTransfer.files);
+    },
+    items: function items(dataTransfer) {
+      return dataTransfer.items;
+    },
+    dataTransfer: function dataTransfer(_dataTransfer) {
+      return _dataTransfer;
+    }
+  },
+  matchesTypes: ['Files']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.HTML, {
+  exposeProperties: {
+    html: function html(dataTransfer, matchesTypes) {
+      return (0, _getDataFromDataTransfer.getDataFromDataTransfer)(dataTransfer, matchesTypes, '');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer2) {
+      return _dataTransfer2;
+    }
+  },
+  matchesTypes: ['Html', 'text/html']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.URL, {
+  exposeProperties: {
+    urls: function urls(dataTransfer, matchesTypes) {
+      return (0, _getDataFromDataTransfer.getDataFromDataTransfer)(dataTransfer, matchesTypes, '').split('\n');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer3) {
+      return _dataTransfer3;
+    }
+  },
+  matchesTypes: ['Url', 'text/uri-list']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.TEXT, {
+  exposeProperties: {
+    text: function text(dataTransfer, matchesTypes) {
+      return (0, _getDataFromDataTransfer.getDataFromDataTransfer)(dataTransfer, matchesTypes, '');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer4) {
+      return _dataTransfer4;
+    }
+  },
+  matchesTypes: ['Text', 'text/plain']
+}), _nativeTypesConfig);
+exports.nativeTypesConfig = nativeTypesConfig;

node_modules/react-dnd-html5-backend/dist/cjs/NativeTypes.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HTML = exports.TEXT = exports.URL = exports.FILE = void 0;
+var FILE = '__NATIVE_FILE__';
+exports.FILE = FILE;
+var URL = '__NATIVE_URL__';
+exports.URL = URL;
+var TEXT = '__NATIVE_TEXT__';
+exports.TEXT = TEXT;
+var HTML = '__NATIVE_HTML__';
+exports.HTML = HTML;

node_modules/react-dnd-html5-backend/dist/cjs/OffsetUtils.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeClientOffset = getNodeClientOffset;
+exports.getEventClientOffset = getEventClientOffset;
+exports.getDragPreviewOffset = getDragPreviewOffset;
+
+var _BrowserDetector = require("./BrowserDetector");
+
+var _MonotonicInterpolant = require("./MonotonicInterpolant");
+
+var ELEMENT_NODE = 1;
+
+function getNodeClientOffset(node) {
+  var el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
+
+  if (!el) {
+    return null;
+  }
+
+  var _el$getBoundingClient = el.getBoundingClientRect(),
+      top = _el$getBoundingClient.top,
+      left = _el$getBoundingClient.left;
+
+  return {
+    x: left,
+    y: top
+  };
+}
+
+function getEventClientOffset(e) {
+  return {
+    x: e.clientX,
+    y: e.clientY
+  };
+}
+
+function isImageNode(node) {
+  var _document$documentEle;
+
+  return node.nodeName === 'IMG' && ((0, _BrowserDetector.isFirefox)() || !((_document$documentEle = document.documentElement) !== null && _document$documentEle !== void 0 && _document$documentEle.contains(node)));
+}
+
+function getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight) {
+  var dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
+  var dragPreviewHeight = isImage ? dragPreview.height : sourceHeight; // Work around @2x coordinate discrepancies in browsers
+
+  if ((0, _BrowserDetector.isSafari)() && isImage) {
+    dragPreviewHeight /= window.devicePixelRatio;
+    dragPreviewWidth /= window.devicePixelRatio;
+  }
+
+  return {
+    dragPreviewWidth: dragPreviewWidth,
+    dragPreviewHeight: dragPreviewHeight
+  };
+}
+
+function getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint) {
+  // The browsers will use the image intrinsic size under different conditions.
+  // Firefox only cares if it's an image, but WebKit also wants it to be detached.
+  var isImage = isImageNode(dragPreview);
+  var dragPreviewNode = isImage ? sourceNode : dragPreview;
+  var dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
+  var offsetFromDragPreview = {
+    x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
+    y: clientOffset.y - dragPreviewNodeOffsetFromClient.y
+  };
+  var sourceWidth = sourceNode.offsetWidth,
+      sourceHeight = sourceNode.offsetHeight;
+  var anchorX = anchorPoint.anchorX,
+      anchorY = anchorPoint.anchorY;
+
+  var _getDragPreviewSize = getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight),
+      dragPreviewWidth = _getDragPreviewSize.dragPreviewWidth,
+      dragPreviewHeight = _getDragPreviewSize.dragPreviewHeight;
+
+  var calculateYOffset = function calculateYOffset() {
+    var interpolantY = new _MonotonicInterpolant.MonotonicInterpolant([0, 0.5, 1], [// Dock to the top
+    offsetFromDragPreview.y, // Align at the center
+    offsetFromDragPreview.y / sourceHeight * dragPreviewHeight, // Dock to the bottom
+    offsetFromDragPreview.y + dragPreviewHeight - sourceHeight]);
+    var y = interpolantY.interpolate(anchorY); // Work around Safari 8 positioning bug
+
+    if ((0, _BrowserDetector.isSafari)() && isImage) {
+      // We'll have to wait for @3x to see if this is entirely correct
+      y += (window.devicePixelRatio - 1) * dragPreviewHeight;
+    }
+
+    return y;
+  };
+
+  var calculateXOffset = function calculateXOffset() {
+    // Interpolate coordinates depending on anchor point
+    // If you know a simpler way to do this, let me know
+    var interpolantX = new _MonotonicInterpolant.MonotonicInterpolant([0, 0.5, 1], [// Dock to the left
+    offsetFromDragPreview.x, // Align at the center
+    offsetFromDragPreview.x / sourceWidth * dragPreviewWidth, // Dock to the right
+    offsetFromDragPreview.x + dragPreviewWidth - sourceWidth]);
+    return interpolantX.interpolate(anchorX);
+  }; // Force offsets if specified in the options.
+
+
+  var offsetX = offsetPoint.offsetX,
+      offsetY = offsetPoint.offsetY;
+  var isManualOffsetX = offsetX === 0 || offsetX;
+  var isManualOffsetY = offsetY === 0 || offsetY;
+  return {
+    x: isManualOffsetX ? offsetX : calculateXOffset(),
+    y: isManualOffsetY ? offsetY : calculateYOffset()
+  };
+}

node_modules/react-dnd-html5-backend/dist/cjs/OptionsReader.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OptionsReader = void 0;
+
+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); return Constructor; }
+
+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 OptionsReader = /*#__PURE__*/function () {
+  function OptionsReader(globalContext, options) {
+    _classCallCheck(this, OptionsReader);
+
+    _defineProperty(this, "ownerDocument", null);
+
+    _defineProperty(this, "globalContext", void 0);
+
+    _defineProperty(this, "optionsArgs", void 0);
+
+    this.globalContext = globalContext;
+    this.optionsArgs = options;
+  }
+
+  _createClass(OptionsReader, [{
+    key: "window",
+    get: function get() {
+      if (this.globalContext) {
+        return this.globalContext;
+      } else if (typeof window !== 'undefined') {
+        return window;
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "document",
+    get: function get() {
+      var _this$globalContext;
+
+      if ((_this$globalContext = this.globalContext) !== null && _this$globalContext !== void 0 && _this$globalContext.document) {
+        return this.globalContext.document;
+      } else if (this.window) {
+        return this.window.document;
+      } else {
+        return undefined;
+      }
+    }
+  }, {
+    key: "rootElement",
+    get: function get() {
+      var _this$optionsArgs;
+
+      return ((_this$optionsArgs = this.optionsArgs) === null || _this$optionsArgs === void 0 ? void 0 : _this$optionsArgs.rootElement) || this.window;
+    }
+  }]);
+
+  return OptionsReader;
+}();
+
+exports.OptionsReader = OptionsReader;

node_modules/react-dnd-html5-backend/dist/cjs/getEmptyImage.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEmptyImage = getEmptyImage;
+var emptyImage;
+
+function getEmptyImage() {
+  if (!emptyImage) {
+    emptyImage = new Image();
+    emptyImage.src = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+  }
+
+  return emptyImage;
+}

node_modules/react-dnd-html5-backend/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "getEmptyImage", {
+  enumerable: true,
+  get: function get() {
+    return _getEmptyImage.getEmptyImage;
+  }
+});
+exports.NativeTypes = exports.HTML5Backend = void 0;
+
+var _HTML5BackendImpl = require("./HTML5BackendImpl");
+
+var NativeTypes = _interopRequireWildcard(require("./NativeTypes"));
+
+exports.NativeTypes = NativeTypes;
+
+var _getEmptyImage = require("./getEmptyImage");
+
+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; }
+
+var HTML5Backend = function createBackend(manager, context, options) {
+  return new _HTML5BackendImpl.HTML5BackendImpl(manager, context, options);
+};
+
+exports.HTML5Backend = HTML5Backend;

node_modules/react-dnd-html5-backend/dist/cjs/matchesType.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchesType = matchesType;
+
+function matchesType(targetType, draggedItemType) {
+  if (draggedItemType === null) {
+    return targetType === null;
+  }
+
+  return Array.isArray(targetType) ? targetType.some(function (t) {
+    return t === draggedItemType;
+  }) : targetType === draggedItemType;
+}

node_modules/react-dnd-html5-backend/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

node_modules/react-dnd-html5-backend/dist/cjs/utils/js_utils.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.memoize = memoize;
+exports.without = without;
+exports.union = union;
+
+// cheap lodash replacements
+function memoize(fn) {
+  var result = null;
+
+  var memoized = function memoized() {
+    if (result == null) {
+      result = fn();
+    }
+
+    return result;
+  };
+
+  return memoized;
+}
+/**
+ * drop-in replacement for _.without
+ */
+
+
+function without(items, item) {
+  return items.filter(function (i) {
+    return i !== item;
+  });
+}
+
+function union(itemsA, itemsB) {
+  var set = new Set();
+
+  var insertItem = function insertItem(item) {
+    return set.add(item);
+  };
+
+  itemsA.forEach(insertItem);
+  itemsB.forEach(insertItem);
+  var result = [];
+  set.forEach(function (key) {
+    return result.push(key);
+  });
+  return result;
+}

node_modules/react-dnd-html5-backend/dist/esm/BrowserDetector.js

@@ -0,0 +1,7 @@
+import { memoize } from './utils/js_utils';
+export var isFirefox = memoize(function () {
+  return /firefox/i.test(navigator.userAgent);
+});
+export var isSafari = memoize(function () {
+  return Boolean(window.safari);
+});

node_modules/react-dnd-html5-backend/dist/esm/EnterLeaveCounter.js

@@ -0,0 +1,50 @@
+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); return Constructor; }
+
+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; }
+
+import { union, without } from './utils/js_utils';
+export var EnterLeaveCounter = /*#__PURE__*/function () {
+  function EnterLeaveCounter(isNodeInDocument) {
+    _classCallCheck(this, EnterLeaveCounter);
+
+    _defineProperty(this, "entered", []);
+
+    _defineProperty(this, "isNodeInDocument", void 0);
+
+    this.isNodeInDocument = isNodeInDocument;
+  }
+
+  _createClass(EnterLeaveCounter, [{
+    key: "enter",
+    value: function enter(enteringNode) {
+      var _this = this;
+
+      var previousLength = this.entered.length;
+
+      var isNodeEntered = function isNodeEntered(node) {
+        return _this.isNodeInDocument(node) && (!node.contains || node.contains(enteringNode));
+      };
+
+      this.entered = union(this.entered.filter(isNodeEntered), [enteringNode]);
+      return previousLength === 0 && this.entered.length > 0;
+    }
+  }, {
+    key: "leave",
+    value: function leave(leavingNode) {
+      var previousLength = this.entered.length;
+      this.entered = without(this.entered.filter(this.isNodeInDocument), leavingNode);
+      return previousLength > 0 && this.entered.length === 0;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.entered = [];
+    }
+  }]);
+
+  return EnterLeaveCounter;
+}();

node_modules/react-dnd-html5-backend/dist/esm/HTML5BackendImpl.js

@@ -0,0 +1,727 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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); return Constructor; }
+
+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; }
+
+import { EnterLeaveCounter } from './EnterLeaveCounter';
+import { getNodeClientOffset, getEventClientOffset, getDragPreviewOffset } from './OffsetUtils';
+import { createNativeDragSource, matchNativeItemType } from './NativeDragSources';
+import * as NativeTypes from './NativeTypes';
+import { OptionsReader } from './OptionsReader';
+export var HTML5BackendImpl = /*#__PURE__*/function () {
+  // React-Dnd Components
+  // Internal State
+  function HTML5BackendImpl(manager, globalContext, options) {
+    var _this = this;
+
+    _classCallCheck(this, HTML5BackendImpl);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "actions", void 0);
+
+    _defineProperty(this, "monitor", void 0);
+
+    _defineProperty(this, "registry", void 0);
+
+    _defineProperty(this, "enterLeaveCounter", void 0);
+
+    _defineProperty(this, "sourcePreviewNodes", new Map());
+
+    _defineProperty(this, "sourcePreviewNodeOptions", new Map());
+
+    _defineProperty(this, "sourceNodes", new Map());
+
+    _defineProperty(this, "sourceNodeOptions", new Map());
+
+    _defineProperty(this, "dragStartSourceIds", null);
+
+    _defineProperty(this, "dropTargetIds", []);
+
+    _defineProperty(this, "dragEnterTargetIds", []);
+
+    _defineProperty(this, "currentNativeSource", null);
+
+    _defineProperty(this, "currentNativeHandle", null);
+
+    _defineProperty(this, "currentDragSourceNode", null);
+
+    _defineProperty(this, "altKeyPressed", false);
+
+    _defineProperty(this, "mouseMoveTimeoutTimer", null);
+
+    _defineProperty(this, "asyncEndDragFrameId", null);
+
+    _defineProperty(this, "dragOverTargetIds", null);
+
+    _defineProperty(this, "lastClientOffset", null);
+
+    _defineProperty(this, "hoverRafId", null);
+
+    _defineProperty(this, "getSourceClientOffset", function (sourceId) {
+      var source = _this.sourceNodes.get(sourceId);
+
+      return source && getNodeClientOffset(source) || null;
+    });
+
+    _defineProperty(this, "endDragNativeItem", function () {
+      if (!_this.isDraggingNativeItem()) {
+        return;
+      }
+
+      _this.actions.endDrag();
+
+      if (_this.currentNativeHandle) {
+        _this.registry.removeSource(_this.currentNativeHandle);
+      }
+
+      _this.currentNativeHandle = null;
+      _this.currentNativeSource = null;
+    });
+
+    _defineProperty(this, "isNodeInDocument", function (node) {
+      // Check the node either in the main document or in the current context
+      return Boolean(node && _this.document && _this.document.body && _this.document.body.contains(node));
+    });
+
+    _defineProperty(this, "endDragIfSourceWasRemovedFromDOM", function () {
+      var node = _this.currentDragSourceNode;
+
+      if (node == null || _this.isNodeInDocument(node)) {
+        return;
+      }
+
+      if (_this.clearCurrentDragSourceNode() && _this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragStartCapture", function () {
+      _this.clearCurrentDragSourceNode();
+
+      _this.dragStartSourceIds = [];
+    });
+
+    _defineProperty(this, "handleTopDragStart", function (e) {
+      if (e.defaultPrevented) {
+        return;
+      }
+
+      var dragStartSourceIds = _this.dragStartSourceIds;
+      _this.dragStartSourceIds = null;
+      var clientOffset = getEventClientOffset(e); // Avoid crashing if we missed a drop event or our previous drag died
+
+      if (_this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      } // Don't publish the source just yet (see why below)
+
+
+      _this.actions.beginDrag(dragStartSourceIds || [], {
+        publishSource: false,
+        getSourceClientOffset: _this.getSourceClientOffset,
+        clientOffset: clientOffset
+      });
+
+      var dataTransfer = e.dataTransfer;
+      var nativeType = matchNativeItemType(dataTransfer);
+
+      if (_this.monitor.isDragging()) {
+        if (dataTransfer && typeof dataTransfer.setDragImage === 'function') {
+          // Use custom drag image if user specifies it.
+          // If child drag source refuses drag but parent agrees,
+          // use parent's node as drag image. Neither works in IE though.
+          var sourceId = _this.monitor.getSourceId();
+
+          var sourceNode = _this.sourceNodes.get(sourceId);
+
+          var dragPreview = _this.sourcePreviewNodes.get(sourceId) || sourceNode;
+
+          if (dragPreview) {
+            var _this$getCurrentSourc = _this.getCurrentSourcePreviewNodeOptions(),
+                anchorX = _this$getCurrentSourc.anchorX,
+                anchorY = _this$getCurrentSourc.anchorY,
+                offsetX = _this$getCurrentSourc.offsetX,
+                offsetY = _this$getCurrentSourc.offsetY;
+
+            var anchorPoint = {
+              anchorX: anchorX,
+              anchorY: anchorY
+            };
+            var offsetPoint = {
+              offsetX: offsetX,
+              offsetY: offsetY
+            };
+            var dragPreviewOffset = getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint);
+            dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
+          }
+        }
+
+        try {
+          // Firefox won't drag without setting data
+          dataTransfer === null || dataTransfer === void 0 ? void 0 : dataTransfer.setData('application/json', {});
+        } catch (err) {// IE doesn't support MIME types in setData
+        } // Store drag source node so we can check whether
+        // it is removed from DOM and trigger endDrag manually.
+
+
+        _this.setCurrentDragSourceNode(e.target); // Now we are ready to publish the drag source.. or are we not?
+
+
+        var _this$getCurrentSourc2 = _this.getCurrentSourcePreviewNodeOptions(),
+            captureDraggingState = _this$getCurrentSourc2.captureDraggingState;
+
+        if (!captureDraggingState) {
+          // Usually we want to publish it in the next tick so that browser
+          // is able to screenshot the current (not yet dragging) state.
+          //
+          // It also neatly avoids a situation where render() returns null
+          // in the same tick for the source element, and browser freaks out.
+          setTimeout(function () {
+            return _this.actions.publishDragSource();
+          }, 0);
+        } else {
+          // In some cases the user may want to override this behavior, e.g.
+          // to work around IE not supporting custom drag previews.
+          //
+          // When using a custom drag layer, the only way to prevent
+          // the default drag preview from drawing in IE is to screenshot
+          // the dragging state in which the node itself has zero opacity
+          // and height. In this case, though, returning null from render()
+          // will abruptly end the dragging, which is not obvious.
+          //
+          // This is the reason such behavior is strictly opt-in.
+          _this.actions.publishDragSource();
+        }
+      } else if (nativeType) {
+        // A native item (such as URL) dragged from inside the document
+        _this.beginDragNativeItem(nativeType);
+      } else if (dataTransfer && !dataTransfer.types && (e.target && !e.target.hasAttribute || !e.target.hasAttribute('draggable'))) {
+        // Looks like a Safari bug: dataTransfer.types is null, but there was no draggable.
+        // Just let it drag. It's a native type (URL or text) and will be picked up in
+        // dragenter handler.
+        return;
+      } else {
+        // If by this time no drag source reacted, tell browser not to drag.
+        e.preventDefault();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEndCapture", function () {
+      if (_this.clearCurrentDragSourceNode() && _this.monitor.isDragging()) {
+        // Firefox can dispatch this event in an infinite loop
+        // if dragend handler does something like showing an alert.
+        // Only proceed if we have not handled it already.
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEnterCapture", function (e) {
+      _this.dragEnterTargetIds = [];
+
+      var isFirstEnter = _this.enterLeaveCounter.enter(e.target);
+
+      if (!isFirstEnter || _this.monitor.isDragging()) {
+        return;
+      }
+
+      var dataTransfer = e.dataTransfer;
+      var nativeType = matchNativeItemType(dataTransfer);
+
+      if (nativeType) {
+        // A native item (such as file or URL) dragged from outside the document
+        _this.beginDragNativeItem(nativeType, dataTransfer);
+      }
+    });
+
+    _defineProperty(this, "handleTopDragEnter", function (e) {
+      var dragEnterTargetIds = _this.dragEnterTargetIds;
+      _this.dragEnterTargetIds = [];
+
+      if (!_this.monitor.isDragging()) {
+        // This is probably a native item type we don't understand.
+        return;
+      }
+
+      _this.altKeyPressed = e.altKey; // If the target changes position as the result of `dragenter`, `dragover` might still
+      // get dispatched despite target being no longer there. The easy solution is to check
+      // whether there actually is a target before firing `hover`.
+
+      if (dragEnterTargetIds.length > 0) {
+        _this.actions.hover(dragEnterTargetIds, {
+          clientOffset: getEventClientOffset(e)
+        });
+      }
+
+      var canDrop = dragEnterTargetIds.some(function (targetId) {
+        return _this.monitor.canDropOnTarget(targetId);
+      });
+
+      if (canDrop) {
+        // IE requires this to fire dragover events
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = _this.getCurrentDropEffect();
+        }
+      }
+    });
+
+    _defineProperty(this, "handleTopDragOverCapture", function () {
+      _this.dragOverTargetIds = [];
+    });
+
+    _defineProperty(this, "handleTopDragOver", function (e) {
+      var dragOverTargetIds = _this.dragOverTargetIds;
+      _this.dragOverTargetIds = [];
+
+      if (!_this.monitor.isDragging()) {
+        // This is probably a native item type we don't understand.
+        // Prevent default "drop and blow away the whole document" action.
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = 'none';
+        }
+
+        return;
+      }
+
+      _this.altKeyPressed = e.altKey;
+      _this.lastClientOffset = getEventClientOffset(e);
+
+      if (_this.hoverRafId === null && typeof requestAnimationFrame !== 'undefined') {
+        _this.hoverRafId = requestAnimationFrame(function () {
+          if (_this.monitor.isDragging()) {
+            _this.actions.hover(dragOverTargetIds || [], {
+              clientOffset: _this.lastClientOffset
+            });
+          }
+
+          _this.hoverRafId = null;
+        });
+      }
+
+      var canDrop = (dragOverTargetIds || []).some(function (targetId) {
+        return _this.monitor.canDropOnTarget(targetId);
+      });
+
+      if (canDrop) {
+        // Show user-specified drop effect.
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = _this.getCurrentDropEffect();
+        }
+      } else if (_this.isDraggingNativeItem()) {
+        // Don't show a nice cursor but still prevent default
+        // "drop and blow away the whole document" action.
+        e.preventDefault();
+      } else {
+        e.preventDefault();
+
+        if (e.dataTransfer) {
+          e.dataTransfer.dropEffect = 'none';
+        }
+      }
+    });
+
+    _defineProperty(this, "handleTopDragLeaveCapture", function (e) {
+      if (_this.isDraggingNativeItem()) {
+        e.preventDefault();
+      }
+
+      var isLastLeave = _this.enterLeaveCounter.leave(e.target);
+
+      if (!isLastLeave) {
+        return;
+      }
+
+      if (_this.isDraggingNativeItem()) {
+        setTimeout(function () {
+          return _this.endDragNativeItem();
+        }, 0);
+      }
+    });
+
+    _defineProperty(this, "handleTopDropCapture", function (e) {
+      _this.dropTargetIds = [];
+
+      if (_this.isDraggingNativeItem()) {
+        var _this$currentNativeSo;
+
+        e.preventDefault();
+        (_this$currentNativeSo = _this.currentNativeSource) === null || _this$currentNativeSo === void 0 ? void 0 : _this$currentNativeSo.loadDataTransfer(e.dataTransfer);
+      } else if (matchNativeItemType(e.dataTransfer)) {
+        // Dragging some elements, like <a> and <img> may still behave like a native drag event,
+        // even if the current drag event matches a user-defined type.
+        // Stop the default behavior when we're not expecting a native item to be dropped.
+        e.preventDefault();
+      }
+
+      _this.enterLeaveCounter.reset();
+    });
+
+    _defineProperty(this, "handleTopDrop", function (e) {
+      var dropTargetIds = _this.dropTargetIds;
+      _this.dropTargetIds = [];
+
+      _this.actions.hover(dropTargetIds, {
+        clientOffset: getEventClientOffset(e)
+      });
+
+      _this.actions.drop({
+        dropEffect: _this.getCurrentDropEffect()
+      });
+
+      if (_this.isDraggingNativeItem()) {
+        _this.endDragNativeItem();
+      } else if (_this.monitor.isDragging()) {
+        _this.actions.endDrag();
+      }
+    });
+
+    _defineProperty(this, "handleSelectStart", function (e) {
+      var target = e.target; // Only IE requires us to explicitly say
+      // we want drag drop operation to start
+
+      if (typeof target.dragDrop !== 'function') {
+        return;
+      } // Inputs and textareas should be selectable
+
+
+      if (target.tagName === 'INPUT' || target.tagName === 'SELECT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
+        return;
+      } // For other targets, ask IE
+      // to enable drag and drop
+
+
+      e.preventDefault();
+      target.dragDrop();
+    });
+
+    this.options = new OptionsReader(globalContext, options);
+    this.actions = manager.getActions();
+    this.monitor = manager.getMonitor();
+    this.registry = manager.getRegistry();
+    this.enterLeaveCounter = new EnterLeaveCounter(this.isNodeInDocument);
+  }
+  /**
+   * Generate profiling statistics for the HTML5Backend.
+   */
+
+
+  _createClass(HTML5BackendImpl, [{
+    key: "profile",
+    value: function profile() {
+      var _this$dragStartSource, _this$dragOverTargetI;
+
+      return {
+        sourcePreviewNodes: this.sourcePreviewNodes.size,
+        sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+        sourceNodeOptions: this.sourceNodeOptions.size,
+        sourceNodes: this.sourceNodes.size,
+        dragStartSourceIds: ((_this$dragStartSource = this.dragStartSourceIds) === null || _this$dragStartSource === void 0 ? void 0 : _this$dragStartSource.length) || 0,
+        dropTargetIds: this.dropTargetIds.length,
+        dragEnterTargetIds: this.dragEnterTargetIds.length,
+        dragOverTargetIds: ((_this$dragOverTargetI = this.dragOverTargetIds) === null || _this$dragOverTargetI === void 0 ? void 0 : _this$dragOverTargetI.length) || 0
+      };
+    } // public for test
+
+  }, {
+    key: "window",
+    get: function get() {
+      return this.options.window;
+    }
+  }, {
+    key: "document",
+    get: function get() {
+      return this.options.document;
+    }
+    /**
+     * Get the root element to use for event subscriptions
+     */
+
+  }, {
+    key: "rootElement",
+    get: function get() {
+      return this.options.rootElement;
+    }
+  }, {
+    key: "setup",
+    value: function setup() {
+      var root = this.rootElement;
+
+      if (root === undefined) {
+        return;
+      }
+
+      if (root.__isReactDndBackendSetUp) {
+        throw new Error('Cannot have two HTML5 backends at the same time.');
+      }
+
+      root.__isReactDndBackendSetUp = true;
+      this.addEventListeners(root);
+    }
+  }, {
+    key: "teardown",
+    value: function teardown() {
+      var root = this.rootElement;
+
+      if (root === undefined) {
+        return;
+      }
+
+      root.__isReactDndBackendSetUp = false;
+      this.removeEventListeners(this.rootElement);
+      this.clearCurrentDragSourceNode();
+
+      if (this.asyncEndDragFrameId) {
+        var _this$window;
+
+        (_this$window = this.window) === null || _this$window === void 0 ? void 0 : _this$window.cancelAnimationFrame(this.asyncEndDragFrameId);
+      }
+    }
+  }, {
+    key: "connectDragPreview",
+    value: function connectDragPreview(sourceId, node, options) {
+      var _this2 = this;
+
+      this.sourcePreviewNodeOptions.set(sourceId, options);
+      this.sourcePreviewNodes.set(sourceId, node);
+      return function () {
+        _this2.sourcePreviewNodes.delete(sourceId);
+
+        _this2.sourcePreviewNodeOptions.delete(sourceId);
+      };
+    }
+  }, {
+    key: "connectDragSource",
+    value: function connectDragSource(sourceId, node, options) {
+      var _this3 = this;
+
+      this.sourceNodes.set(sourceId, node);
+      this.sourceNodeOptions.set(sourceId, options);
+
+      var handleDragStart = function handleDragStart(e) {
+        return _this3.handleDragStart(e, sourceId);
+      };
+
+      var handleSelectStart = function handleSelectStart(e) {
+        return _this3.handleSelectStart(e);
+      };
+
+      node.setAttribute('draggable', 'true');
+      node.addEventListener('dragstart', handleDragStart);
+      node.addEventListener('selectstart', handleSelectStart);
+      return function () {
+        _this3.sourceNodes.delete(sourceId);
+
+        _this3.sourceNodeOptions.delete(sourceId);
+
+        node.removeEventListener('dragstart', handleDragStart);
+        node.removeEventListener('selectstart', handleSelectStart);
+        node.setAttribute('draggable', 'false');
+      };
+    }
+  }, {
+    key: "connectDropTarget",
+    value: function connectDropTarget(targetId, node) {
+      var _this4 = this;
+
+      var handleDragEnter = function handleDragEnter(e) {
+        return _this4.handleDragEnter(e, targetId);
+      };
+
+      var handleDragOver = function handleDragOver(e) {
+        return _this4.handleDragOver(e, targetId);
+      };
+
+      var handleDrop = function handleDrop(e) {
+        return _this4.handleDrop(e, targetId);
+      };
+
+      node.addEventListener('dragenter', handleDragEnter);
+      node.addEventListener('dragover', handleDragOver);
+      node.addEventListener('drop', handleDrop);
+      return function () {
+        node.removeEventListener('dragenter', handleDragEnter);
+        node.removeEventListener('dragover', handleDragOver);
+        node.removeEventListener('drop', handleDrop);
+      };
+    }
+  }, {
+    key: "addEventListeners",
+    value: function addEventListeners(target) {
+      // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
+      if (!target.addEventListener) {
+        return;
+      }
+
+      target.addEventListener('dragstart', this.handleTopDragStart);
+      target.addEventListener('dragstart', this.handleTopDragStartCapture, true);
+      target.addEventListener('dragend', this.handleTopDragEndCapture, true);
+      target.addEventListener('dragenter', this.handleTopDragEnter);
+      target.addEventListener('dragenter', this.handleTopDragEnterCapture, true);
+      target.addEventListener('dragleave', this.handleTopDragLeaveCapture, true);
+      target.addEventListener('dragover', this.handleTopDragOver);
+      target.addEventListener('dragover', this.handleTopDragOverCapture, true);
+      target.addEventListener('drop', this.handleTopDrop);
+      target.addEventListener('drop', this.handleTopDropCapture, true);
+    }
+  }, {
+    key: "removeEventListeners",
+    value: function removeEventListeners(target) {
+      // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
+      if (!target.removeEventListener) {
+        return;
+      }
+
+      target.removeEventListener('dragstart', this.handleTopDragStart);
+      target.removeEventListener('dragstart', this.handleTopDragStartCapture, true);
+      target.removeEventListener('dragend', this.handleTopDragEndCapture, true);
+      target.removeEventListener('dragenter', this.handleTopDragEnter);
+      target.removeEventListener('dragenter', this.handleTopDragEnterCapture, true);
+      target.removeEventListener('dragleave', this.handleTopDragLeaveCapture, true);
+      target.removeEventListener('dragover', this.handleTopDragOver);
+      target.removeEventListener('dragover', this.handleTopDragOverCapture, true);
+      target.removeEventListener('drop', this.handleTopDrop);
+      target.removeEventListener('drop', this.handleTopDropCapture, true);
+    }
+  }, {
+    key: "getCurrentSourceNodeOptions",
+    value: function getCurrentSourceNodeOptions() {
+      var sourceId = this.monitor.getSourceId();
+      var sourceNodeOptions = this.sourceNodeOptions.get(sourceId);
+      return _objectSpread({
+        dropEffect: this.altKeyPressed ? 'copy' : 'move'
+      }, sourceNodeOptions || {});
+    }
+  }, {
+    key: "getCurrentDropEffect",
+    value: function getCurrentDropEffect() {
+      if (this.isDraggingNativeItem()) {
+        // It makes more sense to default to 'copy' for native resources
+        return 'copy';
+      }
+
+      return this.getCurrentSourceNodeOptions().dropEffect;
+    }
+  }, {
+    key: "getCurrentSourcePreviewNodeOptions",
+    value: function getCurrentSourcePreviewNodeOptions() {
+      var sourceId = this.monitor.getSourceId();
+      var sourcePreviewNodeOptions = this.sourcePreviewNodeOptions.get(sourceId);
+      return _objectSpread({
+        anchorX: 0.5,
+        anchorY: 0.5,
+        captureDraggingState: false
+      }, sourcePreviewNodeOptions || {});
+    }
+  }, {
+    key: "isDraggingNativeItem",
+    value: function isDraggingNativeItem() {
+      var itemType = this.monitor.getItemType();
+      return Object.keys(NativeTypes).some(function (key) {
+        return NativeTypes[key] === itemType;
+      });
+    }
+  }, {
+    key: "beginDragNativeItem",
+    value: function beginDragNativeItem(type, dataTransfer) {
+      this.clearCurrentDragSourceNode();
+      this.currentNativeSource = createNativeDragSource(type, dataTransfer);
+      this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
+      this.actions.beginDrag([this.currentNativeHandle]);
+    }
+  }, {
+    key: "setCurrentDragSourceNode",
+    value: function setCurrentDragSourceNode(node) {
+      var _this5 = this;
+
+      this.clearCurrentDragSourceNode();
+      this.currentDragSourceNode = node; // A timeout of > 0 is necessary to resolve Firefox issue referenced
+      // See:
+      //   * https://github.com/react-dnd/react-dnd/pull/928
+      //   * https://github.com/react-dnd/react-dnd/issues/869
+
+      var MOUSE_MOVE_TIMEOUT = 1000; // Receiving a mouse event in the middle of a dragging operation
+      // means it has ended and the drag source node disappeared from DOM,
+      // so the browser didn't dispatch the dragend event.
+      //
+      // We need to wait before we start listening for mousemove events.
+      // This is needed because the drag preview needs to be drawn or else it fires an 'mousemove' event
+      // immediately in some browsers.
+      //
+      // See:
+      //   * https://github.com/react-dnd/react-dnd/pull/928
+      //   * https://github.com/react-dnd/react-dnd/issues/869
+      //
+
+      this.mouseMoveTimeoutTimer = setTimeout(function () {
+        var _this5$rootElement;
+
+        return (_this5$rootElement = _this5.rootElement) === null || _this5$rootElement === void 0 ? void 0 : _this5$rootElement.addEventListener('mousemove', _this5.endDragIfSourceWasRemovedFromDOM, true);
+      }, MOUSE_MOVE_TIMEOUT);
+    }
+  }, {
+    key: "clearCurrentDragSourceNode",
+    value: function clearCurrentDragSourceNode() {
+      if (this.currentDragSourceNode) {
+        this.currentDragSourceNode = null;
+
+        if (this.rootElement) {
+          var _this$window2;
+
+          (_this$window2 = this.window) === null || _this$window2 === void 0 ? void 0 : _this$window2.clearTimeout(this.mouseMoveTimeoutTimer || undefined);
+          this.rootElement.removeEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
+        }
+
+        this.mouseMoveTimeoutTimer = null;
+        return true;
+      }
+
+      return false;
+    }
+  }, {
+    key: "handleDragStart",
+    value: function handleDragStart(e, sourceId) {
+      if (e.defaultPrevented) {
+        return;
+      }
+
+      if (!this.dragStartSourceIds) {
+        this.dragStartSourceIds = [];
+      }
+
+      this.dragStartSourceIds.unshift(sourceId);
+    }
+  }, {
+    key: "handleDragEnter",
+    value: function handleDragEnter(e, targetId) {
+      this.dragEnterTargetIds.unshift(targetId);
+    }
+  }, {
+    key: "handleDragOver",
+    value: function handleDragOver(e, targetId) {
+      if (this.dragOverTargetIds === null) {
+        this.dragOverTargetIds = [];
+      }
+
+      this.dragOverTargetIds.unshift(targetId);
+    }
+  }, {
+    key: "handleDrop",
+    value: function handleDrop(e, targetId) {
+      this.dropTargetIds.unshift(targetId);
+    }
+  }]);
+
+  return HTML5BackendImpl;
+}();

node_modules/react-dnd-html5-backend/dist/esm/MonotonicInterpolant.js

@@ -0,0 +1,132 @@
+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); return Constructor; }
+
+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; }
+
+export var MonotonicInterpolant = /*#__PURE__*/function () {
+  function MonotonicInterpolant(xs, ys) {
+    _classCallCheck(this, MonotonicInterpolant);
+
+    _defineProperty(this, "xs", void 0);
+
+    _defineProperty(this, "ys", void 0);
+
+    _defineProperty(this, "c1s", void 0);
+
+    _defineProperty(this, "c2s", void 0);
+
+    _defineProperty(this, "c3s", void 0);
+
+    var length = xs.length; // Rearrange xs and ys so that xs is sorted
+
+    var indexes = [];
+
+    for (var i = 0; i < length; i++) {
+      indexes.push(i);
+    }
+
+    indexes.sort(function (a, b) {
+      return xs[a] < xs[b] ? -1 : 1;
+    }); // Get consecutive differences and slopes
+
+    var dys = [];
+    var dxs = [];
+    var ms = [];
+    var dx;
+    var dy;
+
+    for (var _i = 0; _i < length - 1; _i++) {
+      dx = xs[_i + 1] - xs[_i];
+      dy = ys[_i + 1] - ys[_i];
+      dxs.push(dx);
+      dys.push(dy);
+      ms.push(dy / dx);
+    } // Get degree-1 coefficients
+
+
+    var c1s = [ms[0]];
+
+    for (var _i2 = 0; _i2 < dxs.length - 1; _i2++) {
+      var m2 = ms[_i2];
+      var mNext = ms[_i2 + 1];
+
+      if (m2 * mNext <= 0) {
+        c1s.push(0);
+      } else {
+        dx = dxs[_i2];
+        var dxNext = dxs[_i2 + 1];
+        var common = dx + dxNext;
+        c1s.push(3 * common / ((common + dxNext) / m2 + (common + dx) / mNext));
+      }
+    }
+
+    c1s.push(ms[ms.length - 1]); // Get degree-2 and degree-3 coefficients
+
+    var c2s = [];
+    var c3s = [];
+    var m;
+
+    for (var _i3 = 0; _i3 < c1s.length - 1; _i3++) {
+      m = ms[_i3];
+      var c1 = c1s[_i3];
+      var invDx = 1 / dxs[_i3];
+
+      var _common = c1 + c1s[_i3 + 1] - m - m;
+
+      c2s.push((m - c1 - _common) * invDx);
+      c3s.push(_common * invDx * invDx);
+    }
+
+    this.xs = xs;
+    this.ys = ys;
+    this.c1s = c1s;
+    this.c2s = c2s;
+    this.c3s = c3s;
+  }
+
+  _createClass(MonotonicInterpolant, [{
+    key: "interpolate",
+    value: function interpolate(x) {
+      var xs = this.xs,
+          ys = this.ys,
+          c1s = this.c1s,
+          c2s = this.c2s,
+          c3s = this.c3s; // The rightmost point in the dataset should give an exact result
+
+      var i = xs.length - 1;
+
+      if (x === xs[i]) {
+        return ys[i];
+      } // Search for the interval x is in, returning the corresponding y if x is one of the original xs
+
+
+      var low = 0;
+      var high = c3s.length - 1;
+      var mid;
+
+      while (low <= high) {
+        mid = Math.floor(0.5 * (low + high));
+        var xHere = xs[mid];
+
+        if (xHere < x) {
+          low = mid + 1;
+        } else if (xHere > x) {
+          high = mid - 1;
+        } else {
+          return ys[mid];
+        }
+      }
+
+      i = Math.max(0, high); // Interpolate
+
+      var diff = x - xs[i];
+      var diffSq = diff * diff;
+      return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
+    }
+  }]);
+
+  return MonotonicInterpolant;
+}();

node_modules/react-dnd-html5-backend/dist/esm/NativeDragSources/NativeDragSource.js

@@ -0,0 +1,78 @@
+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); return Constructor; }
+
+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; }
+
+export var NativeDragSource = /*#__PURE__*/function () {
+  function NativeDragSource(config) {
+    _classCallCheck(this, NativeDragSource);
+
+    _defineProperty(this, "item", void 0);
+
+    _defineProperty(this, "config", void 0);
+
+    this.config = config;
+    this.item = {};
+    this.initializeExposedProperties();
+  }
+
+  _createClass(NativeDragSource, [{
+    key: "initializeExposedProperties",
+    value: function initializeExposedProperties() {
+      var _this = this;
+
+      Object.keys(this.config.exposeProperties).forEach(function (property) {
+        Object.defineProperty(_this.item, property, {
+          configurable: true,
+          enumerable: true,
+          get: function get() {
+            // eslint-disable-next-line no-console
+            console.warn("Browser doesn't allow reading \"".concat(property, "\" until the drop event."));
+            return null;
+          }
+        });
+      });
+    }
+  }, {
+    key: "loadDataTransfer",
+    value: function loadDataTransfer(dataTransfer) {
+      var _this2 = this;
+
+      if (dataTransfer) {
+        var newProperties = {};
+        Object.keys(this.config.exposeProperties).forEach(function (property) {
+          newProperties[property] = {
+            value: _this2.config.exposeProperties[property](dataTransfer, _this2.config.matchesTypes),
+            configurable: true,
+            enumerable: true
+          };
+        });
+        Object.defineProperties(this.item, newProperties);
+      }
+    }
+  }, {
+    key: "canDrag",
+    value: function canDrag() {
+      return true;
+    }
+  }, {
+    key: "beginDrag",
+    value: function beginDrag() {
+      return this.item;
+    }
+  }, {
+    key: "isDragging",
+    value: function isDragging(monitor, handle) {
+      return handle === monitor.getSourceId();
+    }
+  }, {
+    key: "endDrag",
+    value: function endDrag() {// empty
+    }
+  }]);
+
+  return NativeDragSource;
+}();

node_modules/react-dnd-html5-backend/dist/esm/NativeDragSources/getDataFromDataTransfer.js

@@ -0,0 +1,6 @@
+export function getDataFromDataTransfer(dataTransfer, typesToTry, defaultValue) {
+  var result = typesToTry.reduce(function (resultSoFar, typeToTry) {
+    return resultSoFar || dataTransfer.getData(typeToTry);
+  }, '');
+  return result != null ? result : defaultValue;
+}

node_modules/react-dnd-html5-backend/dist/esm/NativeDragSources/index.js

@@ -0,0 +1,20 @@
+import { nativeTypesConfig } from './nativeTypesConfig';
+import { NativeDragSource } from './NativeDragSource';
+export function createNativeDragSource(type, dataTransfer) {
+  var result = new NativeDragSource(nativeTypesConfig[type]);
+  result.loadDataTransfer(dataTransfer);
+  return result;
+}
+export function matchNativeItemType(dataTransfer) {
+  if (!dataTransfer) {
+    return null;
+  }
+
+  var dataTransferTypes = Array.prototype.slice.call(dataTransfer.types || []);
+  return Object.keys(nativeTypesConfig).filter(function (nativeItemType) {
+    var matchesTypes = nativeTypesConfig[nativeItemType].matchesTypes;
+    return matchesTypes.some(function (t) {
+      return dataTransferTypes.indexOf(t) > -1;
+    });
+  })[0] || null;
+}

node_modules/react-dnd-html5-backend/dist/esm/NativeDragSources/nativeTypesConfig.js

@@ -0,0 +1,50 @@
+var _nativeTypesConfig;
+
+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; }
+
+import * as NativeTypes from '../NativeTypes';
+import { getDataFromDataTransfer } from './getDataFromDataTransfer';
+export var nativeTypesConfig = (_nativeTypesConfig = {}, _defineProperty(_nativeTypesConfig, NativeTypes.FILE, {
+  exposeProperties: {
+    files: function files(dataTransfer) {
+      return Array.prototype.slice.call(dataTransfer.files);
+    },
+    items: function items(dataTransfer) {
+      return dataTransfer.items;
+    },
+    dataTransfer: function dataTransfer(_dataTransfer) {
+      return _dataTransfer;
+    }
+  },
+  matchesTypes: ['Files']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.HTML, {
+  exposeProperties: {
+    html: function html(dataTransfer, matchesTypes) {
+      return getDataFromDataTransfer(dataTransfer, matchesTypes, '');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer2) {
+      return _dataTransfer2;
+    }
+  },
+  matchesTypes: ['Html', 'text/html']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.URL, {
+  exposeProperties: {
+    urls: function urls(dataTransfer, matchesTypes) {
+      return getDataFromDataTransfer(dataTransfer, matchesTypes, '').split('\n');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer3) {
+      return _dataTransfer3;
+    }
+  },
+  matchesTypes: ['Url', 'text/uri-list']
+}), _defineProperty(_nativeTypesConfig, NativeTypes.TEXT, {
+  exposeProperties: {
+    text: function text(dataTransfer, matchesTypes) {
+      return getDataFromDataTransfer(dataTransfer, matchesTypes, '');
+    },
+    dataTransfer: function dataTransfer(_dataTransfer4) {
+      return _dataTransfer4;
+    }
+  },
+  matchesTypes: ['Text', 'text/plain']
+}), _nativeTypesConfig);

node_modules/react-dnd-html5-backend/dist/esm/NativeTypes.js

@@ -0,0 +1,4 @@
+export var FILE = '__NATIVE_FILE__';
+export var URL = '__NATIVE_URL__';
+export var TEXT = '__NATIVE_TEXT__';
+export var HTML = '__NATIVE_HTML__';

node_modules/react-dnd-html5-backend/dist/esm/OffsetUtils.js

@@ -0,0 +1,101 @@
+import { isSafari, isFirefox } from './BrowserDetector';
+import { MonotonicInterpolant } from './MonotonicInterpolant';
+var ELEMENT_NODE = 1;
+export function getNodeClientOffset(node) {
+  var el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
+
+  if (!el) {
+    return null;
+  }
+
+  var _el$getBoundingClient = el.getBoundingClientRect(),
+      top = _el$getBoundingClient.top,
+      left = _el$getBoundingClient.left;
+
+  return {
+    x: left,
+    y: top
+  };
+}
+export function getEventClientOffset(e) {
+  return {
+    x: e.clientX,
+    y: e.clientY
+  };
+}
+
+function isImageNode(node) {
+  var _document$documentEle;
+
+  return node.nodeName === 'IMG' && (isFirefox() || !((_document$documentEle = document.documentElement) !== null && _document$documentEle !== void 0 && _document$documentEle.contains(node)));
+}
+
+function getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight) {
+  var dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
+  var dragPreviewHeight = isImage ? dragPreview.height : sourceHeight; // Work around @2x coordinate discrepancies in browsers
+
+  if (isSafari() && isImage) {
+    dragPreviewHeight /= window.devicePixelRatio;
+    dragPreviewWidth /= window.devicePixelRatio;
+  }
+
+  return {
+    dragPreviewWidth: dragPreviewWidth,
+    dragPreviewHeight: dragPreviewHeight
+  };
+}
+
+export function getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint) {
+  // The browsers will use the image intrinsic size under different conditions.
+  // Firefox only cares if it's an image, but WebKit also wants it to be detached.
+  var isImage = isImageNode(dragPreview);
+  var dragPreviewNode = isImage ? sourceNode : dragPreview;
+  var dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
+  var offsetFromDragPreview = {
+    x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
+    y: clientOffset.y - dragPreviewNodeOffsetFromClient.y
+  };
+  var sourceWidth = sourceNode.offsetWidth,
+      sourceHeight = sourceNode.offsetHeight;
+  var anchorX = anchorPoint.anchorX,
+      anchorY = anchorPoint.anchorY;
+
+  var _getDragPreviewSize = getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight),
+      dragPreviewWidth = _getDragPreviewSize.dragPreviewWidth,
+      dragPreviewHeight = _getDragPreviewSize.dragPreviewHeight;
+
+  var calculateYOffset = function calculateYOffset() {
+    var interpolantY = new MonotonicInterpolant([0, 0.5, 1], [// Dock to the top
+    offsetFromDragPreview.y, // Align at the center
+    offsetFromDragPreview.y / sourceHeight * dragPreviewHeight, // Dock to the bottom
+    offsetFromDragPreview.y + dragPreviewHeight - sourceHeight]);
+    var y = interpolantY.interpolate(anchorY); // Work around Safari 8 positioning bug
+
+    if (isSafari() && isImage) {
+      // We'll have to wait for @3x to see if this is entirely correct
+      y += (window.devicePixelRatio - 1) * dragPreviewHeight;
+    }
+
+    return y;
+  };
+
+  var calculateXOffset = function calculateXOffset() {
+    // Interpolate coordinates depending on anchor point
+    // If you know a simpler way to do this, let me know
+    var interpolantX = new MonotonicInterpolant([0, 0.5, 1], [// Dock to the left
+    offsetFromDragPreview.x, // Align at the center
+    offsetFromDragPreview.x / sourceWidth * dragPreviewWidth, // Dock to the right
+    offsetFromDragPreview.x + dragPreviewWidth - sourceWidth]);
+    return interpolantX.interpolate(anchorX);
+  }; // Force offsets if specified in the options.
+
+
+  var offsetX = offsetPoint.offsetX,
+      offsetY = offsetPoint.offsetY;
+  var isManualOffsetX = offsetX === 0 || offsetX;
+  var isManualOffsetY = offsetY === 0 || offsetY;
+  return {
+    x: isManualOffsetX ? offsetX : calculateXOffset(),
+    y: isManualOffsetY ? offsetY : calculateYOffset()
+  };
+}

node_modules/react-dnd-html5-backend/dist/esm/OptionsReader.js

@@ -0,0 +1,57 @@
+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); return Constructor; }
+
+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; }
+
+export var OptionsReader = /*#__PURE__*/function () {
+  function OptionsReader(globalContext, options) {
+    _classCallCheck(this, OptionsReader);
+
+    _defineProperty(this, "ownerDocument", null);
+
+    _defineProperty(this, "globalContext", void 0);
+
+    _defineProperty(this, "optionsArgs", void 0);
+
+    this.globalContext = globalContext;
+    this.optionsArgs = options;
+  }
+
+  _createClass(OptionsReader, [{
+    key: "window",
+    get: function get() {
+      if (this.globalContext) {
+        return this.globalContext;
+      } else if (typeof window !== 'undefined') {
+        return window;
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "document",
+    get: function get() {
+      var _this$globalContext;
+
+      if ((_this$globalContext = this.globalContext) !== null && _this$globalContext !== void 0 && _this$globalContext.document) {
+        return this.globalContext.document;
+      } else if (this.window) {
+        return this.window.document;
+      } else {
+        return undefined;
+      }
+    }
+  }, {
+    key: "rootElement",
+    get: function get() {
+      var _this$optionsArgs;
+
+      return ((_this$optionsArgs = this.optionsArgs) === null || _this$optionsArgs === void 0 ? void 0 : _this$optionsArgs.rootElement) || this.window;
+    }
+  }]);
+
+  return OptionsReader;
+}();

node_modules/react-dnd-html5-backend/dist/esm/getEmptyImage.js

@@ -0,0 +1,9 @@
+var emptyImage;
+export function getEmptyImage() {
+  if (!emptyImage) {
+    emptyImage = new Image();
+    emptyImage.src = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+  }
+
+  return emptyImage;
+}

node_modules/react-dnd-html5-backend/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { HTML5BackendImpl } from './HTML5BackendImpl';
+import * as NativeTypes from './NativeTypes';
+export { getEmptyImage } from './getEmptyImage';
+export { NativeTypes };
+export var HTML5Backend = function createBackend(manager, context, options) {
+  return new HTML5BackendImpl(manager, context, options);
+};

node_modules/react-dnd-html5-backend/dist/esm/matchesType.js

@@ -0,0 +1,9 @@
+export function matchesType(targetType, draggedItemType) {
+  if (draggedItemType === null) {
+    return targetType === null;
+  }
+
+  return Array.isArray(targetType) ? targetType.some(function (t) {
+    return t === draggedItemType;
+  }) : targetType === draggedItemType;
+}

node_modules/react-dnd-html5-backend/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

node_modules/react-dnd-html5-backend/dist/esm/utils/js_utils.js

@@ -0,0 +1,38 @@
+// cheap lodash replacements
+export function memoize(fn) {
+  var result = null;
+
+  var memoized = function memoized() {
+    if (result == null) {
+      result = fn();
+    }
+
+    return result;
+  };
+
+  return memoized;
+}
+/**
+ * drop-in replacement for _.without
+ */
+
+export function without(items, item) {
+  return items.filter(function (i) {
+    return i !== item;
+  });
+}
+export function union(itemsA, itemsB) {
+  var set = new Set();
+
+  var insertItem = function insertItem(item) {
+    return set.add(item);
+  };
+
+  itemsA.forEach(insertItem);
+  itemsB.forEach(insertItem);
+  var result = [];
+  set.forEach(function (key) {
+    return result.push(key);
+  });
+  return result;
+}

node_modules/react-dnd-html5-backend/dist/types/BrowserDetector.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface Window extends HTMLElement {
+        safari: any;
+    }
+}
+export declare type Predicate = () => boolean;
+export declare const isFirefox: Predicate;
+export declare const isSafari: Predicate;

node_modules/react-dnd-html5-backend/dist/types/EnterLeaveCounter.d.ts

@@ -0,0 +1,10 @@
+declare type NodePredicate = (node: Node | null | undefined) => boolean;
+export declare class EnterLeaveCounter {
+    private entered;
+    private isNodeInDocument;
+    constructor(isNodeInDocument: NodePredicate);
+    enter(enteringNode: EventTarget | null): boolean;
+    leave(leavingNode: EventTarget | null): boolean;
+    reset(): void;
+}
+export {};

node_modules/react-dnd-html5-backend/dist/types/HTML5BackendImpl.d.ts

@@ -0,0 +1,69 @@
+import { Backend, DragDropManager, Unsubscribe } from 'dnd-core';
+import { HTML5BackendContext, HTML5BackendOptions } from './types';
+export declare class HTML5BackendImpl implements Backend {
+    private options;
+    private actions;
+    private monitor;
+    private registry;
+    private enterLeaveCounter;
+    private sourcePreviewNodes;
+    private sourcePreviewNodeOptions;
+    private sourceNodes;
+    private sourceNodeOptions;
+    private dragStartSourceIds;
+    private dropTargetIds;
+    private dragEnterTargetIds;
+    private currentNativeSource;
+    private currentNativeHandle;
+    private currentDragSourceNode;
+    private altKeyPressed;
+    private mouseMoveTimeoutTimer;
+    private asyncEndDragFrameId;
+    private dragOverTargetIds;
+    private lastClientOffset;
+    private hoverRafId;
+    constructor(manager: DragDropManager, globalContext?: HTML5BackendContext, options?: HTML5BackendOptions);
+    /**
+     * Generate profiling statistics for the HTML5Backend.
+     */
+    profile(): Record<string, number>;
+    get window(): Window | undefined;
+    get document(): Document | undefined;
+    /**
+     * Get the root element to use for event subscriptions
+     */
+    private get rootElement();
+    setup(): void;
+    teardown(): void;
+    connectDragPreview(sourceId: string, node: Element, options: any): Unsubscribe;
+    connectDragSource(sourceId: string, node: Element, options: any): Unsubscribe;
+    connectDropTarget(targetId: string, node: HTMLElement): Unsubscribe;
+    private addEventListeners;
+    private removeEventListeners;
+    private getCurrentSourceNodeOptions;
+    private getCurrentDropEffect;
+    private getCurrentSourcePreviewNodeOptions;
+    private getSourceClientOffset;
+    private isDraggingNativeItem;
+    private beginDragNativeItem;
+    private endDragNativeItem;
+    private isNodeInDocument;
+    private endDragIfSourceWasRemovedFromDOM;
+    private setCurrentDragSourceNode;
+    private clearCurrentDragSourceNode;
+    handleTopDragStartCapture: () => void;
+    handleDragStart(e: DragEvent, sourceId: string): void;
+    handleTopDragStart: (e: DragEvent) => void;
+    handleTopDragEndCapture: () => void;
+    handleTopDragEnterCapture: (e: DragEvent) => void;
+    handleDragEnter(e: DragEvent, targetId: string): void;
+    handleTopDragEnter: (e: DragEvent) => void;
+    handleTopDragOverCapture: () => void;
+    handleDragOver(e: DragEvent, targetId: string): void;
+    handleTopDragOver: (e: DragEvent) => void;
+    handleTopDragLeaveCapture: (e: DragEvent) => void;
+    handleTopDropCapture: (e: DragEvent) => void;
+    handleDrop(e: DragEvent, targetId: string): void;
+    handleTopDrop: (e: DragEvent) => void;
+    handleSelectStart: (e: DragEvent) => void;
+}

node_modules/react-dnd-html5-backend/dist/types/MonotonicInterpolant.d.ts

@@ -0,0 +1,9 @@
+export declare class MonotonicInterpolant {
+    private xs;
+    private ys;
+    private c1s;
+    private c2s;
+    private c3s;
+    constructor(xs: number[], ys: number[]);
+    interpolate(x: number): number;
+}

node_modules/react-dnd-html5-backend/dist/types/NativeDragSources/NativeDragSource.d.ts

@@ -0,0 +1,13 @@
+import { NativeItemConfig } from './nativeTypesConfig';
+import { DragDropMonitor } from 'dnd-core';
+export declare class NativeDragSource {
+    item: any;
+    private config;
+    constructor(config: NativeItemConfig);
+    private initializeExposedProperties;
+    loadDataTransfer(dataTransfer: DataTransfer | null | undefined): void;
+    canDrag(): boolean;
+    beginDrag(): any;
+    isDragging(monitor: DragDropMonitor, handle: string): boolean;
+    endDrag(): void;
+}

node_modules/react-dnd-html5-backend/dist/types/NativeDragSources/getDataFromDataTransfer.d.ts

@@ -0,0 +1 @@
+export declare function getDataFromDataTransfer(dataTransfer: DataTransfer, typesToTry: string[], defaultValue: string): string;

node_modules/react-dnd-html5-backend/dist/types/NativeDragSources/index.d.ts

@@ -0,0 +1,3 @@
+import { NativeDragSource } from './NativeDragSource';
+export declare function createNativeDragSource(type: string, dataTransfer?: DataTransfer): NativeDragSource;
+export declare function matchNativeItemType(dataTransfer: DataTransfer | null): string | null;

node_modules/react-dnd-html5-backend/dist/types/NativeDragSources/nativeTypesConfig.d.ts

@@ -0,0 +1,10 @@
+export interface NativeItemConfigExposePropreties {
+    [property: string]: (dataTransfer: DataTransfer, matchesTypes: string[]) => any;
+}
+export interface NativeItemConfig {
+    exposeProperties: NativeItemConfigExposePropreties;
+    matchesTypes: string[];
+}
+export declare const nativeTypesConfig: {
+    [key: string]: NativeItemConfig;
+};

node_modules/react-dnd-html5-backend/dist/types/NativeTypes.d.ts

@@ -0,0 +1,4 @@
+export declare const FILE = "__NATIVE_FILE__";
+export declare const URL = "__NATIVE_URL__";
+export declare const TEXT = "__NATIVE_TEXT__";
+export declare const HTML = "__NATIVE_HTML__";

node_modules/react-dnd-html5-backend/dist/types/OffsetUtils.d.ts

@@ -0,0 +1,10 @@
+import { XYCoord } from 'dnd-core';
+export declare function getNodeClientOffset(node: Node): XYCoord | null;
+export declare function getEventClientOffset(e: MouseEvent): XYCoord;
+export declare function getDragPreviewOffset(sourceNode: HTMLElement, dragPreview: HTMLElement, clientOffset: XYCoord, anchorPoint: {
+    anchorX: number;
+    anchorY: number;
+}, offsetPoint: {
+    offsetX: number;
+    offsetY: number;
+}): XYCoord;

node_modules/react-dnd-html5-backend/dist/types/OptionsReader.d.ts

@@ -0,0 +1,10 @@
+import { HTML5BackendContext, HTML5BackendOptions } from './types';
+export declare class OptionsReader {
+    ownerDocument: Document | null;
+    private globalContext;
+    private optionsArgs?;
+    constructor(globalContext: HTML5BackendContext, options?: HTML5BackendOptions);
+    get window(): Window | undefined;
+    get document(): Document | undefined;
+    get rootElement(): Node | undefined;
+}

node_modules/react-dnd-html5-backend/dist/types/getEmptyImage.d.ts

@@ -0,0 +1 @@
+export declare function getEmptyImage(): HTMLImageElement;

node_modules/react-dnd-html5-backend/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+import * as NativeTypes from './NativeTypes';
+import { BackendFactory } from 'dnd-core';
+export { HTML5BackendContext, HTML5BackendOptions } from './types';
+export { getEmptyImage } from './getEmptyImage';
+export { NativeTypes };
+export declare const HTML5Backend: BackendFactory;

node_modules/react-dnd-html5-backend/dist/types/matchesType.d.ts

@@ -0,0 +1,2 @@
+import { SourceType, TargetType } from 'dnd-core';
+export declare function matchesType(targetType: TargetType | null, draggedItemType: SourceType | null): boolean;

node_modules/react-dnd-html5-backend/dist/types/types.d.ts

@@ -0,0 +1,10 @@
+export declare type HTML5BackendContext = Window | undefined;
+/**
+ * Configuration options for the HTML5Backend
+ */
+export interface HTML5BackendOptions {
+    /**
+     * The root DOM node to use for subscribing to events. Default=Window
+     */
+    rootElement: Node;
+}

node_modules/react-dnd-html5-backend/dist/types/utils/js_utils.d.ts

@@ -0,0 +1,6 @@
+export declare function memoize<T>(fn: () => T): () => T;
+/**
+ * drop-in replacement for _.without
+ */
+export declare function without<T>(items: T[], item: T): T[];
+export declare function union<T extends string | number>(itemsA: T[], itemsB: T[]): T[];