{"version":3,"sources":["../node_modules/@react-dnd/invariant/dist/invariant.esm.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/types.js","../node_modules/dnd-core/dist/esm/utils/equality.js","../node_modules/dnd-core/dist/esm/reducers/dragOffset.js","../node_modules/dnd-core/dist/esm/actions/registry.js","../node_modules/dnd-core/dist/esm/utils/js_utils.js","../node_modules/dnd-core/dist/esm/reducers/dragOperation.js","../node_modules/dnd-core/dist/esm/reducers/refCount.js","../node_modules/dnd-core/dist/esm/utils/dirtiness.js","../node_modules/dnd-core/dist/esm/reducers/dirtyHandlerIds.js","../node_modules/dnd-core/dist/esm/reducers/stateId.js","../node_modules/dnd-core/dist/esm/reducers/index.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/local/setClientOffset.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/beginDrag.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/publishDragSource.js","../node_modules/dnd-core/dist/esm/utils/matchesType.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/hover.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/drop.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/endDrag.js","../node_modules/dnd-core/dist/esm/utils/coords.js","../node_modules/dnd-core/dist/esm/DragDropMonitorImpl.js","../node_modules/dnd-core/dist/esm/interfaces.js","../node_modules/dnd-core/dist/esm/utils/getNextUniqueId.js","../node_modules/dnd-core/dist/esm/contracts.js","../node_modules/@react-dnd/asap/dist/esm/browser/asap.js","../node_modules/dnd-core/dist/esm/HandlerRegistryImpl.js","../node_modules/dnd-core/dist/esm/DragDropManagerImpl.js","../node_modules/dnd-core/dist/esm/actions/dragDrop/index.js","../node_modules/dnd-core/dist/esm/factories.js","../node_modules/react-dnd/dist/esm/common/DndContext.js","../node_modules/@react-dnd/asap/dist/esm/browser/raw.js"],"names":["invariant","condition","format","_len","arguments","length","args","Array","_key","error","undefined","Error","argIndex","replace","name","framesToPop","__webpack_require__","d","__webpack_exports__","INIT_COORDS","BEGIN_DRAG","PUBLISH_DRAG_SOURCE","HOVER","DROP","END_DRAG","strictEquality","a","b","areCoordsEqual","offsetA","offsetB","x","y","areArraysEqual","isEqual","i","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","configurable","writable","initialState","initialSourceClientOffset","initialClientOffset","clientOffset","reduce","state","action","payload","type","sourceClientOffset","ADD_SOURCE","ADD_TARGET","REMOVE_SOURCE","REMOVE_TARGET","_typeof","Symbol","iterator","constructor","prototype","get","path","defaultValue","split","c","without","items","item","isObject","input","xor","itemsA","itemsB","map","Map","insertItem","set","has","result","count","dragOperation_ownKeys","dragOperation_objectSpread","dragOperation_defineProperty","dragOperation_initialState","itemType","sourceId","targetIds","dropResult","didDrop","isSourcePublic","dragOperation_reduce","indexOf","targetId","refCount_reduce","NONE","ALL","areDirty","dirtyIds","handlerIds","t","dirtyHandlerIds_reduce","_action$payload","_action$payload$targe","_action$payload$prevT","prevTargetIds","didChange","prevInnermostTargetId","innermostTargetId","stateId_reduce","reducers_ownKeys","reducers_objectSpread","reducers_defineProperty","reducers_reduce","dirtyHandlerIds","dragOffset","refCount","dragOperation","stateId","__IS_NONE__","__IS_ALL__","setClientOffset","ResetCoordinatesAction","createBeginDrag","manager","sourceIds","options","publishSource","_options$publishSourc","getSourceClientOffset","monitor","getMonitor","registry","getRegistry","dispatch","verifyInvariants","getDraggableSource","verifyGetSourceClientOffsetIsFunction","getSource","beginDrag","verifyItemIsObject","pinSource","getSourceType","invariant_esm","isDragging","canDragSource","createPublishDragSource","matchesType","targetType","draggedItemType","isArray","some","createHover","targetIdsArg","_ref","verifyTargetIdsIsArray","slice","checkInvariants","getItemType","removeNonMatchingTargetIds","hoverAllTargets","lastIndexOf","getTarget","getTargetType","splice","hover","drop_ownKeys","drop_objectSpread","drop_defineProperty","createDrop","drop_verifyInvariants","getDroppableTargets","index","determineDropResult","drop","verifyDropResultType","getDropResult","getTargetIds","canDropOnTarget","reverse","createEndDrag","verifyIsDragging","getSourceId","endDrag","unpinSource","subtract","_defineProperties","props","descriptor","HandlerRole","DragDropMonitorImpl_DragDropMonitorImpl","DragDropMonitorImpl","store","instance","Constructor","TypeError","_classCallCheck","this","protoProps","staticProps","listener","_this","prevStateId","getState","handleChange","currentStateId","subscribe","_this2","previousState","nextState","canDrag","canDrop","Boolean","shallow","coords_getSourceClientOffset","coords_getDifferenceFromInitialOffset","nextUniqueId","contracts_typeof","validateType","allowArray","freeTasks","pendingErrors","requestErrorThrow","raw","makeRequestCallFromTimer","shift","asap","task","rawTask","pop","RawTask","call","onerror","HandlerRegistryImpl_defineProperties","_slicedToArray","arr","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","err","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","toString","from","test","_unsupportedIterableToArray","_nonIterableRest","len","arr2","getNextHandlerId","role","id","SOURCE","concat","TARGET","parseRoleFromHandlerId","handlerId","mapContainsValue","searchValue","entries","isDone","_entries$next","HandlerRegistryImpl_HandlerRegistryImpl","HandlerRegistryImpl","HandlerRegistryImpl_classCallCheck","types","dragSources","dropTargets","pinnedSourceId","pinnedSource","validateSourceContract","addHandler","registry_addSource","validateTargetContract","registry_addTarget","handler","includePinned","isSourceId","isPinned","isTargetId","registry_removeSource","delete","registry_removeTarget","DragDropManagerImpl_classCallCheck","DragDropManagerImpl_defineProperties","makeStoreInstance","debugMode","reduxDevTools","window","__REDUX_DEVTOOLS_EXTENSION__","redux","instanceId","DragDropManagerImpl_DragDropManagerImpl","DragDropManagerImpl","isSetUp","handleRefCountChange","shouldSetUp","backend","setup","teardown","actions","publishDragSource","createDragDropActions","boundActions","actionCreator","createDragDropManager","backendFactory","globalContext","backendOptions","receiveBackend","DndContext","react","dragDropManager","createDndContext","context","global","rawAsap","queue","requestFlush","flush","currentIndex","scan","newLength","scope","self","BrowserMutationObserver","MutationObserver","WebKitMutationObserver","callback","timeoutHandle","setTimeout","handleTimer","intervalHandle","setInterval","clearTimeout","clearInterval","toggle","observer","node","document","createTextNode","observe","characterData","data","makeRequestCallFromMutationObserver"],"mappings":"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","file":"static/js/11.f242aa19.chunk.js","sourcesContent":["/**\r\n * Use invariant() to assert state which your program assumes to be true.\r\n *\r\n * Provide sprintf-style format (only %s is supported) and arguments\r\n * to provide information about what broke and what you were\r\n * expecting.\r\n *\r\n * The invariant message will be stripped in production, but the invariant\r\n * will remain to ensure logic does not differ in production.\r\n */\nfunction invariant(condition, format) {\n  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    args[_key - 2] = arguments[_key];\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n\n    throw error;\n  }\n}\n\nexport { invariant };","export var INIT_COORDS = 'dnd-core/INIT_COORDS';\nexport var BEGIN_DRAG = 'dnd-core/BEGIN_DRAG';\nexport var PUBLISH_DRAG_SOURCE = 'dnd-core/PUBLISH_DRAG_SOURCE';\nexport var HOVER = 'dnd-core/HOVER';\nexport var DROP = 'dnd-core/DROP';\nexport var END_DRAG = 'dnd-core/END_DRAG';","export var strictEquality = function strictEquality(a, b) {\n  return a === b;\n};\n/**\n * Determine if two cartesian coordinate offsets are equal\n * @param offsetA\n * @param offsetB\n */\n\nexport function areCoordsEqual(offsetA, offsetB) {\n  if (!offsetA && !offsetB) {\n    return true;\n  } else if (!offsetA || !offsetB) {\n    return false;\n  } else {\n    return offsetA.x === offsetB.x && offsetA.y === offsetB.y;\n  }\n}\n/**\n * Determines if two arrays of items are equal\n * @param a The first array of items\n * @param b The second array of items\n */\n\nexport function areArraysEqual(a, b) {\n  var isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : strictEquality;\n\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  for (var i = 0; i < a.length; ++i) {\n    if (!isEqual(a[i], b[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nimport { INIT_COORDS, BEGIN_DRAG, HOVER, END_DRAG, DROP } from '../actions/dragDrop';\nimport { areCoordsEqual } from '../utils/equality';\nvar initialState = {\n  initialSourceClientOffset: null,\n  initialClientOffset: null,\n  clientOffset: null\n};\nexport function reduce() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n  var payload = action.payload;\n\n  switch (action.type) {\n    case INIT_COORDS:\n    case BEGIN_DRAG:\n      return {\n        initialSourceClientOffset: payload.sourceClientOffset,\n        initialClientOffset: payload.clientOffset,\n        clientOffset: payload.clientOffset\n      };\n\n    case HOVER:\n      if (areCoordsEqual(state.clientOffset, payload.clientOffset)) {\n        return state;\n      }\n\n      return _objectSpread(_objectSpread({}, state), {}, {\n        clientOffset: payload.clientOffset\n      });\n\n    case END_DRAG:\n    case DROP:\n      return initialState;\n\n    default:\n      return state;\n  }\n}","export var ADD_SOURCE = 'dnd-core/ADD_SOURCE';\nexport var ADD_TARGET = 'dnd-core/ADD_TARGET';\nexport var REMOVE_SOURCE = 'dnd-core/REMOVE_SOURCE';\nexport var REMOVE_TARGET = 'dnd-core/REMOVE_TARGET';\nexport function addSource(sourceId) {\n  return {\n    type: ADD_SOURCE,\n    payload: {\n      sourceId: sourceId\n    }\n  };\n}\nexport function addTarget(targetId) {\n  return {\n    type: ADD_TARGET,\n    payload: {\n      targetId: targetId\n    }\n  };\n}\nexport function removeSource(sourceId) {\n  return {\n    type: REMOVE_SOURCE,\n    payload: {\n      sourceId: sourceId\n    }\n  };\n}\nexport function removeTarget(targetId) {\n  return {\n    type: REMOVE_TARGET,\n    payload: {\n      targetId: targetId\n    }\n  };\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n} // cheap lodash replacements\n\n/**\n * drop-in replacement for _.get\n * @param obj\n * @param path\n * @param defaultValue\n */\n\n\nexport function get(obj, path, defaultValue) {\n  return path.split('.').reduce(function (a, c) {\n    return a && a[c] ? a[c] : defaultValue || null;\n  }, obj);\n}\n/**\n * drop-in replacement for _.without\n */\n\nexport function without(items, item) {\n  return items.filter(function (i) {\n    return i !== item;\n  });\n}\n/**\n * drop-in replacement for _.isString\n * @param input\n */\n\nexport function isString(input) {\n  return typeof input === 'string';\n}\n/**\n * drop-in replacement for _.isString\n * @param input\n */\n\nexport function isObject(input) {\n  return _typeof(input) === 'object';\n}\n/**\n * repalcement for _.xor\n * @param itemsA\n * @param itemsB\n */\n\nexport function xor(itemsA, itemsB) {\n  var map = new Map();\n\n  var insertItem = function insertItem(item) {\n    map.set(item, map.has(item) ? map.get(item) + 1 : 1);\n  };\n\n  itemsA.forEach(insertItem);\n  itemsB.forEach(insertItem);\n  var result = [];\n  map.forEach(function (count, key) {\n    if (count === 1) {\n      result.push(key);\n    }\n  });\n  return result;\n}\n/**\n * replacement for _.intersection\n * @param itemsA\n * @param itemsB\n */\n\nexport function intersection(itemsA, itemsB) {\n  return itemsA.filter(function (t) {\n    return itemsB.indexOf(t) > -1;\n  });\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nimport { BEGIN_DRAG, PUBLISH_DRAG_SOURCE, HOVER, END_DRAG, DROP } from '../actions/dragDrop';\nimport { REMOVE_TARGET } from '../actions/registry';\nimport { without } from '../utils/js_utils';\nvar initialState = {\n  itemType: null,\n  item: null,\n  sourceId: null,\n  targetIds: [],\n  dropResult: null,\n  didDrop: false,\n  isSourcePublic: null\n};\nexport function reduce() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n  var payload = action.payload;\n\n  switch (action.type) {\n    case BEGIN_DRAG:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        itemType: payload.itemType,\n        item: payload.item,\n        sourceId: payload.sourceId,\n        isSourcePublic: payload.isSourcePublic,\n        dropResult: null,\n        didDrop: false\n      });\n\n    case PUBLISH_DRAG_SOURCE:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        isSourcePublic: true\n      });\n\n    case HOVER:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        targetIds: payload.targetIds\n      });\n\n    case REMOVE_TARGET:\n      if (state.targetIds.indexOf(payload.targetId) === -1) {\n        return state;\n      }\n\n      return _objectSpread(_objectSpread({}, state), {}, {\n        targetIds: without(state.targetIds, payload.targetId)\n      });\n\n    case DROP:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        dropResult: payload.dropResult,\n        didDrop: true,\n        targetIds: []\n      });\n\n    case END_DRAG:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        itemType: null,\n        item: null,\n        sourceId: null,\n        dropResult: null,\n        didDrop: false,\n        isSourcePublic: null,\n        targetIds: []\n      });\n\n    default:\n      return state;\n  }\n}","import { ADD_SOURCE, ADD_TARGET, REMOVE_SOURCE, REMOVE_TARGET } from '../actions/registry';\nexport function reduce() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n\n  switch (action.type) {\n    case ADD_SOURCE:\n    case ADD_TARGET:\n      return state + 1;\n\n    case REMOVE_SOURCE:\n    case REMOVE_TARGET:\n      return state - 1;\n\n    default:\n      return state;\n  }\n}","import { intersection } from './js_utils';\nexport var NONE = [];\nexport var ALL = [];\nNONE.__IS_NONE__ = true;\nALL.__IS_ALL__ = true;\n/**\n * Determines if the given handler IDs are dirty or not.\n *\n * @param dirtyIds The set of dirty handler ids\n * @param handlerIds The set of handler ids to check\n */\n\nexport function areDirty(dirtyIds, handlerIds) {\n  if (dirtyIds === NONE) {\n    return false;\n  }\n\n  if (dirtyIds === ALL || typeof handlerIds === 'undefined') {\n    return true;\n  }\n\n  var commonIds = intersection(handlerIds, dirtyIds);\n  return commonIds.length > 0;\n}","import { BEGIN_DRAG, PUBLISH_DRAG_SOURCE, HOVER, END_DRAG, DROP } from '../actions/dragDrop';\nimport { ADD_SOURCE, ADD_TARGET, REMOVE_SOURCE, REMOVE_TARGET } from '../actions/registry';\nimport { areArraysEqual } from '../utils/equality';\nimport { NONE, ALL } from '../utils/dirtiness';\nimport { xor } from '../utils/js_utils';\nexport function reduce() {\n  var _state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NONE;\n\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n\n  switch (action.type) {\n    case HOVER:\n      break;\n\n    case ADD_SOURCE:\n    case ADD_TARGET:\n    case REMOVE_TARGET:\n    case REMOVE_SOURCE:\n      return NONE;\n\n    case BEGIN_DRAG:\n    case PUBLISH_DRAG_SOURCE:\n    case END_DRAG:\n    case DROP:\n    default:\n      return ALL;\n  }\n\n  var _action$payload = action.payload,\n      _action$payload$targe = _action$payload.targetIds,\n      targetIds = _action$payload$targe === void 0 ? [] : _action$payload$targe,\n      _action$payload$prevT = _action$payload.prevTargetIds,\n      prevTargetIds = _action$payload$prevT === void 0 ? [] : _action$payload$prevT;\n  var result = xor(targetIds, prevTargetIds);\n  var didChange = result.length > 0 || !areArraysEqual(targetIds, prevTargetIds);\n\n  if (!didChange) {\n    return NONE;\n  } // Check the target ids at the innermost position. If they are valid, add them\n  // to the result\n\n\n  var prevInnermostTargetId = prevTargetIds[prevTargetIds.length - 1];\n  var innermostTargetId = targetIds[targetIds.length - 1];\n\n  if (prevInnermostTargetId !== innermostTargetId) {\n    if (prevInnermostTargetId) {\n      result.push(prevInnermostTargetId);\n    }\n\n    if (innermostTargetId) {\n      result.push(innermostTargetId);\n    }\n  }\n\n  return result;\n}","export function reduce() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n  return state + 1;\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nimport { reduce as dragOffset } from './dragOffset';\nimport { reduce as dragOperation } from './dragOperation';\nimport { reduce as refCount } from './refCount';\nimport { reduce as dirtyHandlerIds } from './dirtyHandlerIds';\nimport { reduce as stateId } from './stateId';\nimport { get } from '../utils/js_utils';\nexport function reduce() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n  return {\n    dirtyHandlerIds: dirtyHandlerIds(state.dirtyHandlerIds, {\n      type: action.type,\n      payload: _objectSpread(_objectSpread({}, action.payload), {}, {\n        prevTargetIds: get(state, 'dragOperation.targetIds', [])\n      })\n    }),\n    dragOffset: dragOffset(state.dragOffset, action),\n    refCount: refCount(state.refCount, action),\n    dragOperation: dragOperation(state.dragOperation, action),\n    stateId: stateId(state.stateId)\n  };\n}","import { INIT_COORDS } from '../types';\nexport function setClientOffset(clientOffset, sourceClientOffset) {\n  return {\n    type: INIT_COORDS,\n    payload: {\n      sourceClientOffset: sourceClientOffset || null,\n      clientOffset: clientOffset || null\n    }\n  };\n}","import { invariant } from '@react-dnd/invariant';\nimport { setClientOffset } from './local/setClientOffset';\nimport { isObject } from '../../utils/js_utils';\nimport { BEGIN_DRAG, INIT_COORDS } from './types';\nvar ResetCoordinatesAction = {\n  type: INIT_COORDS,\n  payload: {\n    clientOffset: null,\n    sourceClientOffset: null\n  }\n};\nexport function createBeginDrag(manager) {\n  return function beginDrag() {\n    var sourceIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {\n      publishSource: true\n    };\n    var _options$publishSourc = options.publishSource,\n        publishSource = _options$publishSourc === void 0 ? true : _options$publishSourc,\n        clientOffset = options.clientOffset,\n        getSourceClientOffset = options.getSourceClientOffset;\n    var monitor = manager.getMonitor();\n    var registry = manager.getRegistry(); // Initialize the coordinates using the client offset\n\n    manager.dispatch(setClientOffset(clientOffset));\n    verifyInvariants(sourceIds, monitor, registry); // Get the draggable source\n\n    var sourceId = getDraggableSource(sourceIds, monitor);\n\n    if (sourceId === null) {\n      manager.dispatch(ResetCoordinatesAction);\n      return;\n    } // Get the source client offset\n\n\n    var sourceClientOffset = null;\n\n    if (clientOffset) {\n      if (!getSourceClientOffset) {\n        throw new Error('getSourceClientOffset must be defined');\n      }\n\n      verifyGetSourceClientOffsetIsFunction(getSourceClientOffset);\n      sourceClientOffset = getSourceClientOffset(sourceId);\n    } // Initialize the full coordinates\n\n\n    manager.dispatch(setClientOffset(clientOffset, sourceClientOffset));\n    var source = registry.getSource(sourceId);\n    var item = source.beginDrag(monitor, sourceId);\n    verifyItemIsObject(item);\n    registry.pinSource(sourceId);\n    var itemType = registry.getSourceType(sourceId);\n    return {\n      type: BEGIN_DRAG,\n      payload: {\n        itemType: itemType,\n        item: item,\n        sourceId: sourceId,\n        clientOffset: clientOffset || null,\n        sourceClientOffset: sourceClientOffset || null,\n        isSourcePublic: !!publishSource\n      }\n    };\n  };\n}\n\nfunction verifyInvariants(sourceIds, monitor, registry) {\n  invariant(!monitor.isDragging(), 'Cannot call beginDrag while dragging.');\n  sourceIds.forEach(function (sourceId) {\n    invariant(registry.getSource(sourceId), 'Expected sourceIds to be registered.');\n  });\n}\n\nfunction verifyGetSourceClientOffsetIsFunction(getSourceClientOffset) {\n  invariant(typeof getSourceClientOffset === 'function', 'When clientOffset is provided, getSourceClientOffset must be a function.');\n}\n\nfunction verifyItemIsObject(item) {\n  invariant(isObject(item), 'Item must be an object.');\n}\n\nfunction getDraggableSource(sourceIds, monitor) {\n  var sourceId = null;\n\n  for (var i = sourceIds.length - 1; i >= 0; i--) {\n    if (monitor.canDragSource(sourceIds[i])) {\n      sourceId = sourceIds[i];\n      break;\n    }\n  }\n\n  return sourceId;\n}","import { PUBLISH_DRAG_SOURCE } from './types';\nexport function createPublishDragSource(manager) {\n  return function publishDragSource() {\n    var monitor = manager.getMonitor();\n\n    if (monitor.isDragging()) {\n      return {\n        type: PUBLISH_DRAG_SOURCE\n      };\n    }\n  };\n}","export function matchesType(targetType, draggedItemType) {\n  if (draggedItemType === null) {\n    return targetType === null;\n  }\n\n  return Array.isArray(targetType) ? targetType.some(function (t) {\n    return t === draggedItemType;\n  }) : targetType === draggedItemType;\n}","import { invariant } from '@react-dnd/invariant';\nimport { matchesType } from '../../utils/matchesType';\nimport { HOVER } from './types';\nexport function createHover(manager) {\n  return function hover(targetIdsArg) {\n    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n        clientOffset = _ref.clientOffset;\n\n    verifyTargetIdsIsArray(targetIdsArg);\n    var targetIds = targetIdsArg.slice(0);\n    var monitor = manager.getMonitor();\n    var registry = manager.getRegistry();\n    checkInvariants(targetIds, monitor, registry);\n    var draggedItemType = monitor.getItemType();\n    removeNonMatchingTargetIds(targetIds, registry, draggedItemType);\n    hoverAllTargets(targetIds, monitor, registry);\n    return {\n      type: HOVER,\n      payload: {\n        targetIds: targetIds,\n        clientOffset: clientOffset || null\n      }\n    };\n  };\n}\n\nfunction verifyTargetIdsIsArray(targetIdsArg) {\n  invariant(Array.isArray(targetIdsArg), 'Expected targetIds to be an array.');\n}\n\nfunction checkInvariants(targetIds, monitor, registry) {\n  invariant(monitor.isDragging(), 'Cannot call hover while not dragging.');\n  invariant(!monitor.didDrop(), 'Cannot call hover after drop.');\n\n  for (var i = 0; i < targetIds.length; i++) {\n    var targetId = targetIds[i];\n    invariant(targetIds.lastIndexOf(targetId) === i, 'Expected targetIds to be unique in the passed array.');\n    var target = registry.getTarget(targetId);\n    invariant(target, 'Expected targetIds to be registered.');\n  }\n}\n\nfunction removeNonMatchingTargetIds(targetIds, registry, draggedItemType) {\n  // Remove those targetIds that don't match the targetType.  This\n  // fixes shallow isOver which would only be non-shallow because of\n  // non-matching targets.\n  for (var i = targetIds.length - 1; i >= 0; i--) {\n    var targetId = targetIds[i];\n    var targetType = registry.getTargetType(targetId);\n\n    if (!matchesType(targetType, draggedItemType)) {\n      targetIds.splice(i, 1);\n    }\n  }\n}\n\nfunction hoverAllTargets(targetIds, monitor, registry) {\n  // Finally call hover on all matching targets.\n  targetIds.forEach(function (targetId) {\n    var target = registry.getTarget(targetId);\n    target.hover(monitor, targetId);\n  });\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nimport { invariant } from '@react-dnd/invariant';\nimport { DROP } from './types';\nimport { isObject } from '../../utils/js_utils';\nexport function createDrop(manager) {\n  return function drop() {\n    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var monitor = manager.getMonitor();\n    var registry = manager.getRegistry();\n    verifyInvariants(monitor);\n    var targetIds = getDroppableTargets(monitor); // Multiple actions are dispatched here, which is why this doesn't return an action\n\n    targetIds.forEach(function (targetId, index) {\n      var dropResult = determineDropResult(targetId, index, registry, monitor);\n      var action = {\n        type: DROP,\n        payload: {\n          dropResult: _objectSpread(_objectSpread({}, options), dropResult)\n        }\n      };\n      manager.dispatch(action);\n    });\n  };\n}\n\nfunction verifyInvariants(monitor) {\n  invariant(monitor.isDragging(), 'Cannot call drop while not dragging.');\n  invariant(!monitor.didDrop(), 'Cannot call drop twice during one drag operation.');\n}\n\nfunction determineDropResult(targetId, index, registry, monitor) {\n  var target = registry.getTarget(targetId);\n  var dropResult = target ? target.drop(monitor, targetId) : undefined;\n  verifyDropResultType(dropResult);\n\n  if (typeof dropResult === 'undefined') {\n    dropResult = index === 0 ? {} : monitor.getDropResult();\n  }\n\n  return dropResult;\n}\n\nfunction verifyDropResultType(dropResult) {\n  invariant(typeof dropResult === 'undefined' || isObject(dropResult), 'Drop result must either be an object or undefined.');\n}\n\nfunction getDroppableTargets(monitor) {\n  var targetIds = monitor.getTargetIds().filter(monitor.canDropOnTarget, monitor);\n  targetIds.reverse();\n  return targetIds;\n}","import { invariant } from '@react-dnd/invariant';\nimport { END_DRAG } from './types';\nexport function createEndDrag(manager) {\n  return function endDrag() {\n    var monitor = manager.getMonitor();\n    var registry = manager.getRegistry();\n    verifyIsDragging(monitor);\n    var sourceId = monitor.getSourceId();\n\n    if (sourceId != null) {\n      var source = registry.getSource(sourceId, true);\n      source.endDrag(monitor, sourceId);\n      registry.unpinSource();\n    }\n\n    return {\n      type: END_DRAG\n    };\n  };\n}\n\nfunction verifyIsDragging(monitor) {\n  invariant(monitor.isDragging(), 'Cannot call endDrag while not dragging.');\n}","/**\n * Coordinate addition\n * @param a The first coordinate\n * @param b The second coordinate\n */\nexport function add(a, b) {\n  return {\n    x: a.x + b.x,\n    y: a.y + b.y\n  };\n}\n/**\n * Coordinate subtraction\n * @param a The first coordinate\n * @param b The second coordinate\n */\n\nexport function subtract(a, b) {\n  return {\n    x: a.x - b.x,\n    y: a.y - b.y\n  };\n}\n/**\n * Returns the cartesian distance of the drag source component's position, based on its position\n * at the time when the current drag operation has started, and the movement difference.\n *\n * Returns null if no item is being dragged.\n *\n * @param state The offset state to compute from\n */\n\nexport function getSourceClientOffset(state) {\n  var clientOffset = state.clientOffset,\n      initialClientOffset = state.initialClientOffset,\n      initialSourceClientOffset = state.initialSourceClientOffset;\n\n  if (!clientOffset || !initialClientOffset || !initialSourceClientOffset) {\n    return null;\n  }\n\n  return subtract(add(clientOffset, initialSourceClientOffset), initialClientOffset);\n}\n/**\n * Determines the x,y offset between the client offset and the initial client offset\n *\n * @param state The offset state to compute from\n */\n\nexport function getDifferenceFromInitialOffset(state) {\n  var clientOffset = state.clientOffset,\n      initialClientOffset = state.initialClientOffset;\n\n  if (!clientOffset || !initialClientOffset) {\n    return null;\n  }\n\n  return subtract(clientOffset, initialClientOffset);\n}","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nimport { invariant } from '@react-dnd/invariant';\nimport { matchesType } from './utils/matchesType';\nimport { getSourceClientOffset as _getSourceClientOffset, getDifferenceFromInitialOffset as _getDifferenceFromInitialOffset } from './utils/coords';\nimport { areDirty } from './utils/dirtiness';\nexport var DragDropMonitorImpl = /*#__PURE__*/function () {\n  function DragDropMonitorImpl(store, registry) {\n    _classCallCheck(this, DragDropMonitorImpl);\n\n    this.store = store;\n    this.registry = registry;\n  }\n\n  _createClass(DragDropMonitorImpl, [{\n    key: \"subscribeToStateChange\",\n    value: function subscribeToStateChange(listener) {\n      var _this = this;\n\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {\n        handlerIds: undefined\n      };\n      var handlerIds = options.handlerIds;\n      invariant(typeof listener === 'function', 'listener must be a function.');\n      invariant(typeof handlerIds === 'undefined' || Array.isArray(handlerIds), 'handlerIds, when specified, must be an array of strings.');\n      var prevStateId = this.store.getState().stateId;\n\n      var handleChange = function handleChange() {\n        var state = _this.store.getState();\n\n        var currentStateId = state.stateId;\n\n        try {\n          var canSkipListener = currentStateId === prevStateId || currentStateId === prevStateId + 1 && !areDirty(state.dirtyHandlerIds, handlerIds);\n\n          if (!canSkipListener) {\n            listener();\n          }\n        } finally {\n          prevStateId = currentStateId;\n        }\n      };\n\n      return this.store.subscribe(handleChange);\n    }\n  }, {\n    key: \"subscribeToOffsetChange\",\n    value: function subscribeToOffsetChange(listener) {\n      var _this2 = this;\n\n      invariant(typeof listener === 'function', 'listener must be a function.');\n      var previousState = this.store.getState().dragOffset;\n\n      var handleChange = function handleChange() {\n        var nextState = _this2.store.getState().dragOffset;\n\n        if (nextState === previousState) {\n          return;\n        }\n\n        previousState = nextState;\n        listener();\n      };\n\n      return this.store.subscribe(handleChange);\n    }\n  }, {\n    key: \"canDragSource\",\n    value: function canDragSource(sourceId) {\n      if (!sourceId) {\n        return false;\n      }\n\n      var source = this.registry.getSource(sourceId);\n      invariant(source, 'Expected to find a valid source.');\n\n      if (this.isDragging()) {\n        return false;\n      }\n\n      return source.canDrag(this, sourceId);\n    }\n  }, {\n    key: \"canDropOnTarget\",\n    value: function canDropOnTarget(targetId) {\n      // undefined on initial render\n      if (!targetId) {\n        return false;\n      }\n\n      var target = this.registry.getTarget(targetId);\n      invariant(target, 'Expected to find a valid target.');\n\n      if (!this.isDragging() || this.didDrop()) {\n        return false;\n      }\n\n      var targetType = this.registry.getTargetType(targetId);\n      var draggedItemType = this.getItemType();\n      return matchesType(targetType, draggedItemType) && target.canDrop(this, targetId);\n    }\n  }, {\n    key: \"isDragging\",\n    value: function isDragging() {\n      return Boolean(this.getItemType());\n    }\n  }, {\n    key: \"isDraggingSource\",\n    value: function isDraggingSource(sourceId) {\n      // undefined on initial render\n      if (!sourceId) {\n        return false;\n      }\n\n      var source = this.registry.getSource(sourceId, true);\n      invariant(source, 'Expected to find a valid source.');\n\n      if (!this.isDragging() || !this.isSourcePublic()) {\n        return false;\n      }\n\n      var sourceType = this.registry.getSourceType(sourceId);\n      var draggedItemType = this.getItemType();\n\n      if (sourceType !== draggedItemType) {\n        return false;\n      }\n\n      return source.isDragging(this, sourceId);\n    }\n  }, {\n    key: \"isOverTarget\",\n    value: function isOverTarget(targetId) {\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {\n        shallow: false\n      }; // undefined on initial render\n\n      if (!targetId) {\n        return false;\n      }\n\n      var shallow = options.shallow;\n\n      if (!this.isDragging()) {\n        return false;\n      }\n\n      var targetType = this.registry.getTargetType(targetId);\n      var draggedItemType = this.getItemType();\n\n      if (draggedItemType && !matchesType(targetType, draggedItemType)) {\n        return false;\n      }\n\n      var targetIds = this.getTargetIds();\n\n      if (!targetIds.length) {\n        return false;\n      }\n\n      var index = targetIds.indexOf(targetId);\n\n      if (shallow) {\n        return index === targetIds.length - 1;\n      } else {\n        return index > -1;\n      }\n    }\n  }, {\n    key: \"getItemType\",\n    value: function getItemType() {\n      return this.store.getState().dragOperation.itemType;\n    }\n  }, {\n    key: \"getItem\",\n    value: function getItem() {\n      return this.store.getState().dragOperation.item;\n    }\n  }, {\n    key: \"getSourceId\",\n    value: function getSourceId() {\n      return this.store.getState().dragOperation.sourceId;\n    }\n  }, {\n    key: \"getTargetIds\",\n    value: function getTargetIds() {\n      return this.store.getState().dragOperation.targetIds;\n    }\n  }, {\n    key: \"getDropResult\",\n    value: function getDropResult() {\n      return this.store.getState().dragOperation.dropResult;\n    }\n  }, {\n    key: \"didDrop\",\n    value: function didDrop() {\n      return this.store.getState().dragOperation.didDrop;\n    }\n  }, {\n    key: \"isSourcePublic\",\n    value: function isSourcePublic() {\n      return Boolean(this.store.getState().dragOperation.isSourcePublic);\n    }\n  }, {\n    key: \"getInitialClientOffset\",\n    value: function getInitialClientOffset() {\n      return this.store.getState().dragOffset.initialClientOffset;\n    }\n  }, {\n    key: \"getInitialSourceClientOffset\",\n    value: function getInitialSourceClientOffset() {\n      return this.store.getState().dragOffset.initialSourceClientOffset;\n    }\n  }, {\n    key: \"getClientOffset\",\n    value: function getClientOffset() {\n      return this.store.getState().dragOffset.clientOffset;\n    }\n  }, {\n    key: \"getSourceClientOffset\",\n    value: function getSourceClientOffset() {\n      return _getSourceClientOffset(this.store.getState().dragOffset);\n    }\n  }, {\n    key: \"getDifferenceFromInitialOffset\",\n    value: function getDifferenceFromInitialOffset() {\n      return _getDifferenceFromInitialOffset(this.store.getState().dragOffset);\n    }\n  }]);\n\n  return DragDropMonitorImpl;\n}();","export var HandlerRole;\n\n(function (HandlerRole) {\n  HandlerRole[\"SOURCE\"] = \"SOURCE\";\n  HandlerRole[\"TARGET\"] = \"TARGET\";\n})(HandlerRole || (HandlerRole = {}));","var nextUniqueId = 0;\nexport function getNextUniqueId() {\n  return nextUniqueId++;\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nimport { invariant } from '@react-dnd/invariant';\nexport function validateSourceContract(source) {\n  invariant(typeof source.canDrag === 'function', 'Expected canDrag to be a function.');\n  invariant(typeof source.beginDrag === 'function', 'Expected beginDrag to be a function.');\n  invariant(typeof source.endDrag === 'function', 'Expected endDrag to be a function.');\n}\nexport function validateTargetContract(target) {\n  invariant(typeof target.canDrop === 'function', 'Expected canDrop to be a function.');\n  invariant(typeof target.hover === 'function', 'Expected hover to be a function.');\n  invariant(typeof target.drop === 'function', 'Expected beginDrag to be a function.');\n}\nexport function validateType(type, allowArray) {\n  if (allowArray && Array.isArray(type)) {\n    type.forEach(function (t) {\n      return validateType(t, false);\n    });\n    return;\n  }\n\n  invariant(typeof type === 'string' || _typeof(type) === 'symbol', allowArray ? 'Type can only be a string, a symbol, or an array of either.' : 'Type can only be a string or a symbol.');\n}","import { rawAsap } from './raw'; // rawAsap provides everything we need except exception management.\n// RawTasks are recycled to reduce GC churn.\n\nvar freeTasks = []; // We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\n\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n  if (pendingErrors.length) {\n    throw pendingErrors.shift();\n  }\n}\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\n\n\nexport function asap(task) {\n  var rawTask;\n\n  if (freeTasks.length) {\n    rawTask = freeTasks.pop();\n  } else {\n    rawTask = new RawTask();\n  }\n\n  rawTask.task = task;\n  rawAsap(rawTask);\n} // We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\n\nvar RawTask =\n/** @class */\nfunction () {\n  function RawTask() {}\n\n  RawTask.prototype.call = function () {\n    try {\n      this.task.call();\n    } catch (error) {\n      if (asap.onerror) {\n        // This hook exists purely for testing purposes.\n        // Its name will be periodically randomized to break any code that\n        // depends on its existence.\n        asap.onerror(error);\n      } else {\n        // In a web browser, exceptions are not fatal. However, to avoid\n        // slowing down the queue of pending tasks, we rethrow the error in a\n        // lower priority turn.\n        pendingErrors.push(error);\n        requestErrorThrow();\n      }\n    } finally {\n      this.task = null;\n      freeTasks[freeTasks.length] = this;\n    }\n  };\n\n  return RawTask;\n}();","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nimport { invariant } from '@react-dnd/invariant';\nimport { addSource as _addSource, addTarget as _addTarget, removeSource as _removeSource, removeTarget as _removeTarget } from './actions/registry';\nimport { getNextUniqueId } from './utils/getNextUniqueId';\nimport { HandlerRole } from './interfaces';\nimport { validateSourceContract, validateTargetContract, validateType } from './contracts';\nimport { asap } from '@react-dnd/asap';\n\nfunction getNextHandlerId(role) {\n  var id = getNextUniqueId().toString();\n\n  switch (role) {\n    case HandlerRole.SOURCE:\n      return \"S\".concat(id);\n\n    case HandlerRole.TARGET:\n      return \"T\".concat(id);\n\n    default:\n      throw new Error(\"Unknown Handler Role: \".concat(role));\n  }\n}\n\nfunction parseRoleFromHandlerId(handlerId) {\n  switch (handlerId[0]) {\n    case 'S':\n      return HandlerRole.SOURCE;\n\n    case 'T':\n      return HandlerRole.TARGET;\n\n    default:\n      invariant(false, \"Cannot parse handler ID: \".concat(handlerId));\n  }\n}\n\nfunction mapContainsValue(map, searchValue) {\n  var entries = map.entries();\n  var isDone = false;\n\n  do {\n    var _entries$next = entries.next(),\n        done = _entries$next.done,\n        _entries$next$value = _slicedToArray(_entries$next.value, 2),\n        value = _entries$next$value[1];\n\n    if (value === searchValue) {\n      return true;\n    }\n\n    isDone = !!done;\n  } while (!isDone);\n\n  return false;\n}\n\nexport var HandlerRegistryImpl = /*#__PURE__*/function () {\n  function HandlerRegistryImpl(store) {\n    _classCallCheck(this, HandlerRegistryImpl);\n\n    this.types = new Map();\n    this.dragSources = new Map();\n    this.dropTargets = new Map();\n    this.pinnedSourceId = null;\n    this.pinnedSource = null;\n    this.store = store;\n  }\n\n  _createClass(HandlerRegistryImpl, [{\n    key: \"addSource\",\n    value: function addSource(type, source) {\n      validateType(type);\n      validateSourceContract(source);\n      var sourceId = this.addHandler(HandlerRole.SOURCE, type, source);\n      this.store.dispatch(_addSource(sourceId));\n      return sourceId;\n    }\n  }, {\n    key: \"addTarget\",\n    value: function addTarget(type, target) {\n      validateType(type, true);\n      validateTargetContract(target);\n      var targetId = this.addHandler(HandlerRole.TARGET, type, target);\n      this.store.dispatch(_addTarget(targetId));\n      return targetId;\n    }\n  }, {\n    key: \"containsHandler\",\n    value: function containsHandler(handler) {\n      return mapContainsValue(this.dragSources, handler) || mapContainsValue(this.dropTargets, handler);\n    }\n  }, {\n    key: \"getSource\",\n    value: function getSource(sourceId) {\n      var includePinned = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');\n      var isPinned = includePinned && sourceId === this.pinnedSourceId;\n      var source = isPinned ? this.pinnedSource : this.dragSources.get(sourceId);\n      return source;\n    }\n  }, {\n    key: \"getTarget\",\n    value: function getTarget(targetId) {\n      invariant(this.isTargetId(targetId), 'Expected a valid target ID.');\n      return this.dropTargets.get(targetId);\n    }\n  }, {\n    key: \"getSourceType\",\n    value: function getSourceType(sourceId) {\n      invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');\n      return this.types.get(sourceId);\n    }\n  }, {\n    key: \"getTargetType\",\n    value: function getTargetType(targetId) {\n      invariant(this.isTargetId(targetId), 'Expected a valid target ID.');\n      return this.types.get(targetId);\n    }\n  }, {\n    key: \"isSourceId\",\n    value: function isSourceId(handlerId) {\n      var role = parseRoleFromHandlerId(handlerId);\n      return role === HandlerRole.SOURCE;\n    }\n  }, {\n    key: \"isTargetId\",\n    value: function isTargetId(handlerId) {\n      var role = parseRoleFromHandlerId(handlerId);\n      return role === HandlerRole.TARGET;\n    }\n  }, {\n    key: \"removeSource\",\n    value: function removeSource(sourceId) {\n      var _this = this;\n\n      invariant(this.getSource(sourceId), 'Expected an existing source.');\n      this.store.dispatch(_removeSource(sourceId));\n      asap(function () {\n        _this.dragSources.delete(sourceId);\n\n        _this.types.delete(sourceId);\n      });\n    }\n  }, {\n    key: \"removeTarget\",\n    value: function removeTarget(targetId) {\n      invariant(this.getTarget(targetId), 'Expected an existing target.');\n      this.store.dispatch(_removeTarget(targetId));\n      this.dropTargets.delete(targetId);\n      this.types.delete(targetId);\n    }\n  }, {\n    key: \"pinSource\",\n    value: function pinSource(sourceId) {\n      var source = this.getSource(sourceId);\n      invariant(source, 'Expected an existing source.');\n      this.pinnedSourceId = sourceId;\n      this.pinnedSource = source;\n    }\n  }, {\n    key: \"unpinSource\",\n    value: function unpinSource() {\n      invariant(this.pinnedSource, 'No source is pinned at the time.');\n      this.pinnedSourceId = null;\n      this.pinnedSource = null;\n    }\n  }, {\n    key: \"addHandler\",\n    value: function addHandler(role, type, handler) {\n      var id = getNextHandlerId(role);\n      this.types.set(id, type);\n\n      if (role === HandlerRole.SOURCE) {\n        this.dragSources.set(id, handler);\n      } else if (role === HandlerRole.TARGET) {\n        this.dropTargets.set(id, handler);\n      }\n\n      return id;\n    }\n  }]);\n\n  return HandlerRegistryImpl;\n}();","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nimport { createStore } from 'redux';\nimport { reduce } from './reducers';\nimport { createDragDropActions } from './actions/dragDrop';\nimport { DragDropMonitorImpl } from './DragDropMonitorImpl';\nimport { HandlerRegistryImpl } from './HandlerRegistryImpl';\n\nfunction makeStoreInstance(debugMode) {\n  // TODO: if we ever make a react-native version of this,\n  // we'll need to consider how to pull off dev-tooling\n  var reduxDevTools = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__;\n  return createStore(reduce, debugMode && reduxDevTools && reduxDevTools({\n    name: 'dnd-core',\n    instanceId: 'dnd-core'\n  }));\n}\n\nexport var DragDropManagerImpl = /*#__PURE__*/function () {\n  function DragDropManagerImpl() {\n    var _this = this;\n\n    var debugMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n    _classCallCheck(this, DragDropManagerImpl);\n\n    this.isSetUp = false;\n\n    this.handleRefCountChange = function () {\n      var shouldSetUp = _this.store.getState().refCount > 0;\n\n      if (_this.backend) {\n        if (shouldSetUp && !_this.isSetUp) {\n          _this.backend.setup();\n\n          _this.isSetUp = true;\n        } else if (!shouldSetUp && _this.isSetUp) {\n          _this.backend.teardown();\n\n          _this.isSetUp = false;\n        }\n      }\n    };\n\n    var store = makeStoreInstance(debugMode);\n    this.store = store;\n    this.monitor = new DragDropMonitorImpl(store, new HandlerRegistryImpl(store));\n    store.subscribe(this.handleRefCountChange);\n  }\n\n  _createClass(DragDropManagerImpl, [{\n    key: \"receiveBackend\",\n    value: function receiveBackend(backend) {\n      this.backend = backend;\n    }\n  }, {\n    key: \"getMonitor\",\n    value: function getMonitor() {\n      return this.monitor;\n    }\n  }, {\n    key: \"getBackend\",\n    value: function getBackend() {\n      return this.backend;\n    }\n  }, {\n    key: \"getRegistry\",\n    value: function getRegistry() {\n      return this.monitor.registry;\n    }\n  }, {\n    key: \"getActions\",\n    value: function getActions() {\n      /* eslint-disable-next-line @typescript-eslint/no-this-alias */\n      var manager = this;\n      var dispatch = this.store.dispatch;\n\n      function bindActionCreator(actionCreator) {\n        return function () {\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n\n          var action = actionCreator.apply(manager, args);\n\n          if (typeof action !== 'undefined') {\n            dispatch(action);\n          }\n        };\n      }\n\n      var actions = createDragDropActions(this);\n      return Object.keys(actions).reduce(function (boundActions, key) {\n        var action = actions[key];\n        boundActions[key] = bindActionCreator(action);\n        return boundActions;\n      }, {});\n    }\n  }, {\n    key: \"dispatch\",\n    value: function dispatch(action) {\n      this.store.dispatch(action);\n    }\n  }]);\n\n  return DragDropManagerImpl;\n}();","import { createBeginDrag } from './beginDrag';\nimport { createPublishDragSource } from './publishDragSource';\nimport { createHover } from './hover';\nimport { createDrop } from './drop';\nimport { createEndDrag } from './endDrag';\nexport * from './types';\nexport function createDragDropActions(manager) {\n  return {\n    beginDrag: createBeginDrag(manager),\n    publishDragSource: createPublishDragSource(manager),\n    hover: createHover(manager),\n    drop: createDrop(manager),\n    endDrag: createEndDrag(manager)\n  };\n}","import { DragDropManagerImpl } from './DragDropManagerImpl';\nexport function createDragDropManager(backendFactory, globalContext, backendOptions, debugMode) {\n  var manager = new DragDropManagerImpl(debugMode);\n  var backend = backendFactory(manager, globalContext, backendOptions);\n  manager.receiveBackend(backend);\n  return manager;\n}","import * as React from 'react';\nimport { createDragDropManager } from 'dnd-core';\n/**\n * Create the React Context\n */\n\nexport var DndContext = React.createContext({\n  dragDropManager: undefined\n});\n/**\n * Creates the context object we're providing\n * @param backend\n * @param context\n */\n\nexport function createDndContext(backend, context, options, debugMode) {\n  return {\n    dragDropManager: createDragDropManager(backend, context, options, debugMode)\n  };\n}","// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nexport function rawAsap(task) {\n  if (!queue.length) {\n    requestFlush();\n    flushing = true;\n  } // Equivalent to push, but avoids a function call.\n\n\n  queue[queue.length] = task;\n}\nvar queue = []; // Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\n// @ts-ignore\n\nvar flushing = false; // `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\n\nvar requestFlush; // The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\n\nvar index = 0; // If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\n\nvar capacity = 1024; // The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\n\nfunction flush() {\n  while (index < queue.length) {\n    var currentIndex = index; // Advance the index before calling the task. This ensures that we will\n    // begin flushing on the next task the task throws an error.\n\n    index = index + 1;\n    queue[currentIndex].call(); // Prevent leaking memory for long chains of recursive calls to `asap`.\n    // If we call `asap` within tasks scheduled by `asap`, the queue will\n    // grow, but to avoid an O(n) walk for every task we execute, we don't\n    // shift tasks off the queue after they have been executed.\n    // Instead, we periodically shift 1024 tasks off the queue.\n\n    if (index > capacity) {\n      // Manually shift all values starting at the index back to the\n      // beginning of the queue.\n      for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n        queue[scan] = queue[scan + index];\n      }\n\n      queue.length -= index;\n      index = 0;\n    }\n  }\n\n  queue.length = 0;\n  index = 0;\n  flushing = false;\n} // `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\n\n\nvar scope = typeof global !== 'undefined' ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver; // MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\n\nif (typeof BrowserMutationObserver === 'function') {\n  requestFlush = makeRequestCallFromMutationObserver(flush); // MessageChannels are desirable because they give direct access to the HTML\n  // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n  // 11-12, and in web workers in many engines.\n  // Although message channels yield to any queued rendering and IO tasks, they\n  // would be better than imposing the 4ms delay of timers.\n  // However, they do not work reliably in Internet Explorer or Safari.\n  // Internet Explorer 10 is the only browser that has setImmediate but does\n  // not have MutationObservers.\n  // Although setImmediate yields to the browser's renderer, it would be\n  // preferrable to falling back to setTimeout since it does not have\n  // the minimum 4ms penalty.\n  // Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n  // Desktop to a lesser extent) that renders both setImmediate and\n  // MessageChannel useless for the purposes of ASAP.\n  // https://github.com/kriskowal/q/issues/396\n  // Timers are implemented universally.\n  // We fall back to timers in workers in most engines, and in foreground\n  // contexts in the following browsers.\n  // However, note that even this simple case requires nuances to operate in a\n  // broad spectrum of browsers.\n  //\n  // - Firefox 3-13\n  // - Internet Explorer 6-9\n  // - iPad Safari 4.3\n  // - Lynx 2.8.7\n} else {\n  requestFlush = makeRequestCallFromTimer(flush);\n} // `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\n\n\nrawAsap.requestFlush = requestFlush; // To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\n\nfunction makeRequestCallFromMutationObserver(callback) {\n  var toggle = 1;\n  var observer = new BrowserMutationObserver(callback);\n  var node = document.createTextNode('');\n  observer.observe(node, {\n    characterData: true\n  });\n  return function requestCall() {\n    toggle = -toggle;\n    node.data = toggle;\n  };\n} // The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\n\nfunction makeRequestCallFromTimer(callback) {\n  return function requestCall() {\n    // We dispatch a timeout with a specified delay of 0 for engines that\n    // can reliably accommodate that request. This will usually be snapped\n    // to a 4 milisecond delay, but once we're flushing, there's no delay\n    // between events.\n    var timeoutHandle = setTimeout(handleTimer, 0); // However, since this timer gets frequently dropped in Firefox\n    // workers, we enlist an interval handle that will try to fire\n    // an event 20 times per second until it succeeds.\n\n    var intervalHandle = setInterval(handleTimer, 50);\n\n    function handleTimer() {\n      // Whichever timer succeeds will cancel both timers and\n      // execute the callback.\n      clearTimeout(timeoutHandle);\n      clearInterval(intervalHandle);\n      callback();\n    }\n  };\n} // This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\n\n\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer; // ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js"],"sourceRoot":""}