planning

node_modules/react-dnd-html5-backend/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dan Abramov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

node_modules/react-dnd-html5-backend/README.md

@@ -0,0 +1,28 @@
+[![npm package](https://img.shields.io/npm/v/react-dnd-html5-backend.svg?style=flat-square)](https://www.npmjs.org/package/react-dnd-html5-backend)
+[![Build Status](https://travis-ci.org/react-dnd/react-dnd-html5-backend.svg?branch=main)](https://travis-ci.org/react-dnd/react-dnd-html5-backend)
+[![dependencies Status](https://david-dm.org/react-dnd/react-dnd-html5-backend/status.svg)](https://david-dm.org/react-dnd/react-dnd-html5-backend)
+[![devDependencies Status](https://david-dm.org/react-dnd/react-dnd-html5-backend/dev-status.svg)](https://david-dm.org/react-dnd/react-dnd-html5-backend?type=dev)
+[![peerDependencies Status](https://david-dm.org/react-dnd/react-dnd-html5-backend/peer-status.svg)](https://david-dm.org/react-dnd/react-dnd-html5-backend?type=peer)
+
+# React DnD HTML5 Backend
+
+The officially supported HTML5 backend for [React DnD](http://react-dnd.github.io/react-dnd/).
+See [the docs](http://react-dnd.github.io/react-dnd/docs/backends/html5) for usage information.
+
+## Installation
+
+If you use [npm](http://npmjs.com):
+
+```
+npm install --save react-dnd-html5-backend
+```
+
+## Browser Support
+
+We strive to support the evergreen browsers.
+
+Unfortunately the browser bugs, inconsistencies, and regressions come up from time to time, so please make sure you test your app on the browsers you’re interested in, and report any bugs to us.
+
+## License
+
+MIT

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[];

node_modules/react-dnd-html5-backend/gulpfile.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { preset } = require('@react-dnd/build')
+module.exports = preset()

node_modules/react-dnd-html5-backend/lib/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/lib/BrowserDetector.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/EnterLeaveCounter.js

@@ -0,0 +1,23 @@
+import { union, without } from './utils/js_utils';
+export class EnterLeaveCounter {
+    entered = [];
+    isNodeInDocument;
+    constructor(isNodeInDocument) {
+        this.isNodeInDocument = isNodeInDocument;
+    }
+    enter(enteringNode) {
+        const previousLength = this.entered.length;
+        const isNodeEntered = (node) => this.isNodeInDocument(node) &&
+            (!node.contains || node.contains(enteringNode));
+        this.entered = union(this.entered.filter(isNodeEntered), [enteringNode]);
+        return previousLength === 0 && this.entered.length > 0;
+    }
+    leave(leavingNode) {
+        const previousLength = this.entered.length;
+        this.entered = without(this.entered.filter(this.isNodeInDocument), leavingNode);
+        return previousLength > 0 && this.entered.length === 0;
+    }
+    reset() {
+        this.entered = [];
+    }
+}

node_modules/react-dnd-html5-backend/lib/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/lib/HTML5BackendImpl.js

@@ -0,0 +1,524 @@
+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 class HTML5BackendImpl {
+    options;
+    // React-Dnd Components
+    actions;
+    monitor;
+    registry;
+    // Internal State
+    enterLeaveCounter;
+    sourcePreviewNodes = new Map();
+    sourcePreviewNodeOptions = new Map();
+    sourceNodes = new Map();
+    sourceNodeOptions = new Map();
+    dragStartSourceIds = null;
+    dropTargetIds = [];
+    dragEnterTargetIds = [];
+    currentNativeSource = null;
+    currentNativeHandle = null;
+    currentDragSourceNode = null;
+    altKeyPressed = false;
+    mouseMoveTimeoutTimer = null;
+    asyncEndDragFrameId = null;
+    dragOverTargetIds = null;
+    lastClientOffset = null;
+    hoverRafId = null;
+    constructor(manager, globalContext, options) {
+        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.
+     */
+    profile() {
+        return {
+            sourcePreviewNodes: this.sourcePreviewNodes.size,
+            sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+            sourceNodeOptions: this.sourceNodeOptions.size,
+            sourceNodes: this.sourceNodes.size,
+            dragStartSourceIds: this.dragStartSourceIds?.length || 0,
+            dropTargetIds: this.dropTargetIds.length,
+            dragEnterTargetIds: this.dragEnterTargetIds.length,
+            dragOverTargetIds: this.dragOverTargetIds?.length || 0,
+        };
+    }
+    // public for test
+    get window() {
+        return this.options.window;
+    }
+    get document() {
+        return this.options.document;
+    }
+    /**
+     * Get the root element to use for event subscriptions
+     */
+    get rootElement() {
+        return this.options.rootElement;
+    }
+    setup() {
+        const 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);
+    }
+    teardown() {
+        const root = this.rootElement;
+        if (root === undefined) {
+            return;
+        }
+        root.__isReactDndBackendSetUp = false;
+        this.removeEventListeners(this.rootElement);
+        this.clearCurrentDragSourceNode();
+        if (this.asyncEndDragFrameId) {
+            this.window?.cancelAnimationFrame(this.asyncEndDragFrameId);
+        }
+    }
+    connectDragPreview(sourceId, node, options) {
+        this.sourcePreviewNodeOptions.set(sourceId, options);
+        this.sourcePreviewNodes.set(sourceId, node);
+        return () => {
+            this.sourcePreviewNodes.delete(sourceId);
+            this.sourcePreviewNodeOptions.delete(sourceId);
+        };
+    }
+    connectDragSource(sourceId, node, options) {
+        this.sourceNodes.set(sourceId, node);
+        this.sourceNodeOptions.set(sourceId, options);
+        const handleDragStart = (e) => this.handleDragStart(e, sourceId);
+        const handleSelectStart = (e) => this.handleSelectStart(e);
+        node.setAttribute('draggable', 'true');
+        node.addEventListener('dragstart', handleDragStart);
+        node.addEventListener('selectstart', handleSelectStart);
+        return () => {
+            this.sourceNodes.delete(sourceId);
+            this.sourceNodeOptions.delete(sourceId);
+            node.removeEventListener('dragstart', handleDragStart);
+            node.removeEventListener('selectstart', handleSelectStart);
+            node.setAttribute('draggable', 'false');
+        };
+    }
+    connectDropTarget(targetId, node) {
+        const handleDragEnter = (e) => this.handleDragEnter(e, targetId);
+        const handleDragOver = (e) => this.handleDragOver(e, targetId);
+        const handleDrop = (e) => this.handleDrop(e, targetId);
+        node.addEventListener('dragenter', handleDragEnter);
+        node.addEventListener('dragover', handleDragOver);
+        node.addEventListener('drop', handleDrop);
+        return () => {
+            node.removeEventListener('dragenter', handleDragEnter);
+            node.removeEventListener('dragover', handleDragOver);
+            node.removeEventListener('drop', handleDrop);
+        };
+    }
+    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);
+    }
+    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);
+    }
+    getCurrentSourceNodeOptions() {
+        const sourceId = this.monitor.getSourceId();
+        const sourceNodeOptions = this.sourceNodeOptions.get(sourceId);
+        return {
+            dropEffect: this.altKeyPressed ? 'copy' : 'move',
+            ...(sourceNodeOptions || {}),
+        };
+    }
+    getCurrentDropEffect() {
+        if (this.isDraggingNativeItem()) {
+            // It makes more sense to default to 'copy' for native resources
+            return 'copy';
+        }
+        return this.getCurrentSourceNodeOptions().dropEffect;
+    }
+    getCurrentSourcePreviewNodeOptions() {
+        const sourceId = this.monitor.getSourceId();
+        const sourcePreviewNodeOptions = this.sourcePreviewNodeOptions.get(sourceId);
+        return {
+            anchorX: 0.5,
+            anchorY: 0.5,
+            captureDraggingState: false,
+            ...(sourcePreviewNodeOptions || {}),
+        };
+    }
+    getSourceClientOffset = (sourceId) => {
+        const source = this.sourceNodes.get(sourceId);
+        return (source && getNodeClientOffset(source)) || null;
+    };
+    isDraggingNativeItem() {
+        const itemType = this.monitor.getItemType();
+        return Object.keys(NativeTypes).some((key) => NativeTypes[key] === itemType);
+    }
+    beginDragNativeItem(type, dataTransfer) {
+        this.clearCurrentDragSourceNode();
+        this.currentNativeSource = createNativeDragSource(type, dataTransfer);
+        this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
+        this.actions.beginDrag([this.currentNativeHandle]);
+    }
+    endDragNativeItem = () => {
+        if (!this.isDraggingNativeItem()) {
+            return;
+        }
+        this.actions.endDrag();
+        if (this.currentNativeHandle) {
+            this.registry.removeSource(this.currentNativeHandle);
+        }
+        this.currentNativeHandle = null;
+        this.currentNativeSource = null;
+    };
+    isNodeInDocument = (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));
+    };
+    endDragIfSourceWasRemovedFromDOM = () => {
+        const node = this.currentDragSourceNode;
+        if (node == null || this.isNodeInDocument(node)) {
+            return;
+        }
+        if (this.clearCurrentDragSourceNode() && this.monitor.isDragging()) {
+            this.actions.endDrag();
+        }
+    };
+    setCurrentDragSourceNode(node) {
+        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
+        const 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(() => {
+            return this.rootElement?.addEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
+        }, MOUSE_MOVE_TIMEOUT);
+    }
+    clearCurrentDragSourceNode() {
+        if (this.currentDragSourceNode) {
+            this.currentDragSourceNode = null;
+            if (this.rootElement) {
+                this.window?.clearTimeout(this.mouseMoveTimeoutTimer || undefined);
+                this.rootElement.removeEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
+            }
+            this.mouseMoveTimeoutTimer = null;
+            return true;
+        }
+        return false;
+    }
+    handleTopDragStartCapture = () => {
+        this.clearCurrentDragSourceNode();
+        this.dragStartSourceIds = [];
+    };
+    handleDragStart(e, sourceId) {
+        if (e.defaultPrevented) {
+            return;
+        }
+        if (!this.dragStartSourceIds) {
+            this.dragStartSourceIds = [];
+        }
+        this.dragStartSourceIds.unshift(sourceId);
+    }
+    handleTopDragStart = (e) => {
+        if (e.defaultPrevented) {
+            return;
+        }
+        const { dragStartSourceIds } = this;
+        this.dragStartSourceIds = null;
+        const 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,
+        });
+        const { dataTransfer } = e;
+        const 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.
+                const sourceId = this.monitor.getSourceId();
+                const sourceNode = this.sourceNodes.get(sourceId);
+                const dragPreview = this.sourcePreviewNodes.get(sourceId) || sourceNode;
+                if (dragPreview) {
+                    const { anchorX, anchorY, offsetX, offsetY } = this.getCurrentSourcePreviewNodeOptions();
+                    const anchorPoint = { anchorX, anchorY };
+                    const offsetPoint = { offsetX, offsetY };
+                    const dragPreviewOffset = getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint);
+                    dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
+                }
+            }
+            try {
+                // Firefox won't drag without setting data
+                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?
+            const { captureDraggingState } = this.getCurrentSourcePreviewNodeOptions();
+            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(() => 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();
+        }
+    };
+    handleTopDragEndCapture = () => {
+        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();
+        }
+    };
+    handleTopDragEnterCapture = (e) => {
+        this.dragEnterTargetIds = [];
+        const isFirstEnter = this.enterLeaveCounter.enter(e.target);
+        if (!isFirstEnter || this.monitor.isDragging()) {
+            return;
+        }
+        const { dataTransfer } = e;
+        const nativeType = matchNativeItemType(dataTransfer);
+        if (nativeType) {
+            // A native item (such as file or URL) dragged from outside the document
+            this.beginDragNativeItem(nativeType, dataTransfer);
+        }
+    };
+    handleDragEnter(e, targetId) {
+        this.dragEnterTargetIds.unshift(targetId);
+    }
+    handleTopDragEnter = (e) => {
+        const { dragEnterTargetIds } = this;
+        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),
+            });
+        }
+        const canDrop = dragEnterTargetIds.some((targetId) => this.monitor.canDropOnTarget(targetId));
+        if (canDrop) {
+            // IE requires this to fire dragover events
+            e.preventDefault();
+            if (e.dataTransfer) {
+                e.dataTransfer.dropEffect = this.getCurrentDropEffect();
+            }
+        }
+    };
+    handleTopDragOverCapture = () => {
+        this.dragOverTargetIds = [];
+    };
+    handleDragOver(e, targetId) {
+        if (this.dragOverTargetIds === null) {
+            this.dragOverTargetIds = [];
+        }
+        this.dragOverTargetIds.unshift(targetId);
+    }
+    handleTopDragOver = (e) => {
+        const { dragOverTargetIds } = this;
+        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(() => {
+                if (this.monitor.isDragging()) {
+                    this.actions.hover(dragOverTargetIds || [], {
+                        clientOffset: this.lastClientOffset,
+                    });
+                }
+                this.hoverRafId = null;
+            });
+        }
+        const canDrop = (dragOverTargetIds || []).some((targetId) => 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';
+            }
+        }
+    };
+    handleTopDragLeaveCapture = (e) => {
+        if (this.isDraggingNativeItem()) {
+            e.preventDefault();
+        }
+        const isLastLeave = this.enterLeaveCounter.leave(e.target);
+        if (!isLastLeave) {
+            return;
+        }
+        if (this.isDraggingNativeItem()) {
+            setTimeout(() => this.endDragNativeItem(), 0);
+        }
+    };
+    handleTopDropCapture = (e) => {
+        this.dropTargetIds = [];
+        if (this.isDraggingNativeItem()) {
+            e.preventDefault();
+            this.currentNativeSource?.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();
+    };
+    handleDrop(e, targetId) {
+        this.dropTargetIds.unshift(targetId);
+    }
+    handleTopDrop = (e) => {
+        const { dropTargetIds } = this;
+        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();
+        }
+    };
+    handleSelectStart = (e) => {
+        const 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();
+    };
+}

