{"version":3,"file":"dnd-core-B-OxvsoS.js","sources":["../../node_modules/dnd-core/node_modules/redux/es/redux.js","../../node_modules/dnd-core/dist/utils/js_utils.js","../../node_modules/dnd-core/dist/actions/dragDrop/types.js","../../node_modules/dnd-core/dist/actions/dragDrop/local/setClientOffset.js","../../node_modules/dnd-core/dist/actions/dragDrop/beginDrag.js","../../node_modules/dnd-core/dist/actions/dragDrop/drop.js","../../node_modules/dnd-core/dist/actions/dragDrop/endDrag.js","../../node_modules/dnd-core/dist/utils/matchesType.js","../../node_modules/dnd-core/dist/actions/dragDrop/hover.js","../../node_modules/dnd-core/dist/actions/dragDrop/publishDragSource.js","../../node_modules/dnd-core/dist/actions/dragDrop/index.js","../../node_modules/dnd-core/dist/classes/DragDropManagerImpl.js","../../node_modules/dnd-core/dist/utils/coords.js","../../node_modules/dnd-core/dist/utils/dirtiness.js","../../node_modules/dnd-core/dist/classes/DragDropMonitorImpl.js","../../node_modules/dnd-core/dist/actions/registry.js","../../node_modules/dnd-core/dist/contracts.js","../../node_modules/dnd-core/dist/interfaces.js","../../node_modules/dnd-core/dist/utils/getNextUniqueId.js","../../node_modules/dnd-core/dist/classes/HandlerRegistryImpl.js","../../node_modules/dnd-core/dist/utils/equality.js","../../node_modules/dnd-core/dist/reducers/dirtyHandlerIds.js","../../node_modules/dnd-core/dist/reducers/dragOffset.js","../../node_modules/dnd-core/dist/reducers/dragOperation.js","../../node_modules/dnd-core/dist/reducers/refCount.js","../../node_modules/dnd-core/dist/reducers/stateId.js","../../node_modules/dnd-core/dist/reducers/index.js","../../node_modules/dnd-core/dist/createDragDropManager.js"],"sourcesContent":["import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';\n\n/**\n * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js\n *\n * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes\n * during build.\n * @param {number} code\n */\nfunction formatProdErrorMessage(code) {\n  return \"Minified Redux error #\" + code + \"; visit https://redux.js.org/Errors?code=\" + code + \" for the full message or \" + 'use the non-minified dev environment for full errors. ';\n}\n\n// Inlined version of the `symbol-observable` polyfill\nvar $$observable = (function () {\n  return typeof Symbol === 'function' && Symbol.observable || '@@observable';\n})();\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nvar randomString = function randomString() {\n  return Math.random().toString(36).substring(7).split('').join('.');\n};\n\nvar ActionTypes = {\n  INIT: \"@@redux/INIT\" + randomString(),\n  REPLACE: \"@@redux/REPLACE\" + randomString(),\n  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {\n    return \"@@redux/PROBE_UNKNOWN_ACTION\" + randomString();\n  }\n};\n\n/**\n * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\nfunction isPlainObject(obj) {\n  if (typeof obj !== 'object' || obj === null) return false;\n  var proto = obj;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(obj) === proto;\n}\n\n// Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of\nfunction miniKindOf(val) {\n  if (val === void 0) return 'undefined';\n  if (val === null) return 'null';\n  var type = typeof val;\n\n  switch (type) {\n    case 'boolean':\n    case 'string':\n    case 'number':\n    case 'symbol':\n    case 'function':\n      {\n        return type;\n      }\n  }\n\n  if (Array.isArray(val)) return 'array';\n  if (isDate(val)) return 'date';\n  if (isError(val)) return 'error';\n  var constructorName = ctorName(val);\n\n  switch (constructorName) {\n    case 'Symbol':\n    case 'Promise':\n    case 'WeakMap':\n    case 'WeakSet':\n    case 'Map':\n    case 'Set':\n      return constructorName;\n  } // other\n\n\n  return type.slice(8, -1).toLowerCase().replace(/\\s/g, '');\n}\n\nfunction ctorName(val) {\n  return typeof val.constructor === 'function' ? val.constructor.name : null;\n}\n\nfunction isError(val) {\n  return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';\n}\n\nfunction isDate(val) {\n  if (val instanceof Date) return true;\n  return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';\n}\n\nfunction kindOf(val) {\n  var typeOfVal = typeof val;\n\n  if (process.env.NODE_ENV !== 'production') {\n    typeOfVal = miniKindOf(val);\n  }\n\n  return typeOfVal;\n}\n\n/**\n * @deprecated\n *\n * **We recommend using the `configureStore` method\n * of the `@reduxjs/toolkit` package**, which replaces `createStore`.\n *\n * Redux Toolkit is our recommended approach for writing Redux logic today,\n * including store setup, reducers, data fetching, and more.\n *\n * **For more details, please read this Redux docs page:**\n * **https://redux.js.org/introduction/why-rtk-is-redux-today**\n *\n * `configureStore` from Redux Toolkit is an improved version of `createStore` that\n * simplifies setup and helps avoid common bugs.\n *\n * You should not be using the `redux` core package by itself today, except for learning purposes.\n * The `createStore` method from the core `redux` package will not be removed, but we encourage\n * all users to migrate to using Redux Toolkit for all Redux code.\n *\n * If you want to use `createStore` without this visual deprecation warning, use\n * the `legacy_createStore` import instead:\n *\n * `import { legacy_createStore as createStore} from 'redux'`\n *\n */\n\nfunction createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(0) : 'It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.');\n  }\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(1) : \"Expected the enhancer to be a function. Instead, received: '\" + kindOf(enhancer) + \"'\");\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(2) : \"Expected the root reducer to be a function. Instead, received: '\" + kindOf(reducer) + \"'\");\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n  /**\n   * This makes a shallow copy of currentListeners so we can use\n   * nextListeners as a temporary list while dispatching.\n   *\n   * This prevents any bugs around consumers calling\n   * subscribe/unsubscribe in the middle of a dispatch.\n   */\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n\n\n  function getState() {\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(3) : 'You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');\n    }\n\n    return currentState;\n  }\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n\n\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(4) : \"Expected the listener to be a function. Instead, received: '\" + kindOf(listener) + \"'\");\n    }\n\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(5) : 'You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api/store#subscribelistener for more details.');\n    }\n\n    var isSubscribed = true;\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      if (isDispatching) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(6) : 'You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api/store#subscribelistener for more details.');\n      }\n\n      isSubscribed = false;\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n      currentListeners = null;\n    };\n  }\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n\n\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(7) : \"Actions must be plain objects. Instead, the actual type was: '\" + kindOf(action) + \"'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.\");\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(8) : 'Actions may not have an undefined \"type\" property. You may have misspelled an action type string constant.');\n    }\n\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(9) : 'Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n\n\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(10) : \"Expected the nextReducer to be a function. Instead, received: '\" + kindOf(nextReducer));\n    }\n\n    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.\n    // Any reducers that existed in both the new and old rootReducer\n    // will receive the previous state. This effectively populates\n    // the new state tree with any relevant data from the old one.\n\n    dispatch({\n      type: ActionTypes.REPLACE\n    });\n  }\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n\n\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object' || observer === null) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(11) : \"Expected the observer to be an object. Instead, received: '\" + kindOf(observer) + \"'\");\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return {\n          unsubscribe: unsubscribe\n        };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  } // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n\n\n  dispatch({\n    type: ActionTypes.INIT\n  });\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}\n/**\n * Creates a Redux store that holds the state tree.\n *\n * **We recommend using `configureStore` from the\n * `@reduxjs/toolkit` package**, which replaces `createStore`:\n * **https://redux.js.org/introduction/why-rtk-is-redux-today**\n *\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n\nvar legacy_createStore = createStore;\n\n/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nfunction warning(message) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message);\n  }\n  /* eslint-enable no-console */\n\n\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message);\n  } catch (e) {} // eslint-disable-line no-empty\n\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  var reducerKeys = Object.keys(reducers);\n  var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n  if (reducerKeys.length === 0) {\n    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n  }\n\n  if (!isPlainObject(inputState)) {\n    return \"The \" + argumentName + \" has unexpected type of \\\"\" + kindOf(inputState) + \"\\\". Expected argument to be an object with the following \" + (\"keys: \\\"\" + reducerKeys.join('\", \"') + \"\\\"\");\n  }\n\n  var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n  });\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\n  if (action && action.type === ActionTypes.REPLACE) return;\n\n  if (unexpectedKeys.length > 0) {\n    return \"Unexpected \" + (unexpectedKeys.length > 1 ? 'keys' : 'key') + \" \" + (\"\\\"\" + unexpectedKeys.join('\", \"') + \"\\\" found in \" + argumentName + \". \") + \"Expected to find one of the known reducer keys instead: \" + (\"\\\"\" + reducerKeys.join('\", \"') + \"\\\". Unexpected keys will be ignored.\");\n  }\n}\n\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach(function (key) {\n    var reducer = reducers[key];\n    var initialState = reducer(undefined, {\n      type: ActionTypes.INIT\n    });\n\n    if (typeof initialState === 'undefined') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(12) : \"The slice reducer for key \\\"\" + key + \"\\\" returned undefined during initialization. \" + \"If the state passed to the reducer is undefined, you must \" + \"explicitly return the initial state. The initial state may \" + \"not be undefined. If you don't want to set a value for this reducer, \" + \"you can use null instead of undefined.\");\n    }\n\n    if (typeof reducer(undefined, {\n      type: ActionTypes.PROBE_UNKNOWN_ACTION()\n    }) === 'undefined') {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(13) : \"The slice reducer for key \\\"\" + key + \"\\\" returned undefined when probed with a random type. \" + (\"Don't try to handle '\" + ActionTypes.INIT + \"' or other actions in \\\"redux/*\\\" \") + \"namespace. They are considered private. Instead, you must return the \" + \"current state for any unknown actions, unless it is undefined, \" + \"in which case you must return the initial state, regardless of the \" + \"action type. The initial state may not be undefined, but can be null.\");\n    }\n  });\n}\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\n\n\nfunction combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\n\n  for (var i = 0; i < reducerKeys.length; i++) {\n    var key = reducerKeys[i];\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof reducers[key] === 'undefined') {\n        warning(\"No reducer provided for key \\\"\" + key + \"\\\"\");\n      }\n    }\n\n    if (typeof reducers[key] === 'function') {\n      finalReducers[key] = reducers[key];\n    }\n  }\n\n  var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same\n  // keys multiple times.\n\n  var unexpectedKeyCache;\n\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError;\n\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination(state, action) {\n    if (state === void 0) {\n      state = {};\n    }\n\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\n\n    for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n      var _key = finalReducerKeys[_i];\n      var reducer = finalReducers[_key];\n      var previousStateForKey = state[_key];\n      var nextStateForKey = reducer(previousStateForKey, action);\n\n      if (typeof nextStateForKey === 'undefined') {\n        var actionType = action && action.type;\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(14) : \"When called with an action of type \" + (actionType ? \"\\\"\" + String(actionType) + \"\\\"\" : '(unknown type)') + \", the slice reducer for key \\\"\" + _key + \"\\\" returned undefined. \" + \"To ignore an action, you must explicitly return the previous state. \" + \"If you want this reducer to hold no value, you can return null instead of undefined.\");\n      }\n\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n\n    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;\n    return hasChanged ? nextState : state;\n  };\n}\n\nfunction bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(this, arguments));\n  };\n}\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass an action creator as the first argument,\n * and get a dispatch wrapped function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\n\n\nfunction bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === 'function') {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n\n  if (typeof actionCreators !== 'object' || actionCreators === null) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(16) : \"bindActionCreators expected an object or a function, but instead received: '\" + kindOf(actionCreators) + \"'. \" + \"Did you write \\\"import ActionCreators from\\\" instead of \\\"import * as ActionCreators from\\\"?\");\n  }\n\n  var boundActionCreators = {};\n\n  for (var key in actionCreators) {\n    var actionCreator = actionCreators[key];\n\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n\n  return boundActionCreators;\n}\n\n/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\nfunction compose() {\n  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {\n    funcs[_key] = arguments[_key];\n  }\n\n  if (funcs.length === 0) {\n    return function (arg) {\n      return arg;\n    };\n  }\n\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n\n  return funcs.reduce(function (a, b) {\n    return function () {\n      return a(b.apply(void 0, arguments));\n    };\n  });\n}\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\n\nfunction applyMiddleware() {\n  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function () {\n      var store = createStore.apply(void 0, arguments);\n\n      var _dispatch = function dispatch() {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(15) : 'Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.');\n      };\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch() {\n          return _dispatch.apply(void 0, arguments);\n        }\n      };\n      var chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(void 0, chain)(store.dispatch);\n      return _objectSpread(_objectSpread({}, store), {}, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}\n\nexport { ActionTypes as __DO_NOT_USE__ActionTypes, applyMiddleware, bindActionCreators, combineReducers, compose, createStore, legacy_createStore };\n","// cheap lodash replacements\n/**\n * drop-in replacement for _.get\n * @param obj\n * @param path\n * @param defaultValue\n */ export function get(obj, path, defaultValue) {\n    return path.split('.').reduce((a, c)=>a && a[c] ? a[c] : defaultValue || null\n    , obj);\n}\n/**\n * drop-in replacement for _.without\n */ export function without(items, item) {\n    return items.filter((i)=>i !== item\n    );\n}\n/**\n * drop-in replacement for _.isString\n * @param input\n */ export function isString(input) {\n    return typeof input === 'string';\n}\n/**\n * drop-in replacement for _.isString\n * @param input\n */ export function isObject(input) {\n    return typeof input === 'object';\n}\n/**\n * replacement for _.xor\n * @param itemsA\n * @param itemsB\n */ export function xor(itemsA, itemsB) {\n    const map = new Map();\n    const insertItem = (item)=>{\n        map.set(item, map.has(item) ? map.get(item) + 1 : 1);\n    };\n    itemsA.forEach(insertItem);\n    itemsB.forEach(insertItem);\n    const result = [];\n    map.forEach((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 */ export function intersection(itemsA, itemsB) {\n    return itemsA.filter((t)=>itemsB.indexOf(t) > -1\n    );\n}\n\n//# sourceMappingURL=js_utils.js.map","export const INIT_COORDS = 'dnd-core/INIT_COORDS';\nexport const BEGIN_DRAG = 'dnd-core/BEGIN_DRAG';\nexport const PUBLISH_DRAG_SOURCE = 'dnd-core/PUBLISH_DRAG_SOURCE';\nexport const HOVER = 'dnd-core/HOVER';\nexport const DROP = 'dnd-core/DROP';\nexport const END_DRAG = 'dnd-core/END_DRAG';\n\n//# sourceMappingURL=types.js.map","import { INIT_COORDS } from '../types.js';\nexport function setClientOffset(clientOffset, sourceClientOffset) {\n    return {\n        type: INIT_COORDS,\n        payload: {\n            sourceClientOffset: sourceClientOffset || null,\n            clientOffset: clientOffset || null\n        }\n    };\n}\n\n//# sourceMappingURL=setClientOffset.js.map","import { invariant } from '@react-dnd/invariant';\nimport { isObject } from '../../utils/js_utils.js';\nimport { setClientOffset } from './local/setClientOffset.js';\nimport { BEGIN_DRAG, INIT_COORDS } from './types.js';\nconst ResetCoordinatesAction = {\n    type: INIT_COORDS,\n    payload: {\n        clientOffset: null,\n        sourceClientOffset: null\n    }\n};\nexport function createBeginDrag(manager) {\n    return function beginDrag(sourceIds = [], options = {\n        publishSource: true\n    }) {\n        const { publishSource =true , clientOffset , getSourceClientOffset ,  } = options;\n        const monitor = manager.getMonitor();\n        const registry = manager.getRegistry();\n        // Initialize the coordinates using the client offset\n        manager.dispatch(setClientOffset(clientOffset));\n        verifyInvariants(sourceIds, monitor, registry);\n        // Get the draggable source\n        const sourceId = getDraggableSource(sourceIds, monitor);\n        if (sourceId == null) {\n            manager.dispatch(ResetCoordinatesAction);\n            return;\n        }\n        // Get the source client offset\n        let sourceClientOffset = null;\n        if (clientOffset) {\n            if (!getSourceClientOffset) {\n                throw new Error('getSourceClientOffset must be defined');\n            }\n            verifyGetSourceClientOffsetIsFunction(getSourceClientOffset);\n            sourceClientOffset = getSourceClientOffset(sourceId);\n        }\n        // Initialize the full coordinates\n        manager.dispatch(setClientOffset(clientOffset, sourceClientOffset));\n        const source = registry.getSource(sourceId);\n        const item = source.beginDrag(monitor, sourceId);\n        // If source.beginDrag returns null, this is an indicator to cancel the drag\n        if (item == null) {\n            return undefined;\n        }\n        verifyItemIsObject(item);\n        registry.pinSource(sourceId);\n        const itemType = registry.getSourceType(sourceId);\n        return {\n            type: BEGIN_DRAG,\n            payload: {\n                itemType,\n                item,\n                sourceId,\n                clientOffset: clientOffset || null,\n                sourceClientOffset: sourceClientOffset || null,\n                isSourcePublic: !!publishSource\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}\nfunction verifyGetSourceClientOffsetIsFunction(getSourceClientOffset) {\n    invariant(typeof getSourceClientOffset === 'function', 'When clientOffset is provided, getSourceClientOffset must be a function.');\n}\nfunction verifyItemIsObject(item) {\n    invariant(isObject(item), 'Item must be an object.');\n}\nfunction getDraggableSource(sourceIds, monitor) {\n    let sourceId = null;\n    for(let i = sourceIds.length - 1; i >= 0; i--){\n        if (monitor.canDragSource(sourceIds[i])) {\n            sourceId = sourceIds[i];\n            break;\n        }\n    }\n    return sourceId;\n}\n\n//# sourceMappingURL=beginDrag.js.map","function _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    return obj;\n}\nfunction _objectSpread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === 'function') {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _defineProperty(target, key, source[key]);\n        });\n    }\n    return target;\n}\nimport { invariant } from '@react-dnd/invariant';\nimport { isObject } from '../../utils/js_utils.js';\nimport { DROP } from './types.js';\nexport function createDrop(manager) {\n    return function drop(options = {}) {\n        const monitor = manager.getMonitor();\n        const registry = manager.getRegistry();\n        verifyInvariants(monitor);\n        const targetIds = getDroppableTargets(monitor);\n        // Multiple actions are dispatched here, which is why this doesn't return an action\n        targetIds.forEach((targetId, index)=>{\n            const dropResult = determineDropResult(targetId, index, registry, monitor);\n            const action = {\n                type: DROP,\n                payload: {\n                    dropResult: _objectSpread({}, options, dropResult)\n                }\n            };\n            manager.dispatch(action);\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}\nfunction determineDropResult(targetId, index, registry, monitor) {\n    const target = registry.getTarget(targetId);\n    let dropResult = target ? target.drop(monitor, targetId) : undefined;\n    verifyDropResultType(dropResult);\n    if (typeof dropResult === 'undefined') {\n        dropResult = index === 0 ? {} : monitor.getDropResult();\n    }\n    return dropResult;\n}\nfunction verifyDropResultType(dropResult) {\n    invariant(typeof dropResult === 'undefined' || isObject(dropResult), 'Drop result must either be an object or undefined.');\n}\nfunction getDroppableTargets(monitor) {\n    const targetIds = monitor.getTargetIds().filter(monitor.canDropOnTarget, monitor);\n    targetIds.reverse();\n    return targetIds;\n}\n\n//# sourceMappingURL=drop.js.map","import { invariant } from '@react-dnd/invariant';\nimport { END_DRAG } from './types.js';\nexport function createEndDrag(manager) {\n    return function endDrag() {\n        const monitor = manager.getMonitor();\n        const registry = manager.getRegistry();\n        verifyIsDragging(monitor);\n        const sourceId = monitor.getSourceId();\n        if (sourceId != null) {\n            const source = registry.getSource(sourceId, true);\n            source.endDrag(monitor, sourceId);\n            registry.unpinSource();\n        }\n        return {\n            type: END_DRAG\n        };\n    };\n}\nfunction verifyIsDragging(monitor) {\n    invariant(monitor.isDragging(), 'Cannot call endDrag while not dragging.');\n}\n\n//# sourceMappingURL=endDrag.js.map","export function matchesType(targetType, draggedItemType) {\n    if (draggedItemType === null) {\n        return targetType === null;\n    }\n    return Array.isArray(targetType) ? targetType.some((t)=>t === draggedItemType\n    ) : targetType === draggedItemType;\n}\n\n//# sourceMappingURL=matchesType.js.map","import { invariant } from '@react-dnd/invariant';\nimport { matchesType } from '../../utils/matchesType.js';\nimport { HOVER } from './types.js';\nexport function createHover(manager) {\n    return function hover(targetIdsArg, { clientOffset  } = {}) {\n        verifyTargetIdsIsArray(targetIdsArg);\n        const targetIds = targetIdsArg.slice(0);\n        const monitor = manager.getMonitor();\n        const registry = manager.getRegistry();\n        const draggedItemType = monitor.getItemType();\n        removeNonMatchingTargetIds(targetIds, registry, draggedItemType);\n        checkInvariants(targetIds, monitor, registry);\n        hoverAllTargets(targetIds, monitor, registry);\n        return {\n            type: HOVER,\n            payload: {\n                targetIds,\n                clientOffset: clientOffset || null\n            }\n        };\n    };\n}\nfunction verifyTargetIdsIsArray(targetIdsArg) {\n    invariant(Array.isArray(targetIdsArg), 'Expected targetIds to be an array.');\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    for(let i = 0; i < targetIds.length; i++){\n        const targetId = targetIds[i];\n        invariant(targetIds.lastIndexOf(targetId) === i, 'Expected targetIds to be unique in the passed array.');\n        const target = registry.getTarget(targetId);\n        invariant(target, 'Expected targetIds to be registered.');\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(let i = targetIds.length - 1; i >= 0; i--){\n        const targetId = targetIds[i];\n        const targetType = registry.getTargetType(targetId);\n        if (!matchesType(targetType, draggedItemType)) {\n            targetIds.splice(i, 1);\n        }\n    }\n}\nfunction hoverAllTargets(targetIds, monitor, registry) {\n    // Finally call hover on all matching targets.\n    targetIds.forEach(function(targetId) {\n        const target = registry.getTarget(targetId);\n        target.hover(monitor, targetId);\n    });\n}\n\n//# sourceMappingURL=hover.js.map","import { PUBLISH_DRAG_SOURCE } from './types.js';\nexport function createPublishDragSource(manager) {\n    return function publishDragSource() {\n        const monitor = manager.getMonitor();\n        if (monitor.isDragging()) {\n            return {\n                type: PUBLISH_DRAG_SOURCE\n            };\n        }\n        return;\n    };\n}\n\n//# sourceMappingURL=publishDragSource.js.map","import { createBeginDrag } from './beginDrag.js';\nimport { createDrop } from './drop.js';\nimport { createEndDrag } from './endDrag.js';\nimport { createHover } from './hover.js';\nimport { createPublishDragSource } from './publishDragSource.js';\nexport * from './types.js';\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}\n\n//# sourceMappingURL=index.js.map","import { createDragDropActions } from '../actions/dragDrop/index.js';\nexport class DragDropManagerImpl {\n    receiveBackend(backend) {\n        this.backend = backend;\n    }\n    getMonitor() {\n        return this.monitor;\n    }\n    getBackend() {\n        return this.backend;\n    }\n    getRegistry() {\n        return this.monitor.registry;\n    }\n    getActions() {\n        /* eslint-disable-next-line @typescript-eslint/no-this-alias */ const manager = this;\n        const { dispatch  } = this.store;\n        function bindActionCreator(actionCreator) {\n            return (...args)=>{\n                const action = actionCreator.apply(manager, args);\n                if (typeof action !== 'undefined') {\n                    dispatch(action);\n                }\n            };\n        }\n        const actions = createDragDropActions(this);\n        return Object.keys(actions).reduce((boundActions, key)=>{\n            const action = actions[key];\n            boundActions[key] = bindActionCreator(action);\n            return boundActions;\n        }, {});\n    }\n    dispatch(action) {\n        this.store.dispatch(action);\n    }\n    constructor(store, monitor){\n        this.isSetUp = false;\n        this.handleRefCountChange = ()=>{\n            const shouldSetUp = this.store.getState().refCount > 0;\n            if (this.backend) {\n                if (shouldSetUp && !this.isSetUp) {\n                    this.backend.setup();\n                    this.isSetUp = true;\n                } else if (!shouldSetUp && this.isSetUp) {\n                    this.backend.teardown();\n                    this.isSetUp = false;\n                }\n            }\n        };\n        this.store = store;\n        this.monitor = monitor;\n        store.subscribe(this.handleRefCountChange);\n    }\n}\n\n//# sourceMappingURL=DragDropManagerImpl.js.map","/**\n * Coordinate addition\n * @param a The first coordinate\n * @param b The second coordinate\n */ export 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 */ export 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 */ export function getSourceClientOffset(state) {\n    const { clientOffset , initialClientOffset , initialSourceClientOffset  } = state;\n    if (!clientOffset || !initialClientOffset || !initialSourceClientOffset) {\n        return null;\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 */ export function getDifferenceFromInitialOffset(state) {\n    const { clientOffset , initialClientOffset  } = state;\n    if (!clientOffset || !initialClientOffset) {\n        return null;\n    }\n    return subtract(clientOffset, initialClientOffset);\n}\n\n//# sourceMappingURL=coords.js.map","import { intersection } from './js_utils.js';\nexport const NONE = [];\nexport const 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 */ export function areDirty(dirtyIds, handlerIds) {\n    if (dirtyIds === NONE) {\n        return false;\n    }\n    if (dirtyIds === ALL || typeof handlerIds === 'undefined') {\n        return true;\n    }\n    const commonIds = intersection(handlerIds, dirtyIds);\n    return commonIds.length > 0;\n}\n\n//# sourceMappingURL=dirtiness.js.map","import { invariant } from '@react-dnd/invariant';\nimport { getDifferenceFromInitialOffset, getSourceClientOffset } from '../utils/coords.js';\nimport { areDirty } from '../utils/dirtiness.js';\nimport { matchesType } from '../utils/matchesType.js';\nexport class DragDropMonitorImpl {\n    subscribeToStateChange(listener, options = {}) {\n        const { handlerIds  } = options;\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        let prevStateId = this.store.getState().stateId;\n        const handleChange = ()=>{\n            const state = this.store.getState();\n            const currentStateId = state.stateId;\n            try {\n                const canSkipListener = currentStateId === prevStateId || currentStateId === prevStateId + 1 && !areDirty(state.dirtyHandlerIds, handlerIds);\n                if (!canSkipListener) {\n                    listener();\n                }\n            } finally{\n                prevStateId = currentStateId;\n            }\n        };\n        return this.store.subscribe(handleChange);\n    }\n    subscribeToOffsetChange(listener) {\n        invariant(typeof listener === 'function', 'listener must be a function.');\n        let previousState = this.store.getState().dragOffset;\n        const handleChange = ()=>{\n            const nextState = this.store.getState().dragOffset;\n            if (nextState === previousState) {\n                return;\n            }\n            previousState = nextState;\n            listener();\n        };\n        return this.store.subscribe(handleChange);\n    }\n    canDragSource(sourceId) {\n        if (!sourceId) {\n            return false;\n        }\n        const source = this.registry.getSource(sourceId);\n        invariant(source, `Expected to find a valid source. sourceId=${sourceId}`);\n        if (this.isDragging()) {\n            return false;\n        }\n        return source.canDrag(this, sourceId);\n    }\n    canDropOnTarget(targetId) {\n        // undefined on initial render\n        if (!targetId) {\n            return false;\n        }\n        const target = this.registry.getTarget(targetId);\n        invariant(target, `Expected to find a valid target. targetId=${targetId}`);\n        if (!this.isDragging() || this.didDrop()) {\n            return false;\n        }\n        const targetType = this.registry.getTargetType(targetId);\n        const draggedItemType = this.getItemType();\n        return matchesType(targetType, draggedItemType) && target.canDrop(this, targetId);\n    }\n    isDragging() {\n        return Boolean(this.getItemType());\n    }\n    isDraggingSource(sourceId) {\n        // undefined on initial render\n        if (!sourceId) {\n            return false;\n        }\n        const source = this.registry.getSource(sourceId, true);\n        invariant(source, `Expected to find a valid source. sourceId=${sourceId}`);\n        if (!this.isDragging() || !this.isSourcePublic()) {\n            return false;\n        }\n        const sourceType = this.registry.getSourceType(sourceId);\n        const draggedItemType = this.getItemType();\n        if (sourceType !== draggedItemType) {\n            return false;\n        }\n        return source.isDragging(this, sourceId);\n    }\n    isOverTarget(targetId, options = {\n        shallow: false\n    }) {\n        // undefined on initial render\n        if (!targetId) {\n            return false;\n        }\n        const { shallow  } = options;\n        if (!this.isDragging()) {\n            return false;\n        }\n        const targetType = this.registry.getTargetType(targetId);\n        const draggedItemType = this.getItemType();\n        if (draggedItemType && !matchesType(targetType, draggedItemType)) {\n            return false;\n        }\n        const targetIds = this.getTargetIds();\n        if (!targetIds.length) {\n            return false;\n        }\n        const index = targetIds.indexOf(targetId);\n        if (shallow) {\n            return index === targetIds.length - 1;\n        } else {\n            return index > -1;\n        }\n    }\n    getItemType() {\n        return this.store.getState().dragOperation.itemType;\n    }\n    getItem() {\n        return this.store.getState().dragOperation.item;\n    }\n    getSourceId() {\n        return this.store.getState().dragOperation.sourceId;\n    }\n    getTargetIds() {\n        return this.store.getState().dragOperation.targetIds;\n    }\n    getDropResult() {\n        return this.store.getState().dragOperation.dropResult;\n    }\n    didDrop() {\n        return this.store.getState().dragOperation.didDrop;\n    }\n    isSourcePublic() {\n        return Boolean(this.store.getState().dragOperation.isSourcePublic);\n    }\n    getInitialClientOffset() {\n        return this.store.getState().dragOffset.initialClientOffset;\n    }\n    getInitialSourceClientOffset() {\n        return this.store.getState().dragOffset.initialSourceClientOffset;\n    }\n    getClientOffset() {\n        return this.store.getState().dragOffset.clientOffset;\n    }\n    getSourceClientOffset() {\n        return getSourceClientOffset(this.store.getState().dragOffset);\n    }\n    getDifferenceFromInitialOffset() {\n        return getDifferenceFromInitialOffset(this.store.getState().dragOffset);\n    }\n    constructor(store, registry){\n        this.store = store;\n        this.registry = registry;\n    }\n}\n\n//# sourceMappingURL=DragDropMonitorImpl.js.map","export const ADD_SOURCE = 'dnd-core/ADD_SOURCE';\nexport const ADD_TARGET = 'dnd-core/ADD_TARGET';\nexport const REMOVE_SOURCE = 'dnd-core/REMOVE_SOURCE';\nexport const REMOVE_TARGET = 'dnd-core/REMOVE_TARGET';\nexport function addSource(sourceId) {\n    return {\n        type: ADD_SOURCE,\n        payload: {\n            sourceId\n        }\n    };\n}\nexport function addTarget(targetId) {\n    return {\n        type: ADD_TARGET,\n        payload: {\n            targetId\n        }\n    };\n}\nexport function removeSource(sourceId) {\n    return {\n        type: REMOVE_SOURCE,\n        payload: {\n            sourceId\n        }\n    };\n}\nexport function removeTarget(targetId) {\n    return {\n        type: REMOVE_TARGET,\n        payload: {\n            targetId\n        }\n    };\n}\n\n//# sourceMappingURL=registry.js.map","import { 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((t)=>validateType(t, false)\n        );\n        return;\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}\n\n//# sourceMappingURL=contracts.js.map","export var HandlerRole;\n(function(HandlerRole) {\n    HandlerRole[\"SOURCE\"] = \"SOURCE\";\n    HandlerRole[\"TARGET\"] = \"TARGET\";\n})(HandlerRole || (HandlerRole = {}));\n\n//# sourceMappingURL=interfaces.js.map","let nextUniqueId = 0;\nexport function getNextUniqueId() {\n    return nextUniqueId++;\n}\n\n//# sourceMappingURL=getNextUniqueId.js.map","import { asap } from '@react-dnd/asap';\nimport { invariant } from '@react-dnd/invariant';\nimport { addSource, addTarget, removeSource, removeTarget } from '../actions/registry.js';\nimport { validateSourceContract, validateTargetContract, validateType } from '../contracts.js';\nimport { HandlerRole } from '../interfaces.js';\nimport { getNextUniqueId } from '../utils/getNextUniqueId.js';\nfunction getNextHandlerId(role) {\n    const id = getNextUniqueId().toString();\n    switch(role){\n        case HandlerRole.SOURCE:\n            return `S${id}`;\n        case HandlerRole.TARGET:\n            return `T${id}`;\n        default:\n            throw new Error(`Unknown Handler Role: ${role}`);\n    }\n}\nfunction parseRoleFromHandlerId(handlerId) {\n    switch(handlerId[0]){\n        case 'S':\n            return HandlerRole.SOURCE;\n        case 'T':\n            return HandlerRole.TARGET;\n        default:\n            throw new Error(`Cannot parse handler ID: ${handlerId}`);\n    }\n}\nfunction mapContainsValue(map, searchValue) {\n    const entries = map.entries();\n    let isDone = false;\n    do {\n        const { done , value: [, value] ,  } = entries.next();\n        if (value === searchValue) {\n            return true;\n        }\n        isDone = !!done;\n    }while (!isDone)\n    return false;\n}\nexport class HandlerRegistryImpl {\n    addSource(type, source) {\n        validateType(type);\n        validateSourceContract(source);\n        const sourceId = this.addHandler(HandlerRole.SOURCE, type, source);\n        this.store.dispatch(addSource(sourceId));\n        return sourceId;\n    }\n    addTarget(type, target) {\n        validateType(type, true);\n        validateTargetContract(target);\n        const targetId = this.addHandler(HandlerRole.TARGET, type, target);\n        this.store.dispatch(addTarget(targetId));\n        return targetId;\n    }\n    containsHandler(handler) {\n        return mapContainsValue(this.dragSources, handler) || mapContainsValue(this.dropTargets, handler);\n    }\n    getSource(sourceId, includePinned = false) {\n        invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');\n        const isPinned = includePinned && sourceId === this.pinnedSourceId;\n        const source = isPinned ? this.pinnedSource : this.dragSources.get(sourceId);\n        return source;\n    }\n    getTarget(targetId) {\n        invariant(this.isTargetId(targetId), 'Expected a valid target ID.');\n        return this.dropTargets.get(targetId);\n    }\n    getSourceType(sourceId) {\n        invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');\n        return this.types.get(sourceId);\n    }\n    getTargetType(targetId) {\n        invariant(this.isTargetId(targetId), 'Expected a valid target ID.');\n        return this.types.get(targetId);\n    }\n    isSourceId(handlerId) {\n        const role = parseRoleFromHandlerId(handlerId);\n        return role === HandlerRole.SOURCE;\n    }\n    isTargetId(handlerId) {\n        const role = parseRoleFromHandlerId(handlerId);\n        return role === HandlerRole.TARGET;\n    }\n    removeSource(sourceId) {\n        invariant(this.getSource(sourceId), 'Expected an existing source.');\n        this.store.dispatch(removeSource(sourceId));\n        asap(()=>{\n            this.dragSources.delete(sourceId);\n            this.types.delete(sourceId);\n        });\n    }\n    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    pinSource(sourceId) {\n        const source = this.getSource(sourceId);\n        invariant(source, 'Expected an existing source.');\n        this.pinnedSourceId = sourceId;\n        this.pinnedSource = source;\n    }\n    unpinSource() {\n        invariant(this.pinnedSource, 'No source is pinned at the time.');\n        this.pinnedSourceId = null;\n        this.pinnedSource = null;\n    }\n    addHandler(role, type, handler) {\n        const id = getNextHandlerId(role);\n        this.types.set(id, type);\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        return id;\n    }\n    constructor(store){\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\n//# sourceMappingURL=HandlerRegistryImpl.js.map","export const strictEquality = (a, b)=>a === b\n;\n/**\n * Determine if two cartesian coordinate offsets are equal\n * @param offsetA\n * @param offsetB\n */ export 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 */ export function areArraysEqual(a, b, isEqual = strictEquality) {\n    if (a.length !== b.length) {\n        return false;\n    }\n    for(let i = 0; i < a.length; ++i){\n        if (!isEqual(a[i], b[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n\n//# sourceMappingURL=equality.js.map","import { BEGIN_DRAG, DROP, END_DRAG, HOVER, PUBLISH_DRAG_SOURCE } from '../actions/dragDrop/index.js';\nimport { ADD_SOURCE, ADD_TARGET, REMOVE_SOURCE, REMOVE_TARGET } from '../actions/registry.js';\nimport { ALL, NONE } from '../utils/dirtiness.js';\nimport { areArraysEqual } from '../utils/equality.js';\nimport { xor } from '../utils/js_utils.js';\nexport function reduce(// eslint-disable-next-line @typescript-eslint/no-unused-vars\n_state = NONE, action) {\n    switch(action.type){\n        case HOVER:\n            break;\n        case ADD_SOURCE:\n        case ADD_TARGET:\n        case REMOVE_TARGET:\n        case REMOVE_SOURCE:\n            return NONE;\n        case BEGIN_DRAG:\n        case PUBLISH_DRAG_SOURCE:\n        case END_DRAG:\n        case DROP:\n        default:\n            return ALL;\n    }\n    const { targetIds =[] , prevTargetIds =[]  } = action.payload;\n    const result = xor(targetIds, prevTargetIds);\n    const didChange = result.length > 0 || !areArraysEqual(targetIds, prevTargetIds);\n    if (!didChange) {\n        return NONE;\n    }\n    // Check the target ids at the innermost position. If they are valid, add them\n    // to the result\n    const prevInnermostTargetId = prevTargetIds[prevTargetIds.length - 1];\n    const innermostTargetId = targetIds[targetIds.length - 1];\n    if (prevInnermostTargetId !== innermostTargetId) {\n        if (prevInnermostTargetId) {\n            result.push(prevInnermostTargetId);\n        }\n        if (innermostTargetId) {\n            result.push(innermostTargetId);\n        }\n    }\n    return result;\n}\n\n//# sourceMappingURL=dirtyHandlerIds.js.map","function _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    return obj;\n}\nfunction _objectSpread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === 'function') {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _defineProperty(target, key, source[key]);\n        });\n    }\n    return target;\n}\nimport { BEGIN_DRAG, DROP, END_DRAG, HOVER, INIT_COORDS } from '../actions/dragDrop/index.js';\nimport { areCoordsEqual } from '../utils/equality.js';\nconst initialState = {\n    initialSourceClientOffset: null,\n    initialClientOffset: null,\n    clientOffset: null\n};\nexport function reduce(state = initialState, action) {\n    const { payload  } = action;\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        case HOVER:\n            if (areCoordsEqual(state.clientOffset, payload.clientOffset)) {\n                return state;\n            }\n            return _objectSpread({}, state, {\n                clientOffset: payload.clientOffset\n            });\n        case END_DRAG:\n        case DROP:\n            return initialState;\n        default:\n            return state;\n    }\n}\n\n//# sourceMappingURL=dragOffset.js.map","function _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    return obj;\n}\nfunction _objectSpread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === 'function') {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _defineProperty(target, key, source[key]);\n        });\n    }\n    return target;\n}\nimport { BEGIN_DRAG, DROP, END_DRAG, HOVER, PUBLISH_DRAG_SOURCE } from '../actions/dragDrop/index.js';\nimport { REMOVE_TARGET } from '../actions/registry.js';\nimport { without } from '../utils/js_utils.js';\nconst 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(state = initialState, action) {\n    const { payload  } = action;\n    switch(action.type){\n        case BEGIN_DRAG:\n            return _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        case PUBLISH_DRAG_SOURCE:\n            return _objectSpread({}, state, {\n                isSourcePublic: true\n            });\n        case HOVER:\n            return _objectSpread({}, state, {\n                targetIds: payload.targetIds\n            });\n        case REMOVE_TARGET:\n            if (state.targetIds.indexOf(payload.targetId) === -1) {\n                return state;\n            }\n            return _objectSpread({}, state, {\n                targetIds: without(state.targetIds, payload.targetId)\n            });\n        case DROP:\n            return _objectSpread({}, state, {\n                dropResult: payload.dropResult,\n                didDrop: true,\n                targetIds: []\n            });\n        case END_DRAG:\n            return _objectSpread({}, state, {\n                itemType: null,\n                item: null,\n                sourceId: null,\n                dropResult: null,\n                didDrop: false,\n                isSourcePublic: null,\n                targetIds: []\n            });\n        default:\n            return state;\n    }\n}\n\n//# sourceMappingURL=dragOperation.js.map","import { ADD_SOURCE, ADD_TARGET, REMOVE_SOURCE, REMOVE_TARGET } from '../actions/registry.js';\nexport function reduce(state = 0, action) {\n    switch(action.type){\n        case ADD_SOURCE:\n        case ADD_TARGET:\n            return state + 1;\n        case REMOVE_SOURCE:\n        case REMOVE_TARGET:\n            return state - 1;\n        default:\n            return state;\n    }\n}\n\n//# sourceMappingURL=refCount.js.map","export function reduce(state = 0) {\n    return state + 1;\n}\n\n//# sourceMappingURL=stateId.js.map","function _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    return obj;\n}\nfunction _objectSpread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === 'function') {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _defineProperty(target, key, source[key]);\n        });\n    }\n    return target;\n}\nimport { get } from '../utils/js_utils.js';\nimport { reduce as dirtyHandlerIds } from './dirtyHandlerIds.js';\nimport { reduce as dragOffset } from './dragOffset.js';\nimport { reduce as dragOperation } from './dragOperation.js';\nimport { reduce as refCount } from './refCount.js';\nimport { reduce as stateId } from './stateId.js';\nexport function reduce(state = {}, action) {\n    return {\n        dirtyHandlerIds: dirtyHandlerIds(state.dirtyHandlerIds, {\n            type: action.type,\n            payload: _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}\n\n//# sourceMappingURL=index.js.map","import { createStore } from 'redux';\nimport { DragDropManagerImpl } from './classes/DragDropManagerImpl.js';\nimport { DragDropMonitorImpl } from './classes/DragDropMonitorImpl.js';\nimport { HandlerRegistryImpl } from './classes/HandlerRegistryImpl.js';\nimport { reduce } from './reducers/index.js';\nexport function createDragDropManager(backendFactory, globalContext = undefined, backendOptions = {}, debugMode = false) {\n    const store = makeStoreInstance(debugMode);\n    const monitor = new DragDropMonitorImpl(store, new HandlerRegistryImpl(store));\n    const manager = new DragDropManagerImpl(store, monitor);\n    const backend = backendFactory(manager, globalContext, backendOptions);\n    manager.receiveBackend(backend);\n    return manager;\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    const 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\n//# sourceMappingURL=createDragDropManager.js.map"],"names":["formatProdErrorMessage","code","$$observable","randomString","ActionTypes","isPlainObject","obj","proto","createStore","reducer","preloadedState","enhancer","_ref2","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","getState","subscribe","listener","isSubscribed","index","dispatch","action","listeners","i","replaceReducer","nextReducer","observable","_ref","outerSubscribe","observer","observeState","unsubscribe","get","path","defaultValue","a","c","without","items","item","isObject","input","xor","itemsA","itemsB","map","insertItem","result","count","key","intersection","t","INIT_COORDS","BEGIN_DRAG","PUBLISH_DRAG_SOURCE","HOVER","DROP","END_DRAG","setClientOffset","clientOffset","sourceClientOffset","ResetCoordinatesAction","createBeginDrag","manager","sourceIds","options","publishSource","getSourceClientOffset","monitor","registry","verifyInvariants","sourceId","getDraggableSource","verifyGetSourceClientOffsetIsFunction","verifyItemIsObject","itemType","invariant","_defineProperty","value","_objectSpread","target","source","ownKeys","sym","createDrop","getDroppableTargets","targetId","dropResult","determineDropResult","verifyDropResultType","targetIds","createEndDrag","verifyIsDragging","matchesType","targetType","draggedItemType","createHover","targetIdsArg","verifyTargetIdsIsArray","removeNonMatchingTargetIds","checkInvariants","hoverAllTargets","createPublishDragSource","createDragDropActions","DragDropManagerImpl","backend","bindActionCreator","actionCreator","args","actions","boundActions","store","shouldSetUp","add","b","subtract","state","initialClientOffset","initialSourceClientOffset","getDifferenceFromInitialOffset","NONE","ALL","areDirty","dirtyIds","handlerIds","DragDropMonitorImpl","prevStateId","handleChange","currentStateId","previousState","nextState","sourceType","shallow","ADD_SOURCE","ADD_TARGET","REMOVE_SOURCE","REMOVE_TARGET","addSource","addTarget","removeSource","removeTarget","validateSourceContract","validateTargetContract","validateType","type","allowArray","HandlerRole","nextUniqueId","getNextUniqueId","getNextHandlerId","role","id","parseRoleFromHandlerId","handlerId","mapContainsValue","searchValue","entries","isDone","done","HandlerRegistryImpl","handler","includePinned","asap","strictEquality","areCoordsEqual","offsetA","offsetB","areArraysEqual","isEqual","reduce","_state","prevTargetIds","prevInnermostTargetId","innermostTargetId","initialState","payload","dirtyHandlerIds","dragOffset","refCount","dragOperation","stateId","createDragDropManager","backendFactory","globalContext","backendOptions","debugMode","makeStoreInstance","reduxDevTools"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27]}