{"version":3,"file":"static/js/vendor.async.non-landing~c30f4496.5064204e.chunk.js","mappings":"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","sources":["../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/types.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/local/setClientOffset.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/js_utils.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/beginDrag.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/publishDragSource.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/matchesType.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/hover.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/drop.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/endDrag.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/classes/DragDropManagerImpl.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/dragDrop/index.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/equality.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/dragOffset.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/actions/registry.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/dragOperation.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/refCount.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/dirtiness.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/dirtyHandlerIds.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/stateId.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/reducers/index.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/coords.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/classes/DragDropMonitorImpl.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/interfaces.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/utils/getNextUniqueId.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/contracts.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/classes/HandlerRegistryImpl.js","../../../../node_modules/.pnpm/dnd-core@14.0.1/node_modules/dnd-core/dist/esm/createDragDropManager.js","../../../../node_modules/.pnpm/http-status-codes@2.3.0/node_modules/http-status-codes/build/es/status-codes.js","../../src/file-pointer/file-pointer-blob.ts","../../../util/src/reporting-context.ts","../../../util/src/guards.ts","../../../../node_modules/uuid/dist/esm-browser/stringify.js","../../../../node_modules/uuid/dist/esm-browser/rng.js","../../../../node_modules/uuid/dist/esm-browser/native.js","../../../../node_modules/uuid/dist/esm-browser/v4.js","../../../util/src/uuid.ts","../../../util/src/error.ts","../../../util/src/assert.ts","../../../util/src/defined.ts","../../../request-client/src/types/request-client-types.ts","../../../request-client/src/client/errors.ts","../../../feature-flags/src/isFeatureEnabled.ts","../../../request-client/src/utils/errors.ts","../../../request-client/src/utils/with-retry.ts","../../../request-client/src/client/request-client.ts","../../../request-client/src/progress-request/progress-request.ts"],"sourcesContent":["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';","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}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n// cheap lodash replacements\n\n/**\n * drop-in replacement for _.get\n * @param obj\n * @param path\n * @param defaultValue\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}","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); // If source.beginDrag returns null, this is an indicator to cancel the drag\n\n    if (item == null) {\n      return undefined;\n    }\n\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) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\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}","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { createDragDropActions } from '../actions/dragDrop';\nexport var DragDropManagerImpl = /*#__PURE__*/function () {\n  function DragDropManagerImpl(store, monitor) {\n    var _this = this;\n\n    _classCallCheck(this, DragDropManagerImpl);\n\n    _defineProperty(this, \"store\", void 0);\n\n    _defineProperty(this, \"monitor\", void 0);\n\n    _defineProperty(this, \"backend\", void 0);\n\n    _defineProperty(this, \"isSetUp\", false);\n\n    _defineProperty(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    this.store = store;\n    this.monitor = monitor;\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}","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) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\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) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\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}","/**\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) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\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    _defineProperty(this, \"store\", void 0);\n\n    _defineProperty(this, \"registry\", void 0);\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. sourceId=\".concat(sourceId));\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. targetId=\".concat(targetId));\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. sourceId=\".concat(sourceId));\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      };\n\n      // undefined on initial render\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) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\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}","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\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    _defineProperty(this, \"types\", new Map());\n\n    _defineProperty(this, \"dragSources\", new Map());\n\n    _defineProperty(this, \"dropTargets\", new Map());\n\n    _defineProperty(this, \"pinnedSourceId\", null);\n\n    _defineProperty(this, \"pinnedSource\", null);\n\n    _defineProperty(this, \"store\", void 0);\n\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}();","import { DragDropManagerImpl } from './classes/DragDropManagerImpl';\nimport { createStore } from 'redux';\nimport { reduce } from './reducers';\nimport { DragDropMonitorImpl } from './classes/DragDropMonitorImpl';\nimport { HandlerRegistryImpl } from './classes/HandlerRegistryImpl';\nexport function createDragDropManager(backendFactory) {\n  var globalContext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;\n  var backendOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var debugMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n  var store = makeStoreInstance(debugMode);\n  var monitor = new DragDropMonitorImpl(store, new HandlerRegistryImpl(store));\n  var manager = new DragDropManagerImpl(store, monitor);\n  var backend = backendFactory(manager, globalContext, backendOptions);\n  manager.receiveBackend(backend);\n  return manager;\n}\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}","// Generated file. Do not edit\nexport var StatusCodes;\n(function (StatusCodes) {\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.1\n     *\n     * This interim response indicates that everything so far is OK and that the client should continue with the request or ignore it if it is already finished.\n     */\n    StatusCodes[StatusCodes[\"CONTINUE\"] = 100] = \"CONTINUE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.2\n     *\n     * This code is sent in response to an Upgrade request header by the client, and indicates the protocol the server is switching too.\n     */\n    StatusCodes[StatusCodes[\"SWITCHING_PROTOCOLS\"] = 101] = \"SWITCHING_PROTOCOLS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.1\n     *\n     * This code indicates that the server has received and is processing the request, but no response is available yet.\n     */\n    StatusCodes[StatusCodes[\"PROCESSING\"] = 102] = \"PROCESSING\";\n    /**\n     * Official Documentation @ https://www.rfc-editor.org/rfc/rfc8297#page-3\n     *\n     * This code indicates to the client that the server is likely to send a final response with the header fields included in the informational response.\n     */\n    StatusCodes[StatusCodes[\"EARLY_HINTS\"] = 103] = \"EARLY_HINTS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.1\n     *\n     * The request has succeeded. The meaning of a success varies depending on the HTTP method:\n     * GET: The resource has been fetched and is transmitted in the message body.\n     * HEAD: The entity headers are in the message body.\n     * POST: The resource describing the result of the action is transmitted in the message body.\n     * TRACE: The message body contains the request message as received by the server\n     */\n    StatusCodes[StatusCodes[\"OK\"] = 200] = \"OK\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.2\n     *\n     * The request has succeeded and a new resource has been created as a result of it. This is typically the response sent after a PUT request.\n     */\n    StatusCodes[StatusCodes[\"CREATED\"] = 201] = \"CREATED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.3\n     *\n     * The request has been received but not yet acted upon. It is non-committal, meaning that there is no way in HTTP to later send an asynchronous response indicating the outcome of processing the request. It is intended for cases where another process or server handles the request, or for batch processing.\n     */\n    StatusCodes[StatusCodes[\"ACCEPTED\"] = 202] = \"ACCEPTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.4\n     *\n     * This response code means returned meta-information set is not exact set as available from the origin server, but collected from a local or a third party copy. Except this condition, 200 OK response should be preferred instead of this response.\n     */\n    StatusCodes[StatusCodes[\"NON_AUTHORITATIVE_INFORMATION\"] = 203] = \"NON_AUTHORITATIVE_INFORMATION\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.5\n     *\n     * There is no content to send for this request, but the headers may be useful. The user-agent may update its cached headers for this resource with the new ones.\n     */\n    StatusCodes[StatusCodes[\"NO_CONTENT\"] = 204] = \"NO_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.6\n     *\n     * This response code is sent after accomplishing request to tell user agent reset document view which sent this request.\n     */\n    StatusCodes[StatusCodes[\"RESET_CONTENT\"] = 205] = \"RESET_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.1\n     *\n     * This response code is used because of range header sent by the client to separate download into multiple streams.\n     */\n    StatusCodes[StatusCodes[\"PARTIAL_CONTENT\"] = 206] = \"PARTIAL_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.2\n     *\n     * A Multi-Status response conveys information about multiple resources in situations where multiple status codes might be appropriate.\n     */\n    StatusCodes[StatusCodes[\"MULTI_STATUS\"] = 207] = \"MULTI_STATUS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.1\n     *\n     * The request has more than one possible responses. User-agent or user should choose one of them. There is no standardized way to choose one of the responses.\n     */\n    StatusCodes[StatusCodes[\"MULTIPLE_CHOICES\"] = 300] = \"MULTIPLE_CHOICES\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.2\n     *\n     * This response code means that URI of requested resource has been changed. Probably, new URI would be given in the response.\n     */\n    StatusCodes[StatusCodes[\"MOVED_PERMANENTLY\"] = 301] = \"MOVED_PERMANENTLY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.3\n     *\n     * This response code means that URI of requested resource has been changed temporarily. New changes in the URI might be made in the future. Therefore, this same URI should be used by the client in future requests.\n     */\n    StatusCodes[StatusCodes[\"MOVED_TEMPORARILY\"] = 302] = \"MOVED_TEMPORARILY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.4\n     *\n     * Server sent this response to directing client to get requested resource to another URI with an GET request.\n     */\n    StatusCodes[StatusCodes[\"SEE_OTHER\"] = 303] = \"SEE_OTHER\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.1\n     *\n     * This is used for caching purposes. It is telling to client that response has not been modified. So, client can continue to use same cached version of response.\n     */\n    StatusCodes[StatusCodes[\"NOT_MODIFIED\"] = 304] = \"NOT_MODIFIED\";\n    /**\n     * @deprecated\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.6\n     *\n     * Was defined in a previous version of the HTTP specification to indicate that a requested response must be accessed by a proxy. It has been deprecated due to security concerns regarding in-band configuration of a proxy.\n     */\n    StatusCodes[StatusCodes[\"USE_PROXY\"] = 305] = \"USE_PROXY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.7\n     *\n     * Server sent this response to directing client to get requested resource to another URI with same method that used prior request. This has the same semantic than the 302 Found HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.\n     */\n    StatusCodes[StatusCodes[\"TEMPORARY_REDIRECT\"] = 307] = \"TEMPORARY_REDIRECT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7538#section-3\n     *\n     * This means that the resource is now permanently located at another URI, specified by the Location: HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.\n     */\n    StatusCodes[StatusCodes[\"PERMANENT_REDIRECT\"] = 308] = \"PERMANENT_REDIRECT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.1\n     *\n     * This response means that server could not understand the request due to invalid syntax.\n     */\n    StatusCodes[StatusCodes[\"BAD_REQUEST\"] = 400] = \"BAD_REQUEST\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.1\n     *\n     * Although the HTTP standard specifies \"unauthorized\", semantically this response means \"unauthenticated\". That is, the client must authenticate itself to get the requested response.\n     */\n    StatusCodes[StatusCodes[\"UNAUTHORIZED\"] = 401] = \"UNAUTHORIZED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.2\n     *\n     * This response code is reserved for future use. Initial aim for creating this code was using it for digital payment systems however this is not used currently.\n     */\n    StatusCodes[StatusCodes[\"PAYMENT_REQUIRED\"] = 402] = \"PAYMENT_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.3\n     *\n     * The client does not have access rights to the content, i.e. they are unauthorized, so server is rejecting to give proper response. Unlike 401, the client's identity is known to the server.\n     */\n    StatusCodes[StatusCodes[\"FORBIDDEN\"] = 403] = \"FORBIDDEN\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.4\n     *\n     * The server can not find requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 to hide the existence of a resource from an unauthorized client. This response code is probably the most famous one due to its frequent occurence on the web.\n     */\n    StatusCodes[StatusCodes[\"NOT_FOUND\"] = 404] = \"NOT_FOUND\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.5\n     *\n     * The request method is known by the server but has been disabled and cannot be used. For example, an API may forbid DELETE-ing a resource. The two mandatory methods, GET and HEAD, must never be disabled and should not return this error code.\n     */\n    StatusCodes[StatusCodes[\"METHOD_NOT_ALLOWED\"] = 405] = \"METHOD_NOT_ALLOWED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.6\n     *\n     * This response is sent when the web server, after performing server-driven content negotiation, doesn't find any content following the criteria given by the user agent.\n     */\n    StatusCodes[StatusCodes[\"NOT_ACCEPTABLE\"] = 406] = \"NOT_ACCEPTABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.2\n     *\n     * This is similar to 401 but authentication is needed to be done by a proxy.\n     */\n    StatusCodes[StatusCodes[\"PROXY_AUTHENTICATION_REQUIRED\"] = 407] = \"PROXY_AUTHENTICATION_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.7\n     *\n     * This response is sent on an idle connection by some servers, even without any previous request by the client. It means that the server would like to shut down this unused connection. This response is used much more since some browsers, like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing. Also note that some servers merely shut down the connection without sending this message.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_TIMEOUT\"] = 408] = \"REQUEST_TIMEOUT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.8\n     *\n     * This response is sent when a request conflicts with the current state of the server.\n     */\n    StatusCodes[StatusCodes[\"CONFLICT\"] = 409] = \"CONFLICT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.9\n     *\n     * This response would be sent when the requested content has been permenantly deleted from server, with no forwarding address. Clients are expected to remove their caches and links to the resource. The HTTP specification intends this status code to be used for \"limited-time, promotional services\". APIs should not feel compelled to indicate resources that have been deleted with this status code.\n     */\n    StatusCodes[StatusCodes[\"GONE\"] = 410] = \"GONE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.10\n     *\n     * The server rejected the request because the Content-Length header field is not defined and the server requires it.\n     */\n    StatusCodes[StatusCodes[\"LENGTH_REQUIRED\"] = 411] = \"LENGTH_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.2\n     *\n     * The client has indicated preconditions in its headers which the server does not meet.\n     */\n    StatusCodes[StatusCodes[\"PRECONDITION_FAILED\"] = 412] = \"PRECONDITION_FAILED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.11\n     *\n     * Request entity is larger than limits defined by server; the server might close the connection or return an Retry-After header field.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_TOO_LONG\"] = 413] = \"REQUEST_TOO_LONG\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.12\n     *\n     * The URI requested by the client is longer than the server is willing to interpret.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_URI_TOO_LONG\"] = 414] = \"REQUEST_URI_TOO_LONG\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.13\n     *\n     * The media format of the requested data is not supported by the server, so the server is rejecting the request.\n     */\n    StatusCodes[StatusCodes[\"UNSUPPORTED_MEDIA_TYPE\"] = 415] = \"UNSUPPORTED_MEDIA_TYPE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.4\n     *\n     * The range specified by the Range header field in the request can't be fulfilled; it's possible that the range is outside the size of the target URI's data.\n     */\n    StatusCodes[StatusCodes[\"REQUESTED_RANGE_NOT_SATISFIABLE\"] = 416] = \"REQUESTED_RANGE_NOT_SATISFIABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.14\n     *\n     * This response code means the expectation indicated by the Expect request header field can't be met by the server.\n     */\n    StatusCodes[StatusCodes[\"EXPECTATION_FAILED\"] = 417] = \"EXPECTATION_FAILED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2324#section-2.3.2\n     *\n     * Any attempt to brew coffee with a teapot should result in the error code \"418 I'm a teapot\". The resulting entity body MAY be short and stout.\n     */\n    StatusCodes[StatusCodes[\"IM_A_TEAPOT\"] = 418] = \"IM_A_TEAPOT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6\n     *\n     * The 507 (Insufficient Storage) status code means the method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request. This condition is considered to be temporary. If the request which received this status code was the result of a user action, the request MUST NOT be repeated until it is requested by a separate user action.\n     */\n    StatusCodes[StatusCodes[\"INSUFFICIENT_SPACE_ON_RESOURCE\"] = 419] = \"INSUFFICIENT_SPACE_ON_RESOURCE\";\n    /**\n     * @deprecated\n     * Official Documentation @ https://tools.ietf.org/rfcdiff?difftype=--hwdiff&url2=draft-ietf-webdav-protocol-06.txt\n     *\n     * A deprecated response used by the Spring Framework when a method has failed.\n     */\n    StatusCodes[StatusCodes[\"METHOD_FAILURE\"] = 420] = \"METHOD_FAILURE\";\n    /**\n     * Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7540#section-9.1.2\n     *\n     * Defined in the specification of HTTP/2 to indicate that a server is not able to produce a response for the combination of scheme and authority that are included in the request URI.\n     */\n    StatusCodes[StatusCodes[\"MISDIRECTED_REQUEST\"] = 421] = \"MISDIRECTED_REQUEST\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.3\n     *\n     * The request was well-formed but was unable to be followed due to semantic errors.\n     */\n    StatusCodes[StatusCodes[\"UNPROCESSABLE_ENTITY\"] = 422] = \"UNPROCESSABLE_ENTITY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.4\n     *\n     * The resource that is being accessed is locked.\n     */\n    StatusCodes[StatusCodes[\"LOCKED\"] = 423] = \"LOCKED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.5\n     *\n     * The request failed due to failure of a previous request.\n     */\n    StatusCodes[StatusCodes[\"FAILED_DEPENDENCY\"] = 424] = \"FAILED_DEPENDENCY\";\n    /**\n     * Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.15\n     *\n     * The server refuses to perform the request using the current protocol but might be willing to do so after the client upgrades to a different protocol.\n     */\n    StatusCodes[StatusCodes[\"UPGRADE_REQUIRED\"] = 426] = \"UPGRADE_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-3\n     *\n     * The origin server requires the request to be conditional. Intended to prevent the 'lost update' problem, where a client GETs a resource's state, modifies it, and PUTs it back to the server, when meanwhile a third party has modified the state on the server, leading to a conflict.\n     */\n    StatusCodes[StatusCodes[\"PRECONDITION_REQUIRED\"] = 428] = \"PRECONDITION_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-4\n     *\n     * The user has sent too many requests in a given amount of time (\"rate limiting\").\n     */\n    StatusCodes[StatusCodes[\"TOO_MANY_REQUESTS\"] = 429] = \"TOO_MANY_REQUESTS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-5\n     *\n     * The server is unwilling to process the request because its header fields are too large. The request MAY be resubmitted after reducing the size of the request header fields.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_HEADER_FIELDS_TOO_LARGE\"] = 431] = \"REQUEST_HEADER_FIELDS_TOO_LARGE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7725\n     *\n     * The user-agent requested a resource that cannot legally be provided, such as a web page censored by a government.\n     */\n    StatusCodes[StatusCodes[\"UNAVAILABLE_FOR_LEGAL_REASONS\"] = 451] = \"UNAVAILABLE_FOR_LEGAL_REASONS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.1\n     *\n     * The server encountered an unexpected condition that prevented it from fulfilling the request.\n     */\n    StatusCodes[StatusCodes[\"INTERNAL_SERVER_ERROR\"] = 500] = \"INTERNAL_SERVER_ERROR\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.2\n     *\n     * The request method is not supported by the server and cannot be handled. The only methods that servers are required to support (and therefore that must not return this code) are GET and HEAD.\n     */\n    StatusCodes[StatusCodes[\"NOT_IMPLEMENTED\"] = 501] = \"NOT_IMPLEMENTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.3\n     *\n     * This error response means that the server, while working as a gateway to get a response needed to handle the request, got an invalid response.\n     */\n    StatusCodes[StatusCodes[\"BAD_GATEWAY\"] = 502] = \"BAD_GATEWAY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.4\n     *\n     * The server is not ready to handle the request. Common causes are a server that is down for maintenance or that is overloaded. Note that together with this response, a user-friendly page explaining the problem should be sent. This responses should be used for temporary conditions and the Retry-After: HTTP header should, if possible, contain the estimated time before the recovery of the service. The webmaster must also take care about the caching-related headers that are sent along with this response, as these temporary condition responses should usually not be cached.\n     */\n    StatusCodes[StatusCodes[\"SERVICE_UNAVAILABLE\"] = 503] = \"SERVICE_UNAVAILABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.5\n     *\n     * This error response is given when the server is acting as a gateway and cannot get a response in time.\n     */\n    StatusCodes[StatusCodes[\"GATEWAY_TIMEOUT\"] = 504] = \"GATEWAY_TIMEOUT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.6\n     *\n     * The HTTP version used in the request is not supported by the server.\n     */\n    StatusCodes[StatusCodes[\"HTTP_VERSION_NOT_SUPPORTED\"] = 505] = \"HTTP_VERSION_NOT_SUPPORTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6\n     *\n     * The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.\n     */\n    StatusCodes[StatusCodes[\"INSUFFICIENT_STORAGE\"] = 507] = \"INSUFFICIENT_STORAGE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-6\n     *\n     * The 511 status code indicates that the client needs to authenticate to gain network access.\n     */\n    StatusCodes[StatusCodes[\"NETWORK_AUTHENTICATION_REQUIRED\"] = 511] = \"NETWORK_AUTHENTICATION_REQUIRED\";\n})(StatusCodes || (StatusCodes = {}));\n","import type { FilePointer, FilePointerLocal } from './file-pointer.js';\n\nexport class FilePointerBlob implements FilePointer {\n    constructor(public readonly file: File) {}\n\n    get permanentUrl() {\n        return URL.createObjectURL(this.file);\n    }\n\n    getTranscoderInputFile(): FilePointerLocal {\n        return {\n            file: this.file,\n            size: this.file.size,\n            source: 'local',\n        };\n    }\n}\n","export class ReportingContext {\n    private failures: { path: string; expected: string; received: string }[] = [];\n\n    constructor(\n        private readonly path: string | number,\n        private readonly children: ReportingContext[] = []\n    ) {}\n\n    push(key: string | number): ReportingContext {\n        const child = new ReportingContext(`${this.path}.${key}`);\n        this.children.push(child);\n        return child;\n    }\n\n    errors(): string[] {\n        const failures = this.failures.map(\n            err => `${err.path}: expected ${err.expected} received ${err.received}`\n        );\n        const childrenErrors = this.children.flatMap(child => child.errors());\n        return [...failures, ...childrenErrors];\n    }\n\n    fail(expected: string, received: string): void {\n        this.failures.push({ path: `${this.path}`, expected, received });\n    }\n}\n\nexport function isReportingContext(val: unknown): val is ReportingContext {\n    return val instanceof ReportingContext;\n}\n","import { isReportingContext, type ReportingContext } from './reporting-context.js';\n\ntype UnknownObject = Record<string, unknown>;\n\nexport interface Guard<T> {\n    /**\n     * The type of context is unknown in order to continue supporting the guard behaviour in array filters.\n     *\n     * @example\n     * ```ts\n     * const arrayOfAnything.filter(isString)\n     * ```\n     *\n     * In the example above the array index will be passed as the `context` parameter, resulting in a type\n     * error. Splitting it out to `arrayOfAnything.filter(item => isString(item))` is less readable and loses\n     * the string[] return type, so we pass an unknown second parameter and check it's type within the guard.\n     */\n    (val: unknown, context?: unknown): val is T;\n}\n\nfunction pushContext(key: string | number, context?: unknown): ReportingContext | undefined {\n    return isReportingContext(context) ? context.push(key) : undefined;\n}\n\nfunction getReadableTypeof(val: unknown): string {\n    if (typeof val === 'object') {\n        if (Array.isArray(val)) {\n            return 'array';\n        }\n        if (val === undefined || val === null) {\n            return `${val}`;\n        }\n        if (val instanceof Date) {\n            return 'date';\n        }\n        if (val instanceof RegExp) {\n            return 'RegExp';\n        }\n    }\n    return typeof val;\n}\n\n/**\n * Check whether a value is an object\n *\n * A value is considered an \"object\" if:\n * - it's not null or undefined,\n * - it's typeof is 'object', and\n * - it's not an array\n */\nexport function isObject(val: unknown, context?: unknown): val is UnknownObject {\n    const result = isDefined(val) && typeof val === 'object' && !Array.isArray(val);\n    if (!result && isReportingContext(context)) {\n        context.fail('object', getReadableTypeof(val));\n    }\n    return result;\n}\n\nexport function isString(val: unknown, context?: unknown): val is string {\n    const result = typeof val === 'string';\n    if (!result && isReportingContext(context)) {\n        context.fail('string', getReadableTypeof(val));\n    }\n    return result;\n}\n\n/**\n * Check whether a value is defined\n */\nexport function isDefined<T>(value: T | undefined | null, context?: unknown): value is T {\n    const result = value !== undefined && value !== null;\n    if (!result && isReportingContext(context)) {\n        context.fail('to be defined', `${value}`);\n    }\n    return result;\n}\n\n/**\n * Check whether a value is another using === equality.\n *\n * @example\n * ```ts\n * // (val: unknown): val is 'bob'\n * const isStringBob = asLiteral('bob');\n * ```\n *\n * It can be used to check a string union:\n *\n * ```ts\n * type Status = 'pending' | 'rejected' | 'resolved';\n *\n * // (val: unknown) => val is 'pending' | 'rejected' | 'resolved'\n * const isStatus = asLiteral(\n *      'pending',\n *      'rejected',\n *      'resolved'\n * );\n * ```\n */\nexport function asLiteral<T extends string | boolean | number>(...literals: T[]) {\n    return (val: unknown, context?: unknown): val is T => {\n        const result = literals.includes(val as T);\n        if (!result && isReportingContext(context)) {\n            const received = ['string', 'boolean', 'number'].includes(typeof val)\n                ? `${val}`\n                : getReadableTypeof(val);\n            context.fail(`one of ${literals.join(',')}`, `(${getReadableTypeof(val)}) ${received}`);\n        }\n        return result;\n    };\n}\n\nexport function isNumber(val: unknown, context?: unknown): val is number {\n    const result = typeof val === 'number';\n    if (!result && isReportingContext(context)) {\n        context.fail('number', getReadableTypeof(val));\n    }\n    return result;\n}\n\nexport function isBoolean(val: unknown, context?: unknown): val is boolean {\n    const result = typeof val === 'boolean';\n    if (!result && isReportingContext(context)) {\n        context.fail('boolean', getReadableTypeof(val));\n    }\n    return result;\n}\n\n/**\n * Check if a value is a function.\n *\n * Note: it's impossible to determine the return type or arguments of a function using a type guard\n */\nexport function isFunction(\n    val: unknown,\n    context?: unknown\n): val is (...args: unknown[]) => unknown {\n    const result = typeof val === 'function';\n    if (!result && isReportingContext(context)) {\n        context.fail('function', getReadableTypeof(val));\n    }\n    return result;\n}\n\nexport function isArray(val: unknown, context?: unknown): val is unknown[] {\n    const result = Array.isArray(val);\n    if (!result && isReportingContext(context)) {\n        context.fail('array', getReadableTypeof(val));\n    }\n    return result;\n}\n\n/**\n * This method is very dangerous and shouldn't be used if you don't know what you're doing.\n *\n * Whenever you use this method you must add a comment explaining why you used it and link\n * to a ticket for removing it.\n *\n * @example\n * ```ts\n * const isProject = createObjectGuard<Project>({\n *   title: isString,\n *   // We currently don't have any object guards for assets.\n *   // Because we've just cast up until now it's safe to use\n *   // this until there is a guard for assets.\n *   assets: asArray(UNSAFE__isAnyValue)\n * })\n * ```\n *\n */\nexport function unsafe__isAnyValue(_val: unknown): _val is any {\n    return true;\n}\n\n/**\n * This is the opposite of the UNSAFE__isAnyValue function. This should only be used if\n * you do not care about the type coming out.\n *\n * Odd scenario, but sometimes the developer may just want to discard the typing system for an unknown area.\n *\n * @example\n * ```ts\n *  function canFetch(): boolean {\n *    try {\n *      await request('/projects/:id', { method: 'GET' }, isUnknownValue);\n *      return true;\n *    } catch {\n *      return false\n *    }\n *  }\n * ```\n */\nexport function isUnknownValue(val: unknown): val is unknown {\n    return true;\n}\n\nexport type ObjectGuard<T> = {\n    [key in keyof T]: Guard<T[key]>;\n};\n\n/**\n * Determine whether an object has a certain shape, composing other type guards together.\n *\n * @example\n * ```ts\n * interface Person {\n *   name: string,\n *   age: number,\n * }\n *\n * const x: unknown = { ... };\n *\n * assert(isObjectOfShape(x, { name: isString, age: isNumber }));\n *\n * // x is now assignable to Person\n * ```\n */\nexport function isObjectOfShape<T>(\n    value: unknown,\n    shape: ObjectGuard<T>,\n    context?: unknown\n): value is T {\n    if (!isObject(value)) {\n        if (isReportingContext(context)) {\n            context.fail('object', getReadableTypeof(value));\n        }\n        return false;\n    }\n    let validShape = true;\n\n    for (const key in shape) {\n        const guard = shape[key];\n        const keyContext = pushContext(key, context);\n\n        if (guard && !guard(value[key], keyContext)) {\n            // We behave differently if a context has been provided, since we likely want to see all fields\n            // in the shape that fail. If we don't care about the context, just fail on the first instance.\n            if (isReportingContext(context)) {\n                validShape = false;\n            } else {\n                return false;\n            }\n        }\n    }\n\n    return validShape;\n}\n\n/**\n * Convert a type guard into a type guard that matches the same or undefined.\n *\n * @example\n * ```ts\n * // (val: unknown) => val is number | undefined\n * const isNumberOrUndefined = asOptional(isNumber);\n * ```\n */\nexport function asOptional<T>(guard: Guard<T>) {\n    return (val: unknown, context?: unknown): val is T | undefined => {\n        return val === undefined || guard(val, context);\n    };\n}\n\n/**\n * Convert a type guard into a type guard that matches the same, null or undefined.\n *\n * This guard is useful for validating responses from the backend as Python may return\n * null or undefined.\n *\n * @example\n * ```ts\n * // (val: unknown) => val is number | undefined | null\n * const isNumberOrUndefinedOrNull = asNullable(isNumber);\n * ```\n *\n */\nexport function asNullableOrUndefined<T>(guard: Guard<T>) {\n    return (val: unknown, context?: unknown): val is T | undefined | null => {\n        return val === undefined || val === null || guard(val, context);\n    };\n}\n\nexport function asNullable<T>(guard: Guard<T>) {\n    return (val: unknown, context?: unknown): val is T | null => {\n        return val === null || guard(val, context);\n    };\n}\n/**\n * Convert multiple type guards into a union of type guards\n *\n * @example\n * ```ts\n * // (val: unknown) => val is number | boolean\n * const isBooleanOrNumber = asUnion(isNumber, isBoolean);\n * ```\n */\nexport function asUnion<T extends Guard<unknown>[]>(...guards: T) {\n    return (\n        val: unknown,\n        context?: unknown\n    ): val is T[number] extends (value: unknown, context?: unknown) => value is infer V\n        ? V\n        : never => {\n        for (const guard of guards) {\n            // Union error reporting is strange, in that we don't want to add errors\n            // to the context until we know they've failed every instance, because otherwise we\n            // receive false failures. Therefore, we don't pass the context through here.\n            if (guard(val)) {\n                return true;\n            }\n        }\n        if (isReportingContext(context)) {\n            // Report the error now\n            guards.forEach((guard, index) => {\n                const guardContext = context.push(`UnionGuard.${index}`);\n                guard(val, guardContext);\n            });\n        }\n        return false;\n    };\n}\n\n/**\n * Convert a type guard into a type guard that matches an array\n *\n * @example\n * ```ts\n * // (val: unknown): val is string[]\n * const isArrayOfStrings = asArray(isString);\n * ```\n */\nexport function asArray<T>(guard: Guard<T>): Guard<T[]> {\n    return (val: unknown, context?: unknown): val is T[] =>\n        Array.isArray(val) &&\n        val.every((v, index) => {\n            // Due to .every this will only report errors on the first invalid item in the array.\n            // This is preferred behaviour to avoid logging repeat errors in a potentially large array.\n            const indexContext = pushContext(index, context);\n            return guard(v, indexContext);\n        });\n}\n\n// These types should become available as part of Typescript 4.1\ntype TupleOf<T, N extends number> = N extends N\n    ? number extends N\n        ? T[]\n        : _TupleOf<T, N, []>\n    : never;\ntype _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N\n    ? R\n    : _TupleOf<T, N, [T, ...R]>;\n\n/**\n * Convert a type guard into a type guard that matches an array of fixed length.\n * Note that currently all of the elements in the tuple must be of the same type.\n *\n * @example\n * ```ts\n * // (val: unknown): val is [string, string]\n * const isTwoStringsInArray = asTuple(isString, 2);\n * ```\n */\nexport function asTuple<T, N extends number>(guard: Guard<T>, length: N) {\n    return (val: unknown, context?: unknown): val is TupleOf<T, N> => {\n        return (\n            Array.isArray(val) &&\n            val.length === length &&\n            val.every((v, index) => {\n                // Due to .every this will only report errors on the first invalid item in the array.\n                // This is preferred behaviour to avoid logging repeat errors in a potentially large array.\n                const indexContext = pushContext(index, context);\n                return guard(v, indexContext);\n            })\n        );\n    };\n}\n\n/**\n * Convert a type guard into a type guard that matches an object.\n *\n * ```ts\n * // (val: unknown): val is { [key: string]: string }\n * const isObjectOfStrings = asObject(isString);\n * ```\n */\nexport function asObject<T>(guard: Guard<T>): Guard<{ [key: string]: T }> {\n    return (val: unknown, context?: unknown): val is { [key: string]: T } =>\n        isObject(val) &&\n        Object.keys(val).every(key => {\n            const objectKeyContext = pushContext(key, context);\n            return guard(val[key], objectKeyContext);\n        });\n}\n\n/**\n * Convert a type guard into a type guard that matches a guarded key value Map object.\n *\n * ```ts\n * // (val: unknown): val is Map<'one' | 'two', string>\n * const isMapOfStrings = asMap(asLiteral('one', 'two'), isString);\n * ```\n */\nexport function asMap<K extends string, V>(\n    keyGuard: Guard<K>,\n    valueGuard: Guard<V>\n): Guard<Map<K, V>> {\n    return (val: unknown, context?: unknown): val is Map<K, V> =>\n        val instanceof Map &&\n        [...val].every(([key, value]) => {\n            const objectKeyContext = pushContext(key, context);\n            return keyGuard(key) && valueGuard(value, objectKeyContext);\n        });\n}\n\n/**\n * Used for when a Record is used as a map for JSON serialization. Where the key value\n * is a significant string, such as the projectId.\n * ```ts\n * const projects: Record<string, ProjectStateModel> = {};\n * const isProjectRecordMap = asRecordMap(isString, isProjectStateModel);\n * ```\n */\nexport function asRecordMap<K extends string, V>(\n    keyGuard: Guard<K>,\n    valueGuard: Guard<V>\n): Guard<Record<K, V>> {\n    return (val: unknown, context?: unknown): val is Record<K, V> =>\n        val instanceof Object &&\n        Object.entries(val).every(([key, value]) => {\n            const objectKeyContext = pushContext(key, context);\n            return keyGuard(key) && valueGuard(value, objectKeyContext);\n        });\n}\n\n/**\n * Convert an object of type guards into a type guard that matches that object.\n *\n * @example\n * ```ts\n * interface Person {\n *   name: string;\n *   age: number;\n *   metadata?: {\n *     location: string;\n *   }\n * }\n *\n * const isPerson: (val: unknown) => val is Person = createObjectGuard({\n *   name: isString,\n *   age: isNumber,\n *   metadata: asOptional(createObjectGuard({ location: isString }))\n * });\n * ```\n */\nexport function createObjectGuard<T>(guard: ObjectGuard<T>) {\n    return (val: unknown, context?: unknown): val is T => isObjectOfShape(val, guard, context);\n}\n\n/**\n * Assist in type narrowing when you just need to pick out a key.\n */\nexport function hasKey<K extends string>(\n    key: K,\n    objectToTest: unknown\n): objectToTest is Record<K, unknown> {\n    if (typeof objectToTest === 'object' && objectToTest !== null) {\n        return key in objectToTest;\n    }\n    return false;\n}\n\n/**\n * checks to see if you have an object that doesn't have any keys or values.\n * eg; check if you have a project object, but it is an empty project.\n */\nexport function isEmptyObject(val: Record<string, unknown>) {\n    return isObject(val) && Object.keys(val).length === 0;\n}\n\n/**\n * Infer the type of a guard.\n */\nexport type GuardedType<T> = T extends (x: unknown) => x is infer R ? R : never;\n","import validate from './validate.js';\nconst byteToHex = [];\nfor (let i = 0; i < 256; ++i) {\n    byteToHex.push((i + 0x100).toString(16).slice(1));\n}\nexport function unsafeStringify(arr, offset = 0) {\n    return (byteToHex[arr[offset + 0]] +\n        byteToHex[arr[offset + 1]] +\n        byteToHex[arr[offset + 2]] +\n        byteToHex[arr[offset + 3]] +\n        '-' +\n        byteToHex[arr[offset + 4]] +\n        byteToHex[arr[offset + 5]] +\n        '-' +\n        byteToHex[arr[offset + 6]] +\n        byteToHex[arr[offset + 7]] +\n        '-' +\n        byteToHex[arr[offset + 8]] +\n        byteToHex[arr[offset + 9]] +\n        '-' +\n        byteToHex[arr[offset + 10]] +\n        byteToHex[arr[offset + 11]] +\n        byteToHex[arr[offset + 12]] +\n        byteToHex[arr[offset + 13]] +\n        byteToHex[arr[offset + 14]] +\n        byteToHex[arr[offset + 15]]).toLowerCase();\n}\nfunction stringify(arr, offset = 0) {\n    const uuid = unsafeStringify(arr, offset);\n    if (!validate(uuid)) {\n        throw TypeError('Stringified UUID is invalid');\n    }\n    return uuid;\n}\nexport default stringify;\n","let getRandomValues;\nconst rnds8 = new Uint8Array(16);\nexport default function rng() {\n    if (!getRandomValues) {\n        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {\n            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n        }\n        getRandomValues = crypto.getRandomValues.bind(crypto);\n    }\n    return getRandomValues(rnds8);\n}\n","const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);\nexport default { randomUUID };\n","import native from './native.js';\nimport rng from './rng.js';\nimport { unsafeStringify } from './stringify.js';\nfunction v4(options, buf, offset) {\n    if (native.randomUUID && !buf && !options) {\n        return native.randomUUID();\n    }\n    options = options || {};\n    const rnds = options.random ?? options.rng?.() ?? rng();\n    if (rnds.length < 16) {\n        throw new Error('Random bytes length must be >= 16');\n    }\n    rnds[6] = (rnds[6] & 0x0f) | 0x40;\n    rnds[8] = (rnds[8] & 0x3f) | 0x80;\n    if (buf) {\n        offset = offset || 0;\n        if (offset < 0 || offset + 16 > buf.length) {\n            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);\n        }\n        for (let i = 0; i < 16; ++i) {\n            buf[offset + i] = rnds[i];\n        }\n        return buf;\n    }\n    return unsafeStringify(rnds);\n}\nexport default v4;\n","import { v4 as uuidV4, validate as uuidValidate, version as uuidVersion } from 'uuid';\n\nexport function uuid(): string {\n    return uuidV4();\n}\n\nexport function isUuid(str: string) {\n    return uuidValidate(str) && uuidVersion(str) === 4;\n}\n","import { isNumber, isString } from './guards.js';\nimport { uuid } from './uuid.js';\n\nexport type ErrorContext = Record<string, unknown>;\nexport type SerializedErrorContext = Record<string, string | number | undefined>;\n\nexport interface SerializedErrorWithContext {\n    message: string;\n    stack?: string;\n    context?: SerializedErrorContext;\n    safeToLog?: boolean;\n}\n\nlet testMode = false;\n\n/**\n * Enables test mode for error context. This will set the correlation ID to a fixed value.\n *\n * ONLY USE IN TESTS.\n */\nexport function __enableTestMode() {\n    testMode = true;\n}\n\nexport class ErrorWithContext<T extends ErrorContext = ErrorContext> extends Error {\n    /**\n     * Converts an unknown error value to an `ErrorWithContext`.\n     * This is useful for serialization since normal `Error` objects cannot be easily serialized.\n     * If you do not care about serialization and just want an error object, use `toErrorObject`\n     * since that keeps the original error if it is already an error object.\n     */\n    static fromUnknownError(\n        error: unknown,\n        defaultMessage: string,\n        context?: ErrorContext,\n        safeToLog?: boolean\n    ): ErrorWithContext {\n        if (error instanceof ErrorWithContext) {\n            if (context === undefined) {\n                return error;\n            }\n            const errorWithContext = new ErrorWithContext(error.message, {\n                ...error.context,\n                ...context,\n            });\n            replaceStackFrame(errorWithContext, error);\n            return errorWithContext;\n        }\n\n        if (error instanceof Error) {\n            const errorWithContext = new ErrorWithContext(error.message, context);\n            replaceStackFrame(errorWithContext, error);\n            return errorWithContext;\n        }\n\n        let originalError: string;\n        if (isString(error)) {\n            originalError = error;\n        } else {\n            try {\n                originalError = JSON.stringify(error);\n            } catch {\n                originalError = String(error);\n            }\n        }\n        return new ErrorWithContext(defaultMessage, { ...context, originalError }, safeToLog);\n    }\n\n    /**\n     * Deserializes an object serialized using {@link serialize} to recreate the original error.\n     */\n    static fromSerialized(serialized: SerializedErrorWithContext): ErrorWithContext {\n        const error = new ErrorWithContext(\n            serialized.message,\n            serialized.context,\n            serialized.safeToLog\n        );\n        error.stack = serialized.stack;\n        return error;\n    }\n\n    /**\n     * Create an Error that includes additional information to be logged to Sentry or Amplitude.\n     *\n     * Note: only string or number properties will be logged to amplitude.\n     */\n    constructor(\n        message: string,\n        /**\n         * The extra context attached to this error.\n         */\n        public context?: T,\n        /**\n         * A boolean indicating if this error is safe to log (does not contain any PII).\n         */\n        public readonly safeToLog?: boolean\n    ) {\n        super(message);\n        this.correlationId = testMode ? '00000000-0000-0000-0000-000000000000' : uuid();\n    }\n\n    /**\n     * Extract context entries that are strings or numbers into a new object.\n     *\n     * @example\n     * ```ts\n     * const error = new ErrorWithContext('Failed to download projects', {\n     *   response,\n     *   statusCode\n     * });\n     *\n     * // { statusCode: 500 }\n     * const properties = error.toEventProperties();\n     * ```\n     */\n    toEventProperties(): SerializedErrorContext {\n        const properties: SerializedErrorContext = {};\n\n        for (const [key, value] of Object.entries(this.context ?? {})) {\n            if (isString(value) || isNumber(value)) {\n                properties[key] = value;\n            }\n        }\n\n        return properties;\n    }\n\n    /**\n     * Serializes the error into something that can be copied over a worker channel. Can be\n     * deserialized using {@link fromSerialized}.\n     */\n    serialize(): SerializedErrorWithContext {\n        return {\n            message: this.message,\n            stack: this.stack,\n            context: this.toEventProperties(),\n            safeToLog: this.safeToLog,\n        };\n    }\n\n    /**\n     * A unique ID to identify this error.\n     */\n    readonly correlationId: string;\n\n    /**\n     * An error code stored in the context if one exists.\n     */\n    get errorCode(): string | undefined {\n        return this.context?.errorCode as string;\n    }\n\n    /**\n     * The message of the error.\n     */\n    get errorMessage(): string | undefined {\n        return this.message;\n    }\n\n    /**\n     * Any related context to the error.\n     */\n    get errorContext(): string | undefined {\n        return undefined;\n    }\n}\n\nexport function isErrorWithContext(value: unknown): value is ErrorWithContext {\n    return value instanceof ErrorWithContext;\n}\n\nexport function toErrorObject(error: unknown, message: string): Error {\n    if (error instanceof Error) {\n        return error;\n    }\n    return ErrorWithContext.fromUnknownError(error, message);\n}\n\n/**\n * Push the current stack frame onto a provided error object.\n *\n * @example\n * ```\n * top() {\n *\n *   const error = new Error('test');\n *\n *   // Error: test\n *   //    at top\n *\n *   next() {\n *\n *     pushCurrentFrame(error);\n *\n *     // Error: test\n *     //    at next\n *     //    at top\n *\n *   }\n * }\n * ```\n */\nexport function pushCurrentFrame(e: Error): void {\n    const currentError = new Error('CurrentFrame');\n\n    if (e.stack && currentError.stack) {\n        const currentFrame = currentError.stack.split('\\n')[2];\n\n        const [name, ...stack] = (e.stack ?? '').split('\\n');\n\n        e.stack = [name, currentFrame, ...stack].join('\\n');\n    }\n}\n\n/**\n * Pop the current stack frame off the provided error object.\n *\n * @example\n * ```\n * top() {\n *   next()\n *     const error = new Error('test');\n *\n *     popStackFrame(error);\n *\n *     // Error: test\n *     //    at top\n *\n *   }\n * }\n * ```\n */\nexport function popStackFrame<E extends Error>(e: E): void {\n    if (e.stack) {\n        const [name, , ...stack] = e.stack.split('\\n');\n        e.stack = [name, ...stack].join('\\n');\n    }\n}\n\n/**\n * Completely replaces the stack of one error with another.\n *\n * @example\n * ```\n * const errorClone = new Error(error.message);\n * replaceStackFrame(errorClone, error);\n * ```\n */\nexport function replaceStackFrame<E extends Error>(error: E, stackError: Error): void {\n    if (error.stack === undefined) {\n        error.stack = stackError.stack;\n    } else if (stackError.stack !== undefined) {\n        const [name] = error.stack.split('\\n');\n        const [, ...stack] = stackError.stack.split('\\n');\n        error.stack = [name, ...stack].join('\\n');\n    }\n}\n\n/**\n * Custom TypeError that should be thrown in place of the built-in TypeError.\n * While it's functionally the same, this one will be scrubbed during logging.\n */\nexport class UnsupportedTypeError extends TypeError {\n    constructor(message: string) {\n        super(message);\n    }\n}\n","import { popStackFrame } from './error.js';\n\nexport class AssertionError extends Error {\n    constructor(message?: string) {\n        super(message ? `AssertionError: ${message}` : `AssertionError: Assertion failed`);\n    }\n}\n\n/**\n * Assert a condition\n *\n * @example\n * ```ts\n * const val: number | string;\n * assert(typeof val === 'number', 'Expected val to be a number');\n *\n * // from here val is a number\n * console.log(val + 2);\n * ```\n *\n * @param condition - the condition to be asserted. False means fail true means pass.\n * @param message - an optional message to pass to the assertion error\n *\n */\nexport function assert(condition: boolean, message?: string): asserts condition {\n    if (!condition) {\n        const error = new AssertionError(message);\n        popStackFrame(error);\n\n        throw error;\n    }\n}\n\n/**\n * Throw in exhaustive checks\n *\n * Can only be called with a variable that is inferred as never.\n * Used within exhaustiveness checks to make sure all cases are handled.\n *\n * @example\n * ```ts\n * interface Square {\n *   kind: 'square';\n *   size: number;\n * }\n *\n * interface Rectangle {\n *   kind: 'rectangle';\n *   width: number;\n *   height: number;\n * }\n *\n * type Shape = Square | Rectangle;\n *\n * function area(shape: Shape): number {\n *   switch (shape.kind) {\n *     case 'square':\n *       return shape.size * shape.size;\n *     case 'rectangle':\n *       return shape.width * shape.height;\n *     // If a new case is added at compile time you will get a compile error.\n *     // If a new value appears at runtime you will get a runtime error.\n *     default:\n *       return assertNever(shape);\n *   }\n * }\n * ```\n *\n * @param _ -  the value to check for never\n * @param message - an optional message to pass to the assertion error\n */\nexport function assertNever(\n    _: never,\n    message = 'Unexpected value. Should have been never.'\n): never {\n    const error = new AssertionError(message);\n    popStackFrame(error);\n\n    throw error;\n}\n","import { assert } from './assert.js';\nimport { popStackFrame } from './error.js';\nimport { isDefined } from './guards.js';\n\nexport type HandleUndefinedMode = 'throw' | 'log' | 'ignore';\n\nlet handleUndefinedMode: HandleUndefinedMode = 'ignore';\nlet errorLogger: (err: unknown) => void = console.error;\n\nexport function setHandleUndefinedMode(\n    mode: HandleUndefinedMode,\n    logger: (err: unknown) => void\n): void {\n    handleUndefinedMode = mode;\n    errorLogger = logger;\n}\n\n/**\n * Assert that a value is defined\n *\n * @example\n * ```ts\n * const value: string | undefined = store.get('key-that-definitely-exists');\n *\n * assertDefined(value, 'Expected value to be defined');\n *\n * // value is now defined\n * console.log(value.split('.'));\n * ```\n */\nexport function assertDefined<T>(value: T | undefined | null, message: string): asserts value is T {\n    try {\n        assert(isDefined(value), message);\n    } catch (e) {\n        if (e instanceof Error) {\n            popStackFrame(e);\n        }\n\n        throw e;\n    }\n}\n\n/**\n * Assert that a value is defined, returning the value\n *\n * @example\n * ```ts\n * const value: string | undefined = store.get('key-that-definitely-exists');\n *\n * const definedValue: string = defined(\n *     store.get('key-that-definitely-exists'),\n *     'Expected value to be defined'\n * );\n * ```\n *\n * Note: this should be used instead of the dangerous `!` operator.\n */\nexport function defined<T>(value: T | undefined | null, message: string): T {\n    try {\n        assertDefined(value, message);\n        return value;\n    } catch (e) {\n        if (e instanceof Error) {\n            popStackFrame(e);\n        }\n\n        throw e;\n    }\n}\n\n/**\n * Assert that a value is defined, returning the value.\n *\n * This is most useful when tsconfig noUncheckedIndexedAccess is enabled.\n *\n * If the value is not defined, the behaviour depends what `setHandleUndefinedMode` has\n * been set to:\n *\n * - `throw`: throw an error\n * - `log`: log an error\n * - `ignore`: ignore & return whatever the `value` is (unsafe, but useful for toggling on/off)\n *\n * @example\n *\n * ```ts\n * const arr: string[] = ['a', 'b', 'c'];\n * for (let i = 0; arr.length; i++) {\n *    // arr[i] is string | undefined (when noUncheckedIndexedAccess is enabled)\n *    const value = handleUndefined(arr[i]); // value is string\n * }\n * ```\n *\n * Note: this should be used instead of the dangerous `!` operator.\n */\nexport function handleUndefined<T>(value: T | undefined | null, message: string): T {\n    if (handleUndefinedMode === 'ignore') {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return value!;\n    }\n\n    try {\n        assertDefined(value, message);\n        return value;\n    } catch (e) {\n        if (e instanceof Error) {\n            popStackFrame(e);\n        }\n\n        if (handleUndefinedMode === 'throw') {\n            throw e;\n        } else if (handleUndefinedMode === 'log') {\n            errorLogger(e);\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return value!;\n    }\n}\n","import type { HttpError } from '../client/errors.js';\nimport type { RetryOptions } from '../utils/with-retry.js';\n\nexport const SUPPORTED_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'] as const;\nexport type SupportedMethods = (typeof SUPPORTED_METHODS)[number];\n\nexport interface HttpRequestSummary {\n    apiType?: 'graph' | 'substrate' | 'sharepoint' | 'mru';\n    method: SupportedMethods;\n    status: number;\n    requestId?: string;\n    responseId?: string;\n    resourceId?: string;\n    requestTimestamp?: number;\n    durationMs?: number;\n    correlationId?: string;\n}\n\nexport interface ExtendedResponse extends Response {\n    requestInfo: HttpRequestSummary;\n}\n\nexport const isExtendedResponse = (val: unknown): val is ExtendedResponse => {\n    const extendedResponse = val as ExtendedResponse;\n    return extendedResponse.requestInfo !== undefined;\n};\n\nexport interface RequestRetryOptions {\n    // List of status codes that should throw a retryable error\n    retryableHttpCodes?: number[];\n    retryPolicy?: RetryOptions<Record<string, never>, Response>;\n    signal?: AbortSignal | null;\n}\n\nexport interface RequestClientOptions extends RequestRetryOptions {\n    headers?: { [key: string]: string };\n    onSuccess?: (requestInfo: HttpRequestSummary) => void;\n    onError?: (error: HttpError, requestInfo: HttpRequestSummary) => void;\n}\n\nexport interface RequestOptions<T = undefined> extends RequestClientOptions {\n    method: SupportedMethods;\n    body?: unknown;\n    extraData?: T;\n}\n\ntype JsonGuard = <V>(guard: (body: unknown, context?: unknown) => body is V) => Promise<V>;\n\nexport interface GuardedJsonResponse extends Omit<Response, 'json'> {\n    json: JsonGuard;\n}\nexport interface RequestPromise extends Promise<GuardedJsonResponse> {\n    json: JsonGuard;\n}\n\nexport interface StrictRequestInit extends RequestInit {\n    method: string;\n    headers: { [key: string]: string };\n}\n\nexport type RequestOptionsMethodInferred<T> = Omit<RequestOptions<T>, 'method'>;\n\nexport interface RequestFunction<T = undefined> {\n    (resource: string, options?: RequestOptions<T>): RequestPromise;\n    get(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n    post(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n    put(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n    patch(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n    delete(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n    head(resource: string, options?: RequestOptionsMethodInferred<T>): RequestPromise;\n}\n\nexport type RequestHelperFunction = {\n    [key in Lowercase<SupportedMethods>]: (\n        resource: string,\n        options?: RequestOptions\n    ) => RequestPromise;\n};\n","import { ErrorWithContext, isNumber, isObject, isString } from '@clipchamp/util';\n\nimport { isExtendedResponse } from '../types/request-client-types.js';\n\nexport class NetworkError extends ErrorWithContext {\n    constructor(\n        public resource: string,\n        public method: string,\n        public online: boolean,\n        public originalError?: unknown\n    ) {\n        super(\n            `NetworkError::${method}::${online ? 'online' : 'offline'}`,\n            {\n                errorType: 'network',\n                resource,\n                method,\n                online: `${online}`,\n            },\n            true\n        );\n        if (originalError instanceof Error && this.context) {\n            this.context['reason'] = originalError.message;\n        }\n    }\n\n    public override get errorCode() {\n        return 'NetworkError';\n    }\n}\n\nexport class NetworkAbortError extends ErrorWithContext {\n    constructor(\n        public resource: string,\n        public method: string\n    ) {\n        super(`NetworkAbortError::${method}`, {}, true);\n    }\n\n    public override get errorCode() {\n        return 'NetworkAbortError';\n    }\n}\n\nexport class NetworkTypeError extends ErrorWithContext {\n    constructor(\n        public resource: string,\n        public method: string,\n        public originalError?: unknown\n    ) {\n        super(`NetworkTypeError`, {}, true);\n        if (originalError instanceof Error && this.context) {\n            this.context['reason'] = originalError.message;\n        }\n    }\n\n    public override get errorCode() {\n        return 'NetworkTypeError';\n    }\n}\n\nexport class HttpError extends ErrorWithContext {\n    constructor(\n        public resource: string,\n        public method: string,\n        public status: number,\n        public response: Response,\n        public body?: unknown\n    ) {\n        super(\n            `HTTPError::${method}`,\n            {\n                errorType: 'http',\n                resource,\n                method,\n                status,\n                reason: response.statusText,\n            },\n            true\n        );\n        if (this.context && isObject(body)) {\n            for (const [key, value] of Object.entries(body)) {\n                if (isString(value) || isNumber(value)) {\n                    this.context[`body.${key}`] = value;\n                }\n            }\n        }\n    }\n\n    public override get errorCode(): string {\n        if (isExtendedResponse(this.response)) {\n            // This error had additional properties attached during the request, so return them instead\n            return `${this.response.requestInfo.apiType}-${this.response.requestInfo.resourceId}-${this.status}`;\n        }\n        return this.status.toString();\n    }\n}\n\nexport class RetryableHttpError extends HttpError {\n    constructor(\n        resource: string,\n        method: string,\n        status: number,\n        response: Response,\n        body?: unknown\n    ) {\n        super(resource, method, status, response, body);\n        if (this.context) {\n            this.context['errorType'] = 'retryable-http';\n        }\n    }\n\n    public override get errorCode() {\n        return 'RetryableHttpError';\n    }\n}\n\nexport function isRetryableHttpError(val: unknown): val is RetryableHttpError {\n    return val instanceof RetryableHttpError;\n}\n\nexport const isNetworkOrRetryableHttpError = (val: unknown): boolean => {\n    return (\n        val instanceof NetworkError || val instanceof NetworkTypeError || isRetryableHttpError(val)\n    );\n};\n\nexport class JsonParseError extends ErrorWithContext {\n    constructor(\n        public response: Response,\n        public method: string,\n        public requestBody: unknown,\n        public responseBody: unknown\n    ) {\n        super(`JsonParseError::${method}::${response.url}`, {\n            response,\n            method,\n            requestBody,\n            responseBody,\n        });\n    }\n\n    public override get errorCode() {\n        return 'JsonParseError';\n    }\n}\n\nexport class UnexpectedResponseBody extends ErrorWithContext {\n    constructor(\n        public response: Response,\n        public method: string,\n        public requestBody: unknown,\n        public errors: string[]\n    ) {\n        super(`UnexpectedResponseBody::${method}::${response.url}`, {\n            errors,\n        });\n    }\n\n    public override get errorCode() {\n        if (isExtendedResponse(this.response)) {\n            // This error had additional properties attached during the request, so return them instead\n            return `${this.response.requestInfo.apiType}-${this.response.requestInfo.resourceId}`;\n        }\n        return 'UnexpectedResponseBody';\n    }\n\n    public override get errorContext() {\n        const errors = this.context?.errors as string[];\n        if (errors) {\n            return errors.join(', ');\n        }\n        return undefined;\n    }\n}\n","import { defined } from '@clipchamp/util';\n\nimport type { ExperimentFeature, ExperimentVariant, Feature } from './features.js';\nimport type { FlightService } from './FlightService.js';\nimport type { FlightMap } from './FlightTypes.js';\nimport type { KillSwitchKey } from './killSwitches.js';\nimport type { OperationalConfig } from './operationalConfig.js';\n\nlet globalFlightService: FlightService<unknown> | undefined = undefined;\n\n/**\n * This is an internal function - only use within the library.\n */\nexport function getFlightService<T = unknown>() {\n    return defined(\n        globalFlightService as FlightService<T>,\n        'Global flight service has not been set, or is of the wrong type.'\n    );\n}\n\nexport function setGlobalFlightService<T>(service: FlightService<T>) {\n    globalFlightService = service;\n}\n\n/**\n * FOR USE IN TESTS ONLY\n *\n * Remove all listeners from the store and reset to initial value.\n */\nexport function __resetFeatureFlagStore() {\n    getFlightService().__reset();\n}\n\n/**\n * Returns a map of all features and states.\n * Avoid using this if possible and prefer individual checks\n */\nexport function snapshotFeatures<TResult = unknown>() {\n    return getFlightService<TResult>().getAll();\n}\n\n/**\n * Check whether a feature is enabled\n */\nexport function isFeatureEnabled(feature: Feature): boolean {\n    const flightService = getFlightService();\n    return flightService.isEnabled(feature) && !flightService.isEnabled(`ks_${feature}`);\n}\n\n/**\n * Check whether a kill switch is enabled\n */\nexport function isKillSwitchEnabled(killSwitch: KillSwitchKey): boolean {\n    return getFlightService().isEnabled(killSwitch);\n}\n\n/**\n * Return a remote operational config set in ECS\n *\n * Example:\n *\n * ```ts\n * class PizzaDelivery {\n *   constructor() {\n *     this.checkIfPizzaHereRateMs = getOperationalConfigValue('config__pizza_polling_rate_ms') ?? DEFAULT_PIZZA_POLLING_RATE;\n *   }\n * }\n * ```\n *\n */\nexport function getOperationalConfigValue(\n    operationalConfig: OperationalConfig\n): string | undefined {\n    return getFlightService().getValue(operationalConfig) as string;\n}\n\n/**\n * Returns the strongly typed value of a flighted feature. Values are typed\n * checked using the mapped type and optionally using a type guard.\n */\nexport function getFeatureValue<T = string>(\n    feature: Feature,\n    guard?: (val: unknown, context?: unknown) => val is T\n): T | undefined {\n    const flightService = getFlightService();\n\n    const pairedKillSwitch = flightService.isEnabled(`ks_${feature}`);\n    if (pairedKillSwitch) {\n        // If kill switch is enabled, then always return false\n        return undefined;\n    }\n\n    const flightValue = flightService.getValue(feature);\n\n    if (flightValue === undefined || flightValue === null) {\n        return undefined;\n    }\n\n    if (guard && !guard(flightValue)) {\n        throw new Error('Flight value does not match requested type');\n    }\n\n    return flightValue as T;\n}\n\n/**\n * Get the value of an experiment feature\n */\nexport function getExperimentFeature<F extends ExperimentFeature>(\n    feature: F\n): ExperimentVariant<F> | false {\n    const flightValue = getFeatureValue<ExperimentVariant<F> | false>(feature, undefined);\n    const pairedKillSwitch = isKillSwitchEnabled(`ks_${feature}`);\n\n    if (pairedKillSwitch) {\n        // If kill switch is enabled, then always return false\n        return false;\n    }\n\n    if (typeof flightValue === 'boolean' || typeof flightValue === 'string') {\n        return flightValue;\n    }\n\n    return false;\n}\n\n/**\n * Get the value of an experiment feature\n * @see getExperimentFeature\n */\nexport function getExperimentFeatureInCurrentLocale<F extends ExperimentFeature>(feature: F) {\n    return getExperimentFeature<F>(feature);\n}\n\n/**\n * Get the value of a text feature. This functions returns the value as-is, or an empty string when value type is not string.\n * As above, value verification is recommended.\n */\nexport function getTextFeature<TResult>(feature: Feature): string {\n    const flightValue = getFeatureValue<TResult>(feature, undefined);\n    return typeof flightValue === 'string' ? flightValue : '';\n}\n\nexport function onFeaturesChanged<TResult>(\n    callback: (features: FlightMap<TResult | boolean | string>) => void,\n    emitImmediately = false\n): () => void {\n    const flightService = getFlightService<TResult>();\n    return flightService.onFeaturesChanged(callback, emitImmediately);\n}\n\nexport function setFeatures(features: FlightMap): void {\n    getFlightService().setFeatures(features);\n}\n","import { replaceStackFrame } from '@clipchamp/util';\n\nexport class NonRetryableError extends Error {\n    constructor(public readonly innerError: unknown) {\n        while (innerError instanceof NonRetryableError) {\n            innerError = innerError.innerError;\n        }\n\n        let message: string | undefined;\n        if (innerError instanceof Error) {\n            message = innerError.message;\n        }\n\n        super(message);\n\n        if (innerError instanceof Error) {\n            replaceStackFrame(this, innerError);\n        }\n    }\n}\n","import { toErrorObject } from '@clipchamp/util';\n\nimport { NonRetryableError } from './errors.js';\n\ntype BackOffPolicy = 'fixed' | 'exponential';\n\ninterface ExponentialOption {\n    maxInterval: number;\n    multiplier: number;\n}\n\nexport interface InjectedKwargs {\n    retried: boolean;\n    retryCount?: number;\n}\n\ntype RetryHandler<TCallerKwargs extends object = Record<string, never>> = (\n    e: Error,\n    kwargs?: TCallerKwargs\n) => Promise<TCallerKwargs | boolean> | TCallerKwargs | boolean;\n\ntype CatchHandler<TCallerKwargs extends object = Record<string, never>, TReturn = void> = (\n    e: Error,\n    kwargs?: TCallerKwargs\n) => Promise<TReturn>;\n\ntype BackOffDurationHandler = (e: Error, retryCount: number) => number | undefined;\n\nexport interface RetryOptions<\n    TCallerKwargs extends object = Record<string, never>,\n    TReturn = void,\n> {\n    maxAttempts?: number;\n    backOffPolicy?: BackOffPolicy;\n    backOff?: number;\n    getManualBackOff?: BackOffDurationHandler;\n    doRetry?: RetryHandler<TCallerKwargs>;\n    catch?: CatchHandler<TCallerKwargs, TReturn>;\n    exponentialOption?: ExponentialOption;\n}\n\ninterface CompleteRetryOptions<TCallerKwargs extends object = Record<string, never>, TReturn = void>\n    extends RetryOptions<TCallerKwargs, TReturn> {\n    maxAttempts: number;\n    backOffPolicy: BackOffPolicy;\n    backOff: number;\n    getManualBackOff?: BackOffDurationHandler;\n    doRetry: RetryHandler<TCallerKwargs>;\n    catch: CatchHandler<TCallerKwargs, TReturn>;\n    exponentialOption: ExponentialOption;\n    retried: boolean;\n    retryCount: number;\n}\n\nconst sleep = (timeout: number) => new Promise(resolve => setTimeout(resolve, timeout));\n\nconst retryAsync = async <TCallerKwargs extends object = Record<string, never>, TReturn = void>(\n    fn: (props: TCallerKwargs & InjectedKwargs) => Promise<TReturn>,\n    kwargs: TCallerKwargs | undefined,\n    {\n        maxAttempts,\n        backOff,\n        backOffPolicy,\n        exponentialOption,\n        getManualBackOff,\n        doRetry,\n        catch: catchHandler,\n        retried = false,\n        retryCount = 0,\n    }: CompleteRetryOptions<TCallerKwargs, TReturn>\n): Promise<TReturn> => {\n    try {\n        return await fn({ ...kwargs, retried, retryCount } as TCallerKwargs & InjectedKwargs);\n    } catch (e) {\n        if (e instanceof NonRetryableError) {\n            return catchHandler(toErrorObject(e.innerError, 'Error retrying'), kwargs);\n        }\n\n        const error = toErrorObject(e, 'Error retrying');\n\n        if (--maxAttempts <= 0) {\n            return catchHandler(error, kwargs);\n        }\n\n        const shouldRetry = await doRetry(error, kwargs);\n        if (shouldRetry === false) {\n            return catchHandler(error, kwargs);\n        }\n\n        if (shouldRetry !== true) {\n            kwargs = shouldRetry;\n        }\n\n        if (backOff) {\n            await sleep(backOff);\n        }\n\n        let newBackOff: number | undefined = undefined;\n\n        if (getManualBackOff) {\n            // A back off override was provided and may return a new back off delay time\n            newBackOff = getManualBackOff(error, retryCount);\n        }\n\n        if (!newBackOff && backOffPolicy === 'exponential') {\n            newBackOff = backOff * exponentialOption.multiplier;\n        }\n\n        if (newBackOff) {\n            backOff = Math.min(newBackOff, exponentialOption.maxInterval);\n        }\n\n        return retryAsync(fn, kwargs, {\n            maxAttempts,\n            backOff,\n            backOffPolicy,\n            exponentialOption,\n            doRetry,\n            catch: catchHandler,\n            retried: true,\n            retryCount: retryCount++,\n        });\n    }\n};\n\nexport const withRetry = <TCallerKwargs extends object = Record<string, never>, TReturn = void>({\n    maxAttempts = 3,\n    backOffPolicy = 'fixed',\n    backOff = 0,\n    getManualBackOff = undefined,\n    doRetry = () => true,\n    catch: catchHandler = e => {\n        throw e;\n    },\n    exponentialOption = { maxInterval: 2000, multiplier: 2 },\n}: RetryOptions<TCallerKwargs, TReturn>) => {\n    return (\n        originalFn: (props: TCallerKwargs & InjectedKwargs) => Promise<TReturn>\n    ): ((kwargs?: TCallerKwargs) => Promise<TReturn>) => {\n        const options: CompleteRetryOptions<TCallerKwargs, TReturn> = {\n            maxAttempts,\n            backOffPolicy,\n            backOff,\n            getManualBackOff,\n            doRetry,\n            exponentialOption,\n            retried: false,\n            retryCount: 0,\n            catch: catchHandler,\n        };\n        if (options.backOffPolicy === 'exponential' && !options.backOff) {\n            options.backOff = 1000;\n        }\n\n        return async kwargs => {\n            return retryAsync(originalFn, kwargs, options);\n        };\n    };\n};\n","import { isKillSwitchEnabled } from '@clipchamp/feature-flags';\nimport { type Guard, ReportingContext } from '@clipchamp/util';\n\nimport {\n    type GuardedJsonResponse,\n    isExtendedResponse,\n    type RequestClientOptions,\n    type RequestFunction,\n    type RequestHelperFunction,\n    type RequestOptions,\n    type RequestOptionsMethodInferred,\n    type RequestPromise,\n    type StrictRequestInit,\n    SUPPORTED_METHODS,\n    type SupportedMethods,\n} from '../types/request-client-types.js';\nimport { type RetryOptions, withRetry } from '../utils/with-retry.js';\nimport {\n    HttpError,\n    JsonParseError,\n    NetworkAbortError,\n    NetworkError,\n    NetworkTypeError,\n    RetryableHttpError,\n    UnexpectedResponseBody,\n} from './errors.js';\n\n/**\n * Wrapper for fetch() that coerces appropriate request headers and handles\n * basic response validation.\n *\n *  @throws NetworkError, RetryableHttpError, HttpError, JsonParseError, UnexpectedResponseBody\n */\nasync function baseRequest<T>(\n    makeFetch: (input: string, init: StrictRequestInit, extraData?: T) => Promise<Response>,\n    resource: string,\n    options: RequestOptions<T>\n): Promise<Response> {\n    const { method, extraData, headers, retryableHttpCodes, signal } = options;\n\n    const body: RequestInit['body'] =\n        options.body instanceof Blob || options.body instanceof FormData\n            ? options.body\n            : JSON.stringify(options.body);\n\n    let response: Response;\n\n    try {\n        response = await makeFetch(\n            resource,\n            {\n                method,\n                body,\n                headers: {\n                    'Content-Type': 'application/json',\n\n                    'X-Requested-With': 'XMLHttpRequest',\n                    ...headers,\n                },\n                signal,\n            },\n            extraData\n        );\n    } catch (error) {\n        // Check for AbortErrors and handle explicity (including errors wrapped by unit tests)\n        const ex = error instanceof DOMException ? error : ((error as any).cause as DOMException);\n        if (ex && ex.name === 'AbortError') {\n            throw new NetworkAbortError(resource, options.method);\n        }\n\n        const reshapingTypeErrorEnabled = !isKillSwitchEnabled('wal__reshape_type_error');\n        if (\n            reshapingTypeErrorEnabled && // TypeError can occur from invalid cancellations (i.e. refresh browser, navigate too fast)\n            // A stackoverflow answer has created a table on how this can occur across all browsers. The gist of it\n            // is they all share the same `name` property as `TypeError`\n            // https://stackoverflow.com/questions/55738408/javascript-typeerror-cancelled-error-when-calling-fetch-on-ios\n            // This differs to DOMException, as DomException can be more broad\n            //\n            // Interestingly this could also be a similar symptom to the DOMException above, as TypeMismatchError is now deprecated\n            // https://developer.mozilla.org/en-US/docs/Web/API/DOMException#typemismatcherror\n            error instanceof Error &&\n            error.name === 'TypeError'\n        ) {\n            throw new NetworkTypeError(resource, options.method, error);\n        }\n\n        throw new NetworkError(resource, options.method, navigator.onLine, error);\n    }\n\n    if (!response.ok) {\n        const body = await response.json().catch(() => undefined);\n        if (retryableHttpCodes?.some(code => code === response.status) ?? false) {\n            // Rethrow as a retryable error\n            throw new RetryableHttpError(resource, method, response.status, response, body);\n        }\n        throw new HttpError(resource, method, response.status, response, body);\n    }\n    return response;\n}\n\n/**\n * Returns the same promise returned by fetch() and retries failed requests if they match\n * the retry policy properties set.\n *\n *  @throws NetworkError, RetryableHttpError, HttpError, JsonParseError, UnexpectedResponseBody\n */\nasync function retryWrapper<T>(\n    makeFetch: (input: string, init: StrictRequestInit, extraData?: T) => Promise<Response>,\n    resource: string,\n    options: RequestOptions<T>\n): Promise<Response> {\n    const retryPolicy = options.retryPolicy || {\n        maxAttempts: 1,\n        doRetry: () => false,\n    };\n    const retryCallback = withRetry<Record<string, never>, Response>(retryPolicy);\n    return await retryCallback(async () => await baseRequest(makeFetch, resource, options))();\n}\n\nasync function safeTextParse(response: Response): Promise<string> {\n    try {\n        return await response.clone().text();\n    } catch {\n        return '';\n    }\n}\n\n/**\n * Returns the same promise returned by fetch() with the .json method on the\n * response swapped out for one that takes a type guard.\n *\n *  @throws NetworkError, RetryableHttpError, HttpError, JsonParseError, UnexpectedResponseBody\n */\nasync function guardWrapper<T>(\n    makeFetch: (input: string, init: StrictRequestInit, extraData?: T) => Promise<Response>,\n    resource: string,\n    options: RequestOptions<T>\n): Promise<GuardedJsonResponse> {\n    const { method } = options;\n\n    const next = options.retryPolicy ? retryWrapper : baseRequest;\n\n    let response: Response;\n    try {\n        response = await next(makeFetch, resource, options);\n        if (options.onSuccess && isExtendedResponse(response)) {\n            options.onSuccess(response.requestInfo);\n        }\n    } catch (err) {\n        if (options.onError && err instanceof HttpError && isExtendedResponse(err.response)) {\n            options.onError(err, err.response.requestInfo);\n        }\n        throw err;\n    }\n\n    const responseCopy = response.clone();\n    const originalResponseJson = response.json.bind(response);\n\n    const jsonGuard: Pick<GuardedJsonResponse, 'json'> = {\n        json: async guard => {\n            const body: RequestInit['body'] =\n                options.body instanceof Blob ? options.body : JSON.stringify(options.body);\n\n            const parsedBody = await originalResponseJson().catch(() => {\n                throw new JsonParseError(responseCopy, method, body, safeTextParse(response));\n            });\n\n            const errorContext = new ReportingContext('JsonGuard');\n            if (!guard(parsedBody, errorContext)) {\n                throw new UnexpectedResponseBody(response, method, body, errorContext.errors());\n            }\n\n            return parsedBody;\n        },\n    };\n    // The original response object may contain getters and setters,\n    // so an object spread won't suffice, instead we can do an\n    // object assign over it with the overrides we would like\n    return Object.assign(response, jsonGuard);\n}\n\nfunction createRequestHelperFunction<T>(\n    func: (resource: string, options?: RequestOptions<T>) => RequestPromise,\n    method: SupportedMethods\n) {\n    return (resource: string, options?: RequestOptionsMethodInferred<T>) =>\n        func(resource, {\n            ...options,\n            method,\n        });\n}\n\n/**\n * Adds a bit of sugar to wrappedRequest. These are equivalent:\n *     `wrappedRequest('/').then(response => response.json(guard));`\n *     `request('/').json(guard).`\n */\nconst guardedResponse = (req: Promise<GuardedJsonResponse>): RequestPromise => {\n    return Object.assign(req, {\n        json<V>(guard: Guard<V>): Promise<V> {\n            return req.then(response => response.json(guard));\n        },\n    });\n};\n\nconst mergeRetryPolicy = <T>(\n    defaultOptions: RequestClientOptions,\n    requestOptions: RequestOptions<T>\n): RetryOptions<Record<string, never>, Response> | undefined => {\n    return defaultOptions.retryPolicy || requestOptions.retryPolicy\n        ? {\n              maxAttempts: 3,\n              ...defaultOptions.retryPolicy,\n              ...requestOptions.retryPolicy,\n          }\n        : undefined;\n};\n\nexport function createRequestClient<T = undefined>(\n    makeFetch: (input: string, init: StrictRequestInit, extraData?: T) => Promise<Response>,\n    defaultOptions: RequestClientOptions = {}\n): RequestFunction<T> {\n    // this is the default `request('/').json(guard)` function\n    const defaultFunc = (\n        resource: string,\n        options: RequestOptions<T> = { method: 'GET' }\n    ): RequestPromise => {\n        const response = guardWrapper<T>(makeFetch, resource, {\n            ...defaultOptions,\n            ...options,\n            retryPolicy: mergeRetryPolicy(defaultOptions, options),\n        });\n        return guardedResponse(response);\n    };\n\n    // generates all request.get / .post / etc. helper functions based on SUPPORTED_METHODS\n    const helperFunctions = SUPPORTED_METHODS.reduce<RequestHelperFunction>((prevObj, method) => {\n        const key = method.toLowerCase() as Lowercase<typeof method>;\n        prevObj[key] = createRequestHelperFunction(defaultFunc, method);\n        return prevObj;\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    }, {} as RequestHelperFunction);\n\n    return Object.assign(defaultFunc, helperFunctions);\n}\n","import { createRequestClient } from '../client/request-client.js';\n\ninterface ProgressRequestData {\n    onProgress?: (event: ProgressEvent<any>) => void;\n    responseType?: XMLHttpRequestResponseType;\n    excludeHeaders?: string[];\n}\n\nfunction mapHeaders(headers: string): Record<string, string> {\n    const arr = headers.trim().split(/[\\n\\r]+/);\n\n    // Create a map of header names to values\n    const headerMap: Record<string, string> = {};\n    for (const line of arr) {\n        const parts = line.split(': ');\n        const header = parts.shift();\n        const value = parts.join(': ');\n        if (header !== undefined && header.trim().length > 0) {\n            headerMap[header] = value.trim();\n        }\n    }\n    return headerMap;\n}\n\nfunction getProgressRequestClient() {\n    return createRequestClient<ProgressRequestData>((url, init, extraData) => {\n        const xhr = new XMLHttpRequest();\n        xhr.open(init.method, url, true);\n\n        function onAbort() {\n            xhr.abort();\n        }\n\n        if (extraData?.excludeHeaders) {\n            extraData?.excludeHeaders.forEach(key => {\n                delete init.headers[key];\n            });\n        }\n        for (const [key, value] of Object.entries<string>(init.headers)) {\n            xhr.setRequestHeader(key, value);\n        }\n\n        if (extraData) {\n            if (extraData?.responseType) {\n                xhr.responseType = extraData?.responseType;\n            }\n            if (extraData.onProgress) {\n                if (init.body !== undefined) {\n                    xhr.upload.onprogress = extraData.onProgress;\n                }\n                xhr.onprogress = extraData.onProgress;\n            }\n            if (init.signal) {\n                init.signal.addEventListener('abort', onAbort, { once: true });\n            }\n        }\n\n        return new Promise((resolve, reject) => {\n            xhr.onload = async () => {\n                let response = xhr.response;\n\n                if (extraData?.responseType === 'json') {\n                    response = JSON.stringify(response);\n                }\n\n                init?.signal?.removeEventListener('abort', onAbort);\n\n                return resolve(\n                    new Response(response, {\n                        status: xhr.status,\n                        statusText: xhr.statusText,\n                        headers: mapHeaders(xhr.getAllResponseHeaders()),\n                    })\n                );\n            };\n\n            xhr.onerror = () => {\n                init?.signal?.removeEventListener('abort', onAbort);\n                reject(xhr.statusText);\n            };\n\n            xhr.onabort = () => {\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject('cancelled');\n            };\n\n            if (init?.signal?.aborted) {\n                // eslint-disable-next-line prefer-promise-reject-errors\n                return reject('cancelled');\n            }\n\n            xhr.send(init.body as XMLHttpRequestBodyInit);\n        });\n    });\n}\n\nexport const progressRequest = getProgressRequestClient();\n"],"names":["INIT_COORDS","BEGIN_DRAG","PUBLISH_DRAG_SOURCE","HOVER","DROP","END_DRAG","setClientOffset","clientOffset","sourceClientOffset","type","payload","_typeof","obj","Symbol","iterator","constructor","prototype","isObject","input","ResetCoordinatesAction","createBeginDrag","manager","sourceIds","arguments","length","undefined","options","publishSource","_options$publishSourc","getSourceClientOffset","monitor","getMonitor","registry","getRegistry","dispatch","isDragging","forEach","sourceId","getSource","verifyInvariants","i","canDragSource","getDraggableSource","Error","verifyGetSourceClientOffsetIsFunction","item","beginDrag","verifyItemIsObject","pinSource","itemType","getSourceType","isSourcePublic","createPublishDragSource","matchesType","targetType","draggedItemType","Array","isArray","some","t","createHover","targetIdsArg","verifyTargetIdsIsArray","targetIds","slice","didDrop","targetId","lastIndexOf","target","getTarget","checkInvariants","getTargetType","splice","removeNonMatchingTargetIds","getItemType","hover","hoverAllTargets","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","source","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","value","configurable","writable","createDrop","getTargetIds","canDropOnTarget","reverse","getDroppableTargets","index","dropResult","drop","verifyDropResultType","getDropResult","determineDropResult","action","createEndDrag","verifyIsDragging","getSourceId","endDrag","unpinSource","_defineProperties","props","descriptor","DragDropManagerImpl","store","_this","this","instance","Constructor","TypeError","_classCallCheck","shouldSetUp","getState","refCount","backend","isSetUp","setup","teardown","subscribe","handleRefCountChange","protoProps","staticProps","actions","publishDragSource","createDragDropActions","reduce","boundActions","actionCreator","_len","args","_key","strictEquality","a","b","initialState","initialSourceClientOffset","initialClientOffset","offsetA","offsetB","state","x","y","ADD_SOURCE","ADD_TARGET","REMOVE_SOURCE","REMOVE_TARGET","items","indexOf","NONE","ALL","_action$payload","_action$payload$targe","_action$payload$prevT","prevTargetIds","result","itemsA","itemsB","map","Map","insertItem","set","has","get","count","xor","didChange","isEqual","areArraysEqual","prevInnermostTargetId","innermostTargetId","path","defaultValue","dirtyHandlerIds","split","c","dragOffset","dragOperation","stateId","subtract","__IS_NONE__","__IS_ALL__","HandlerRole","DragDropMonitorImpl","listener","handlerIds","prevStateId","currentStateId","canSkipListener","dirtyIds","areDirty","_this2","previousState","nextState","concat","canDrag","canDrop","Boolean","shallow","nextUniqueId","validateType","allowArray","_slicedToArray","arr","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","call","next","done","err","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","toString","name","from","test","_unsupportedIterableToArray","_nonIterableRest","len","arr2","getNextHandlerId","role","id","SOURCE","TARGET","parseRoleFromHandlerId","handlerId","mapContainsValue","searchValue","entries","isDone","_entries$next","HandlerRegistryImpl","validateSourceContract","addHandler","validateTargetContract","handler","dragSources","dropTargets","includePinned","isSourceId","pinnedSourceId","pinnedSource","isTargetId","types","delete","createDragDropManager","backendFactory","globalContext","backendOptions","debugMode","reduxDevTools","window","__REDUX_DEVTOOLS_EXTENSION__","instanceId","makeStoreInstance","receiveBackend","StatusCodes","FilePointerBlob","file","URL","createObjectURL","size","ReportingContext","children","child","failures","expected","received","childrenErrors","flatMap","errors","e","isReportingContext","val","pushContext","context","getReadableTypeof","Date","RegExp","isDefined","fail","asLiteral","literals","includes","join","asArray","guard","every","v","indexContext","createObjectGuard","shape","validShape","keyContext","isObjectOfShape","getRandomValues","byteToHex","rnds8","Uint8Array","native","randomUUID","crypto","bind","v4","buf","offset","rnds","_a","random","rng","toLowerCase","unsafeStringify","uuid","uuidV4","ErrorWithContext","message","safeToLog","correlationId","properties","isString","isNumber","stack","toEventProperties","errorCode","error","defaultMessage","errorWithContext","JSON","stringify","String","originalError","serialized","fromUnknownError","popStackFrame","stackError","AssertionError","condition","SUPPORTED_METHODS","isExtendedResponse","requestInfo","NetworkError","r","method","online","errorType","resource","NetworkAbortError","NetworkTypeError","HttpError","status","response","body","s","reason","statusText","apiType","resourceId","RetryableHttpError","isRetryableHttpError","JsonParseError","requestBody","url","responseBody","UnexpectedResponseBody","getFlightService","globalFlightService","isKillSwitchEnabled","killSwitch","isEnabled","NonRetryableError","innerError","replaceStackFrame","sleep","timeout","Promise","resolve","retryAsync","fn","kwargs","maxAttempts","backOff","backOffPolicy","exponentialOption","getManualBackOff","doRetry","catch","retried","retryCount","catchHandler","toErrorObject","shouldRetry","newBackOff","multiplier","Math","min","maxInterval","withRetry","originalFn","baseRequest","makeFetch","extraData","headers","retryableHttpCodes","signal","Blob","FormData","ex","DOMException","cause","navigator","onLine","ok","json","code","retryWrapper","retryPolicy","safeTextParse","clone","text","guardWrapper","onSuccess","onError","originalResponseJson","assign","responseCopy","parsedBody","errorContext","mergeRetryPolicy","defaultOptions","requestOptions","createRequestClient","defaultFunc","req","then","guardedResponse","helperFunctions","prevObj","func","createRequestHelperFunction","mapHeaders","trim","headerMap","line","header","parts","shift","progressRequest","init","XMLHttpRequest","onAbort","abort","open","excludeHeaders","setRequestHeader","responseType","xhr","onProgress","onprogress","addEventListener","once","reject","onload","removeEventListener","Response","getAllResponseHeaders","onerror","onabort","aborted","send"],"sourceRoot":""}