node_modules/react-dnd-html5-backend/lib/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/lib/MonotonicInterpolant.js

@@ -0,0 +1,92 @@
+export class MonotonicInterpolant {
+    xs;
+    ys;
+    c1s;
+    c2s;
+    c3s;
+    constructor(xs, ys) {
+        const { length } = xs;
+        // Rearrange xs and ys so that xs is sorted
+        const indexes = [];
+        for (let i = 0; i < length; i++) {
+            indexes.push(i);
+        }
+        indexes.sort((a, b) => (xs[a] < xs[b] ? -1 : 1));
+        // Get consecutive differences and slopes
+        const dys = [];
+        const dxs = [];
+        const ms = [];
+        let dx;
+        let dy;
+        for (let 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
+        const c1s = [ms[0]];
+        for (let i = 0; i < dxs.length - 1; i++) {
+            const m2 = ms[i];
+            const mNext = ms[i + 1];
+            if (m2 * mNext <= 0) {
+                c1s.push(0);
+            }
+            else {
+                dx = dxs[i];
+                const dxNext = dxs[i + 1];
+                const 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
+        const c2s = [];
+        const c3s = [];
+        let m;
+        for (let i = 0; i < c1s.length - 1; i++) {
+            m = ms[i];
+            const c1 = c1s[i];
+            const invDx = 1 / dxs[i];
+            const common = c1 + c1s[i + 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;
+    }
+    interpolate(x) {
+        const { xs, ys, c1s, c2s, c3s } = this;
+        // The rightmost point in the dataset should give an exact result
+        let 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
+        let low = 0;
+        let high = c3s.length - 1;
+        let mid;
+        while (low <= high) {
+            mid = Math.floor(0.5 * (low + high));
+            const 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
+        const diff = x - xs[i];
+        const diffSq = diff * diff;
+        return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
+    }
+}

node_modules/react-dnd-html5-backend/lib/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/lib/NativeDragSources/NativeDragSource.js

@@ -0,0 +1,47 @@
+export class NativeDragSource {
+    item;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.item = {};
+        this.initializeExposedProperties();
+    }
+    initializeExposedProperties() {
+        Object.keys(this.config.exposeProperties).forEach((property) => {
+            Object.defineProperty(this.item, property, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    // eslint-disable-next-line no-console
+                    console.warn(`Browser doesn't allow reading "${property}" until the drop event.`);
+                    return null;
+                },
+            });
+        });
+    }
+    loadDataTransfer(dataTransfer) {
+        if (dataTransfer) {
+            const newProperties = {};
+            Object.keys(this.config.exposeProperties).forEach((property) => {
+                newProperties[property] = {
+                    value: this.config.exposeProperties[property](dataTransfer, this.config.matchesTypes),
+                    configurable: true,
+                    enumerable: true,
+                };
+            });
+            Object.defineProperties(this.item, newProperties);
+        }
+    }
+    canDrag() {
+        return true;
+    }
+    beginDrag() {
+        return this.item;
+    }
+    isDragging(monitor, handle) {
+        return handle === monitor.getSourceId();
+    }
+    endDrag() {
+        // empty
+    }
+}

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

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

node_modules/react-dnd-html5-backend/lib/NativeDragSources/getDataFromDataTransfer.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/NativeDragSources/index.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/NativeDragSources/nativeTypesConfig.js

@@ -0,0 +1,33 @@
+import * as NativeTypes from '../NativeTypes';
+import { getDataFromDataTransfer } from './getDataFromDataTransfer';
+export const nativeTypesConfig = {
+    [NativeTypes.FILE]: {
+        exposeProperties: {
+            files: (dataTransfer) => Array.prototype.slice.call(dataTransfer.files),
+            items: (dataTransfer) => dataTransfer.items,
+            dataTransfer: (dataTransfer) => dataTransfer,
+        },
+        matchesTypes: ['Files'],
+    },
+    [NativeTypes.HTML]: {
+        exposeProperties: {
+            html: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, ''),
+            dataTransfer: (dataTransfer) => dataTransfer,
+        },
+        matchesTypes: ['Html', 'text/html'],
+    },
+    [NativeTypes.URL]: {
+        exposeProperties: {
+            urls: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, '').split('\n'),
+            dataTransfer: (dataTransfer) => dataTransfer,
+        },
+        matchesTypes: ['Url', 'text/uri-list'],
+    },
+    [NativeTypes.TEXT]: {
+        exposeProperties: {
+            text: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, ''),
+            dataTransfer: (dataTransfer) => dataTransfer,
+        },
+        matchesTypes: ['Text', 'text/plain'],
+    },
+};

node_modules/react-dnd-html5-backend/lib/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/lib/NativeTypes.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/OffsetUtils.js

@@ -0,0 +1,83 @@
+import { isSafari, isFirefox } from './BrowserDetector';
+import { MonotonicInterpolant } from './MonotonicInterpolant';
+const ELEMENT_NODE = 1;
+export function getNodeClientOffset(node) {
+    const el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
+    if (!el) {
+        return null;
+    }
+    const { top, left } = el.getBoundingClientRect();
+    return { x: left, y: top };
+}
+export function getEventClientOffset(e) {
+    return {
+        x: e.clientX,
+        y: e.clientY,
+    };
+}
+function isImageNode(node) {
+    return (node.nodeName === 'IMG' &&
+        (isFirefox() || !document.documentElement?.contains(node)));
+}
+function getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight) {
+    let dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
+    let dragPreviewHeight = isImage ? dragPreview.height : sourceHeight;
+    // Work around @2x coordinate discrepancies in browsers
+    if (isSafari() && isImage) {
+        dragPreviewHeight /= window.devicePixelRatio;
+        dragPreviewWidth /= window.devicePixelRatio;
+    }
+    return { dragPreviewWidth, 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.
+    const isImage = isImageNode(dragPreview);
+    const dragPreviewNode = isImage ? sourceNode : dragPreview;
+    const dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
+    const offsetFromDragPreview = {
+        x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
+        y: clientOffset.y - dragPreviewNodeOffsetFromClient.y,
+    };
+    const { offsetWidth: sourceWidth, offsetHeight: sourceHeight } = sourceNode;
+    const { anchorX, anchorY } = anchorPoint;
+    const { dragPreviewWidth, dragPreviewHeight } = getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight);
+    const calculateYOffset = () => {
+        const 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,
+        ]);
+        let 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;
+    };
+    const calculateXOffset = () => {
+        // Interpolate coordinates depending on anchor point
+        // If you know a simpler way to do this, let me know
+        const 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.
+    const { offsetX, offsetY } = offsetPoint;
+    const isManualOffsetX = offsetX === 0 || offsetX;
+    const isManualOffsetY = offsetY === 0 || offsetY;
+    return {
+        x: isManualOffsetX ? offsetX : calculateXOffset(),
+        y: isManualOffsetY ? offsetY : calculateYOffset(),
+    };
+}

node_modules/react-dnd-html5-backend/lib/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/lib/OptionsReader.js

@@ -0,0 +1,32 @@
+export class OptionsReader {
+    ownerDocument = null;
+    globalContext;
+    optionsArgs;
+    constructor(globalContext, options) {
+        this.globalContext = globalContext;
+        this.optionsArgs = options;
+    }
+    get window() {
+        if (this.globalContext) {
+            return this.globalContext;
+        }
+        else if (typeof window !== 'undefined') {
+            return window;
+        }
+        return undefined;
+    }
+    get document() {
+        if (this.globalContext?.document) {
+            return this.globalContext.document;
+        }
+        else if (this.window) {
+            return this.window.document;
+        }
+        else {
+            return undefined;
+        }
+    }
+    get rootElement() {
+        return this.optionsArgs?.rootElement || this.window;
+    }
+}

node_modules/react-dnd-html5-backend/lib/getEmptyImage.d.ts

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

node_modules/react-dnd-html5-backend/lib/getEmptyImage.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/index.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/matchesType.js

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

node_modules/react-dnd-html5-backend/lib/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/lib/types.js

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

node_modules/react-dnd-html5-backend/lib/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[];

node_modules/react-dnd-html5-backend/lib/utils/js_utils.js

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

node_modules/react-dnd-html5-backend/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "react-dnd-html5-backend",
+  "version": "14.1.0",
+  "description": "HTML5 backend for React DnD",
+  "main": "dist/cjs/index.js",
+  "publishConfig": {
+    "main": "dist/cjs/index.js",
+    "module": "dist/esm/index.js",
+    "types": "dist/types/index.d.ts"
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-dnd/react-dnd.git"
+  },
+  "scripts": {
+    "clean": "gulp clean",
+    "build": "gulp build",
+    "watch": "gulp watch",
+    "bundle": "gulp bundle"
+  },
+  "dependencies": {
+    "dnd-core": "14.0.1"
+  },
+  "devDependencies": {
+    "@react-dnd/build": "12.0.0",
+    "gulp": "^4.0.2"
+  },
+  "umd": {
+    "name": "ReactDnDHTML5Backend",
+    "input": "./dist/esm/index.js",
+    "external": [
+      "react",
+      "react-dom",
+      "react-dnd"
+    ],
+    "globals": {
+      "react": "React",
+      "react-dom": "ReactDOM",
+      "react-dnd": "ReactDnD"
+    },
+    "alias": {
+      "dnd-core": "dnd-core/dist/esm/index",
+      "react-dnd": "react-dnd/dist/esm/index"
+    }
+  },
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts"
+}