{"version":3,"sources":["../../src/utils.js","../../src/MessageChannel/methods/broadcastChannel.js","../../src/MessageChannel/ObliviousSet.js","../../src/MessageChannel/methods/localStorage.js","../../src/MessageChannel/methods/simulate.js","../../src/MessageChannel/methodChooser.js","../../src/MessageChannel/MessageChannel.js","../../src/MessageChannel/leaderElection.js","../../src/TabManager.js","../../src/IdleTimer.js","../../src/useIdleTimer.js","../node_modules/@babel/runtime/helpers/inherits.js","../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","../node_modules/@babel/runtime/helpers/getPrototypeOf.js","../node_modules/@babel/runtime/helpers/asyncToGenerator.js","../node_modules/@babel/runtime/regenerator/index.js","../node_modules/react-toastify/node_modules/classnames/index.js","../node_modules/react-toastify/node_modules/prop-types/factoryWithThrowingShims.js","../node_modules/react-toastify/node_modules/prop-types/lib/ReactPropTypesSecret.js","../node_modules/react-ripples/esm/createRipples.js","../node_modules/react-ripples/esm/withAttrs.js","../node_modules/react-ripples/esm/index.js","../node_modules/react-toastify/node_modules/react-transition-group/esm/config.js","../node_modules/react-toastify/node_modules/react-transition-group/esm/TransitionGroupContext.js","../node_modules/react-toastify/node_modules/react-transition-group/esm/Transition.js","../node_modules/react-toastify/node_modules/react-transition-group/esm/utils/ChildMapping.js","../node_modules/react-toastify/node_modules/react-transition-group/esm/TransitionGroup.js","../node_modules/react-toastify/esm/react-toastify.js","../node_modules/regenerator-runtime/runtime.js","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/react-toastify/node_modules/prop-types/index.js"],"names":["IS_BROWSER","window","DEFAULT_ELEMENT","document","DEFAULT_EVENTS","debounced","fn","delay","timerId","result","args","clearTimeout","setTimeout","cancel","throttled","lastCall","now","Date","getTime","lastMs","additional","microSeconds","ms","randomToken","Math","random","toString","substring","sleep","time","Promise","resolve","create","channelName","state","messagesCallback","bc","BroadcastChannel","onmessage","msg","data","close","channelState","onMessage","postMessage","messageJson","err","reject","canBeUsed","type","averageResponseTime","ObliviousSet","ttl","set","Set","timeMap","Map","value","this","has","add","_removeTooOldValues","clear","olderThen","iterator","Symbol","next","get","getLocalStorage","localStorage","e","addStorageEventListener","key","listener","ev","JSON","parse","newValue","addEventListener","ls","setItem","removeItem","options","Error","uuid","eMIs","removeTimeout","msgObj","token","messagesCallbackTime","removeEventListener","writeObj","stringify","createEvent","initEvent","dispatchEvent","userAgent","navigator","toLowerCase","includes","defaultTime","SIMULATE_CHANNELS","name","Array","from","filter","channel","forEach","METHODS","BroadcastChannelMethod","LocalStorageMethod","chooseMethod","SimulateMethod","method","find","m","useMethod","map","MessageChannel","closed","_isListening","_onMessageListener","_addEventListeners","message","internal","_unSendMessagePromises","_beforeClose","_preparePromises","_prepareChannel","_post","listenObj","_removeListenerObject","_addListenerObject","obj","awaitPrepare","then","all","_this","_state","messageChannel","sendPromise","maybePromise","s","_hasMessageListeners","length","push","listenerFn","o","LeaderElection","_channel","_options","isLeader","isDead","_isApplying","_reApply","_unloadFns","_listeners","_intervals","_duplicateListeners","_duplicateCalled","_onBeforeDie","a","unloadFn","die","stopCriteria","handleMessage","context","_this2","action","_sendMessage","responseTime","leaderElector","isLeaderListener","success","applyOnce","_awaitLeadershipPromise","resolved","finish","clearInterval","interval","whenDeathListener","setInterval","fallbackInterval","onBeforeDie","_this3","uFn","msgJson","postInternal","TabManager","emitOnAllTabs","callbacks","start","reset","pause","resume","elector","_leaderElector","registry","leader","allIdle","awaitLeadership","id","idle","active","onIdle","onActive","isIdle","Object","values","every","v","send","isActive","some","onDuplicate","isAllIdle","setAllIdle","bool","IdleTimer","Component","props","oldDate","lastActive","lastIdle","idleTime","remaining","pageX","pageY","tId","eventsBound","callbackRefs","debounce","throttle","_onAction","onAction","eventsThrottle","handleEvent","_handleEvent","bind","startOnMount","startManually","_toggleIdleState","getRemainingTime","getElapsedTime","getLastActiveTime","getLastIdleTime","getTotalIdleTime","getTotalActiveTime","_setupTabManager","_bindEvents","prevProps","_unbindEvents","timeout","manager","console","error","children","crossTab","assign","element","events","passive","capture","force","setState","prevState","_this4","stopOnIdle","elapsedTimeSinceLastActive","remote","timeLeft","useIdleTimer","useRef","firstLoad","_timeout","emitOnIdle","emitOnActive","emitOnAction","useEffect","current","intermediateOnAction","useMemo","callOnAction","nextIdle","eventsWereBound","propTypes","PropTypes","number","arrayOf","string","func","oneOfType","object","shape","oneOf","defaultProps","setPrototypeOf","module","exports","subClass","superClass","TypeError","prototype","constructor","writable","configurable","defineProperty","__esModule","_typeof","assertThisInitialized","self","call","_getPrototypeOf","getPrototypeOf","__proto__","asyncGeneratorStep","gen","_next","_throw","arg","info","done","arguments","apply","undefined","hasOwn","hasOwnProperty","classNames","classes","i","argType","isArray","inner","join","default","ReactPropTypesSecret","require","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","location","propFullName","secret","getShim","isRequired","ReactPropTypes","array","bigint","symbol","any","elementType","instanceOf","node","objectOf","exact","checkPropTypes","__extends","extendStatics","d","b","p","__","__assign","t","n","__rest","indexOf","getOwnPropertySymbols","propertyIsEnumerable","boxStyle","position","display","overflow","withAttrs","React","createElement","_a","_super","class_1","timer","onClick","during","color","stopPropagation","rect","currentTarget","getBoundingClientRect","left","scrollX","top","scrollY","size","max","width","height","rippleStyle","opacity","transform","transition","backgroundColor","borderRadius","pointerEvents","componentWillUnmount","render","className","trim","style","PureComponent","displayName","createRipples","createContext","Transition","_React$Component","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","status","nextCallback","_inheritsLoose","getDerivedStateFromProps","_ref","_proto","componentDidMount","updateStatus","componentDidUpdate","nextStatus","cancelNextCallback","getTimeouts","exit","mounting","performEnter","performExit","appearing","_ref2","nodeRef","ReactDOM","findDOMNode","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","onExit","onExiting","onExited","nextState","callback","setNextCallback","event","handler","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","_this$props","childProps","_objectWithoutPropertiesLoose","TransitionGroupContext","Provider","cloneElement","Children","only","noop","contextType","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","getChildMapping","mapFn","c","child","isValidElement","mapper","getProp","prop","getNextChildMapping","nextProps","prevChildMapping","nextChildMapping","prev","getValueForKey","nextKeysPending","pendingKeys","prevKey","childMapping","nextKey","pendingNextKey","mergeChildMappings","keys","hasPrev","hasNext","prevChild","isLeaving","k","TransitionGroup","handleExited","_assertThisInitialized","contextValue","firstRender","mounted","currentChildMapping","_extends","component","childFactory","POSITION","TOP_LEFT","TOP_RIGHT","TOP_CENTER","BOTTOM_LEFT","BOTTOM_RIGHT","BOTTOM_CENTER","TYPE","INFO","SUCCESS","WARNING","ERROR","DEFAULT","ACTION","NOOP","isValidDelay","val","isNaN","objectValues","canUseDom","falseOrDelay","eventManager","list","emitQueue","on","off","delete","cancelEmit","timers","emit","_len","_key","cssTransition","_ref$duration","duration","_ref$appendPosition","appendPosition","enterDuration","exitDuration","preventExitTransition","enterClassName","exitClassName","classList","animationFillMode","animationDuration","remove","cssText","ProgressBar","_cx","_animationEvent","isRunning","closeToast","hide","userStyle","controlledProgress","progress","rtl","animationPlayState","cx","RT_NAMESPACE","animationEvent","getX","targetTouches","clientX","getY","clientY","iLoveInternetExplorer","test","Toast","_Component","concat","flag","canCloseOnClick","canDrag","drag","x","y","deltaX","removalDistance","boundingRect","ref","pauseToast","autoClose","playToast","onDragStart","nativeEvent","offsetWidth","draggablePercent","onDragMove","abs","onDragEnd","onDragTransitionEnd","_this$boundingRect","bottom","right","pauseOnHover","onExitTransitionEnd","scrollHeight","requestAnimationFrame","minHeight","padding","margin","onOpen","draggable","bindDragEvents","pauseOnFocusLoss","bindFocusEvents","unbindDragEvents","unbindFocusEvents","onClose","closeButton","closeOnClick","hideProgressBar","bodyClassName","progressClassName","progressStyle","updateId","role","toastProps","onMouseEnter","onMouseLeave","parseFloat","onMouseDown","onTouchStart","onMouseUp","onTouchEnd","CloseButton","ariaLabel","containerId","arialLabel","Bounce","ToastContainer","toast","toastKey","collection","isToastActive","content","buildToast","removeToast","dispatchChange","makeCloseButton","toastClose","toastId","getAutoCloseDelay","toastAutoClose","canBeRendered","parseClassName","belongToContainer","enableMultiContainer","toastOptions","toastClassName","appendToast","staleToastId","_extends2","renderToast","_this5","toastToRender","newestOnTop","reverse","_this5$collection$toa","isDocumentHidden","disablePointer","_this6","containers","latestInstance","containerDomNode","containerConfig","queue","lazy","isAnyContainerMounted","getToast","container","getContainer","mergeOptions","getToastId","generateToastId","substr","dispatchToast","body","appendChild","_loop","warn","warning","dismiss","update","oldOptions","oldContent","nextOptions","onChange","configure","containerInstance","item","removeChild","runtime","Op","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","_invoke","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","isGeneratorFunction","genFun","ctor","mark","awrap","async","iter","pop","skipTempReset","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis","Function"],"mappings":"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","file":"static/js/32.509dd633.chunk.js","sourcesContent":["/**\n * Determine if we are in a browser\n * or a server environment\n * @type {Boolean}\n * @private\n */\nexport const IS_BROWSER =\n  (typeof window === 'undefined' ? 'undefined' : typeof window) === 'object'\n\n/**\n * Default element to listen for events on\n * @type {Object}\n * @private\n */\nexport const DEFAULT_ELEMENT = IS_BROWSER ? document : {}\n\n/**\n * The default events to determine activity\n * @type {Array}\n * @private\n */\nexport const DEFAULT_EVENTS = [\n  'mousemove',\n  'keydown',\n  'wheel',\n  'DOMMouseScroll',\n  'mousewheel',\n  'mousedown',\n  'touchstart',\n  'touchmove',\n  'MSPointerDown',\n  'MSPointerMove',\n  'visibilitychange'\n]\n\n/**\n * Creates a debounced function that delays invoking func until\n * after delay milliseconds has elapsed since the last time the\n * debounced function was invoked.\n * @name debounced\n * @param  {Function} fn   Function to debounce\n * @param  {Number} delay  How long to wait\n * @return {Function}      Executed Function\n * @private\n **/\nexport function debounced (fn, delay) {\n  let timerId\n  function result (...args) {\n    if (timerId) {\n      clearTimeout(timerId)\n    }\n    timerId = setTimeout(() => {\n      fn(...args)\n      timerId = null\n    }, delay)\n  }\n\n  result.cancel = function () {\n    clearTimeout(timerId)\n  }\n\n  return result\n}\n\n/**\n * Creates a throttled function that only invokes func at most\n * once per every wait milliseconds.\n * @name throttled\n * @param  {Function} fn   Function to debounce\n * @param  {Number} delay  How long to wait\n * @return {Function}      Executed Function\n * @private\n **/\nexport function throttled (fn, delay) {\n  let lastCall = 0\n  return function (...args) {\n    const now = new Date().getTime()\n    if (now - lastCall < delay) {\n      return\n    }\n    lastCall = now\n    return fn(...args)\n  }\n}\n\nlet lastMs = 0\nlet additional = 0\n\n/**\n * Returns current time in microseconds.\n *\n * @returns {Number} current time in microseconds\n * @private\n */\nexport function microSeconds () {\n  const ms = new Date().getTime()\n  if (ms === lastMs) {\n    additional++\n    return ms * 1000 + additional\n  } else {\n    lastMs = ms\n    additional = 0\n    return ms * 1000\n  }\n}\n\n/**\n * Generate and return a random token.\n *\n * @returns {String} Random token.\n * @private\n */\nexport function randomToken () {\n  return Math.random().toString(36).substring(2)\n}\n\n/**\n * Checks if a js object is a promise.\n *\n * @param {*} obj  Any javascript object.\n * @returns {Boolean} Wether or not this object is a promise.\n */\nexport function isPromise (obj) {\n  if (obj && typeof obj.then === 'function') {\n    /* istanbul ignore next */\n    return true\n  } else {\n    return false\n  }\n}\n\n/**\n * Sleeps for x amount of milliseconds.\n *\n * @param {Number} time   Amount of time in milliseconds.\n * @returns {Promise}\n * @private\n */\nexport function sleep (time = 0) {\n  return new Promise(resolve => setTimeout(resolve, time))\n}\n\n/**\n * Get the current timestamp.\n *\n * @returns {Number}\n * @private\n */\nexport function now () {\n  return new Date().getTime()\n}\n\n/**\n * Waits until the given function returns true\n * @param  {function}  fn\n * @return {Promise}\n */\nexport function waitUntil (fn, timeout = 0, interval = 20) {\n  let timedOut = false\n  let ok = false\n\n  /* istanbul ignore next */\n  if (timeout !== 0) {\n    sleep(timeout).then(() => {\n      timedOut = true\n    })\n  }\n\n  return new Promise((resolve, reject) => {\n    const runLoop = () => {\n      if (ok) {\n        resolve()\n        return\n      }\n      /* istanbul ignore next */\n      if (timedOut) {\n        reject(new Error(`❌ waitUntil reached timeout of ${timeout}ms`))\n        return\n      }\n      sleep(interval).then(() => {\n        ok = fn()\n        runLoop()\n      })\n    }\n    runLoop()\n  })\n}\n","/* eslint-env browser */\nimport { microSeconds } from '../../utils'\n\nexport const type = 'broadcastChannel'\n\nexport function create (channelName) {\n  const state = {\n    messagesCallback: null,\n    bc: new BroadcastChannel(channelName)\n  }\n\n  state.bc.onmessage = msg => {\n    if (state.messagesCallback) {\n      state.messagesCallback(msg.data)\n    }\n  }\n\n  return state\n}\n\nexport function close (channelState) {\n  channelState.bc.close()\n}\n\nexport function postMessage (channelState, messageJson) {\n  try {\n    channelState.bc.postMessage(messageJson, false)\n    return Promise.resolve()\n  } catch (err) {\n    /* istanbul ignore next */\n    return Promise.reject(err)\n  }\n}\n\nexport function onMessage (channelState, fn) {\n  channelState.messagesCallback = fn\n}\n\nexport function canBeUsed () {\n  if (typeof BroadcastChannel === 'function') {\n    return true\n  } else {\n    /* istanbul ignore next */\n    return false\n  }\n}\n\nexport function averageResponseTime () {\n  return 150\n}\n\nexport default {\n  create,\n  close,\n  onMessage,\n  postMessage,\n  canBeUsed,\n  type,\n  averageResponseTime,\n  microSeconds\n}\n","import { now } from '../utils'\n\nexport default class ObliviousSet {\n  constructor (ttl = 1000 * 60) {\n    this.ttl = ttl\n    this.set = new Set()\n    this.timeMap = new Map()\n  }\n\n  has (value) {\n    return this.set.has(value)\n  }\n\n  add (value) {\n    this.timeMap.set(value, now())\n    this.set.add(value)\n    this._removeTooOldValues()\n  }\n\n  clear () {\n    this.set.clear()\n    this.timeMap.clear()\n  }\n\n  _removeTooOldValues () {\n    const olderThen = now() - this.ttl\n    const iterator = this.set[Symbol.iterator]()\n\n    while (true) {\n      const value = iterator.next().value\n      if (!value) return // no more elements\n      const time = this.timeMap.get(value)\n      if (time < olderThen) {\n        this.timeMap.delete(value)\n        this.set.delete(value)\n      } else {\n        // We reached a value that is not old enough\n        return\n      }\n    }\n  }\n}\n","import ObliviousSet from '../ObliviousSet'\n\nimport {\n  randomToken,\n  microSeconds\n} from '../../utils'\n\nexport const type = 'localStorage'\n\n/**\n * Returns local storage instance\n */\nexport function getLocalStorage () {\n  let localStorage\n  if (typeof window === 'undefined') return null\n  try {\n    localStorage = window.localStorage\n    localStorage = window['ie8-eventlistener/storage'] || window.localStorage\n  } catch (e) {\n    // New versions of Firefox throw a Security exception\n    // if cookies are disabled. See\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1028153\n  }\n  return localStorage\n}\n\nexport function storageKey (channelName) {\n  return channelName\n}\n\n/**\n* writes the new message to the storage\n* and fires the storage-event so other readers can find it\n*/\nexport function postMessage (channelState, messageJson) {\n  return new Promise(resolve => {\n    const key = storageKey(channelState.channelName)\n    const writeObj = {\n      token: randomToken(),\n      time: new Date().getTime(),\n      data: messageJson,\n      uuid: channelState.uuid\n    }\n    const value = JSON.stringify(writeObj)\n    getLocalStorage().setItem(key, value)\n\n    /**\n       * StorageEvent does not fire the 'storage' event\n       * in the window that changes the state of the local storage.\n       * So we fire it manually\n       */\n    const ev = document.createEvent('Event')\n    ev.initEvent('storage', true, true)\n    ev.key = key\n    ev.newValue = value\n    window.dispatchEvent(ev)\n\n    resolve()\n  })\n}\n\nexport function addStorageEventListener (channelName, fn) {\n  const key = storageKey(channelName)\n  const listener = ev => {\n    if (ev.key === key) {\n      fn(JSON.parse(ev.newValue))\n    }\n  }\n  window.addEventListener('storage', listener)\n  return listener\n}\nexport function removeStorageEventListener (listener) {\n  window.removeEventListener('storage', listener)\n}\n\nexport function create (channelName, options = {}) {\n  if (!canBeUsed()) {\n    /* istanbul ignore next */\n    throw new Error('❌ localStorage cannot be used.')\n  }\n\n  const uuid = randomToken()\n\n  /**\n     * eMIs\n     * contains all messages that have been emitted before\n     * @type {ObliviousSet}\n     */\n  const eMIs = new ObliviousSet(options.removeTimeout)\n\n  const state = {\n    channelName,\n    uuid,\n    eMIs // emittedMessagesIds\n  }\n\n  state.listener = addStorageEventListener(\n    channelName,\n    (msgObj) => {\n      if (!state.messagesCallback) return // no listener\n      if (msgObj.uuid === uuid) return // own message\n      if (!msgObj.token || eMIs.has(msgObj.token)) return // already emitted\n      if (msgObj.data.time && msgObj.data.time < state.messagesCallbackTime) return // too old\n\n      eMIs.add(msgObj.token)\n      state.messagesCallback(msgObj.data)\n    }\n  )\n\n  return state\n}\n\nexport function close (channelState) {\n  removeStorageEventListener(channelState.listener)\n}\n\nexport function onMessage (channelState, fn, time) {\n  channelState.messagesCallbackTime = time\n  channelState.messagesCallback = fn\n}\n\nexport function canBeUsed () {\n  const ls = getLocalStorage()\n\n  if (!ls) return false\n\n  try {\n    const key = '__check'\n    ls.setItem(key, 'works')\n    ls.removeItem(key)\n  } catch (e) {\n    // Safari 10 in private mode will not allow write access to local\n    // storage and fail with a QuotaExceededError. See\n    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API#Private_Browsing_Incognito_modes\n\n    /* istanbul ignore next */\n    return false\n  }\n\n  return true\n}\n\n/* istanbul ignore next */\nexport function averageResponseTime () {\n  const defaultTime = 120\n  const userAgent = navigator.userAgent.toLowerCase()\n  if (userAgent.includes('safari') && !userAgent.includes('chrome')) {\n    // safari is much slower so this time is higher\n    return defaultTime * 2\n  }\n  return defaultTime\n}\n\nexport default {\n  create,\n  close,\n  onMessage,\n  postMessage,\n  canBeUsed,\n  type,\n  averageResponseTime,\n  microSeconds\n}\n","import { microSeconds } from '../../utils'\n\nexport const type = 'simulate'\n\nconst SIMULATE_CHANNELS = new Set()\n\nexport function create (channelName) {\n  const state = {\n    name: channelName,\n    messagesCallback: null\n  }\n  SIMULATE_CHANNELS.add(state)\n\n  return state\n}\n\nexport function close (channelState) {\n  SIMULATE_CHANNELS.delete(channelState)\n}\n\nexport function postMessage (channelState, messageJson) {\n  return new Promise(resolve => setTimeout(() => {\n    const channelArray = Array.from(SIMULATE_CHANNELS)\n    channelArray\n      .filter(channel => channel.name === channelState.name)\n      .filter(channel => channel !== channelState)\n      .filter(channel => !!channel.messagesCallback)\n      .forEach(channel => channel.messagesCallback(messageJson))\n    resolve()\n  }, 5))\n}\n\nexport function onMessage (channelState, fn) {\n  channelState.messagesCallback = fn\n}\n\n/* istanbul ignore next */\nexport function canBeUsed () {\n  return true\n}\n\n/* istanbul ignore next */\nexport function averageResponseTime () {\n  return 5\n}\n\nexport default {\n  create,\n  close,\n  onMessage,\n  postMessage,\n  canBeUsed,\n  type,\n  averageResponseTime,\n  microSeconds\n}\n","import BroadcastChannelMethod from './methods/broadcastChannel'\nimport LocalStorageMethod from './methods/localStorage'\nimport SimulateMethod from './methods/simulate'\n\n// Order is important\nconst METHODS = [\n  BroadcastChannelMethod,\n  LocalStorageMethod\n]\n\nexport function chooseMethod (options = {}) {\n  if (options.type) {\n    // For testing\n    if (options.type === 'simulate') {\n      return SimulateMethod\n    }\n\n    // Chosen type\n    const method = METHODS.find(m => m.type === options.type)\n    if (!method) throw new Error(`❌ Method ${options.type} is not supported.`)\n    else return method\n  }\n\n  const useMethod = METHODS.find(method => method.canBeUsed())\n\n  /* istanbul ignore next */\n  if (!useMethod) {\n    throw new Error(`❌ No method found ${JSON.stringify(METHODS.map(m => m.type))}`)\n  }\n  return useMethod\n}\n","import { chooseMethod } from './methodChooser'\nimport { isPromise } from '../utils'\n\nexport class MessageChannel {\n  constructor (name, options = {}) {\n    this.name = name\n    this.options = options\n    this.method = chooseMethod(this.options)\n    this.closed = false\n\n    // isListening\n    this._isListening = false\n\n    /**\n     * _onMessageListener\n     * setting onmessage twice,\n     * will overwrite the first listener\n     */\n    this._onMessageListener = null\n\n    /**\n     * _addEventListeners\n     */\n    this._addEventListeners = {\n      message: [],\n      internal: []\n    }\n\n    /**\n     * Un send message promises\n     * where the sending is still in progress\n     * @type {Set<Promise>}\n     */\n    this._unSendMessagePromises = new Set()\n\n    /**\n     * _beforeClose\n     * array of promises that will be awaited\n     * before the channel is closed\n     */\n    this._beforeClose = []\n\n    /**\n     * _preparePromise\n     */\n    this._preparePromises = null\n    _prepareChannel(this)\n  }\n\n  postMessage (msg) {\n    if (this.closed) {\n      throw new Error(\n        '❌ Cannot post message after channel has closed'\n      )\n    }\n    return _post(this, 'message', msg)\n  }\n\n  postInternal (msg) {\n    return _post(this, 'internal', msg)\n  }\n\n  set onmessage (fn) {\n    const time = this.method.microSeconds()\n    const listenObj = {\n      time,\n      fn\n    }\n    _removeListenerObject(this, 'message', this._onMessageListener)\n    if (fn && typeof fn === 'function') {\n      this._onMessageListener = listenObj\n      _addListenerObject(this, 'message', listenObj)\n    } else {\n      /* istanbul ignore next */\n      this._onMessageListener = null\n    }\n  }\n\n  /* istanbul ignore next */\n  get onmessage () {\n    return this._onMessageListener\n  }\n\n  addEventListener (type, fn) {\n    const time = this.method.microSeconds()\n    const listenObj = {\n      time,\n      fn\n    }\n    _addListenerObject(this, type, listenObj)\n  }\n\n  removeEventListener (type, fn) {\n    const obj = this._addEventListeners[type].find(obj => obj.fn === fn)\n    _removeListenerObject(this, type, obj)\n  }\n\n  close () {\n    if (this.closed) {\n      return\n    }\n    this.closed = true\n    const awaitPrepare = this._preparePromises ? this._preparePromises : Promise.resolve()\n\n    this._onMessageListener = null\n    this._addEventListeners.message = []\n\n    return awaitPrepare\n      // Wait until all current sending are processed\n      .then(() => Promise.all(Array.from(this._unSendMessagePromises)))\n      // Run before-close hooks\n      .then(() => Promise.all(this._beforeClose.map(fn => fn())))\n      // Close the channel\n      .then(() => this.method.close(this._state))\n  }\n\n  get type () {\n    return this.method.type\n  }\n\n  isClosed () {\n    return this.closed\n  }\n}\n\nfunction _post (messageChannel, type, msg) {\n  const time = messageChannel.method.microSeconds()\n  const msgObj = {\n    time,\n    type,\n    data: msg\n  }\n\n  const awaitPrepare = messageChannel._preparePromises ? messageChannel._preparePromises : Promise.resolve()\n  return awaitPrepare.then(() => {\n    const sendPromise = messageChannel.method.postMessage(\n      messageChannel._state,\n      msgObj\n    )\n\n    // add/remove to un-send messages list\n    messageChannel._unSendMessagePromises.add(sendPromise)\n    sendPromise\n      .catch()\n      .then(() => messageChannel._unSendMessagePromises.delete(sendPromise))\n\n    return sendPromise\n  })\n}\n\nfunction _prepareChannel (channel) {\n  const maybePromise = channel.method.create(channel.name, channel.options)\n  /* istanbul ignore next */\n  if (isPromise(maybePromise)) {\n    channel._preparePromises = maybePromise\n    maybePromise.then(s => {\n      channel._state = s\n    })\n  } else {\n    channel._state = maybePromise\n  }\n}\n\nfunction _hasMessageListeners (channel) {\n  if (channel._addEventListeners.message.length > 0) return true\n  if (channel._addEventListeners.internal.length > 0) return true\n  return false\n}\n\nfunction _addListenerObject (channel, type, obj) {\n  channel._addEventListeners[type].push(obj)\n  _startListening(channel)\n}\n\nfunction _removeListenerObject (channel, type, obj) {\n  channel._addEventListeners[type] = channel._addEventListeners[type].filter(o => o !== obj)\n  _stopListening(channel)\n}\n\nfunction _startListening (channel) {\n  if (!channel._isListening && _hasMessageListeners(channel)) {\n    // someone is listening, start subscribing\n\n    const listenerFn = msgObj => {\n      channel._addEventListeners[msgObj.type].forEach(obj => {\n        if (msgObj.time >= obj.time) {\n          obj.fn(msgObj.data)\n        }\n      })\n    }\n\n    const time = channel.method.microSeconds()\n    if (channel._preparePromises) {\n      /* istanbul ignore next */\n      channel._preparePromises.then(() => {\n        channel._isListening = true\n        channel.method.onMessage(\n          channel._state,\n          listenerFn,\n          time\n        )\n      })\n    } else {\n      channel._isListening = true\n      channel.method.onMessage(\n        channel._state,\n        listenerFn,\n        time\n      )\n    }\n  }\n}\n\nfunction _stopListening (channel) {\n  if (channel._isListening && !_hasMessageListeners(channel)) {\n    // no one is listening, stop subscribing\n    channel._isListening = false\n    const time = channel.method.microSeconds()\n    channel.method.onMessage(\n      channel._state,\n      null,\n      time\n    )\n  }\n}\n","import { IS_BROWSER, sleep, randomToken } from '../utils'\n\nclass LeaderElection {\n  constructor (channel, options) {\n    this._channel = channel\n    this._options = options\n\n    this.isLeader = false\n    this.isDead = false\n    this.token = randomToken()\n\n    this._isApplying = false\n    this._reApply = false\n\n    // things to clean up\n    this._unloadFns = []\n    this._listeners = []\n    this._intervals = []\n    this._duplicateListeners = () => { }\n    this._duplicateCalled = false\n    this._onBeforeDie = async () => {}\n\n    const unloadFn = async () => this.die()\n\n    if (IS_BROWSER) {\n      window.addEventListener('beforeUnload', unloadFn)\n      window.addEventListener('unload', unloadFn)\n\n      this._unloadFns.push(['beforeUnload', unloadFn])\n      this._unloadFns.push(['unload', unloadFn])\n    }\n  }\n\n  applyOnce () {\n    if (this.isLeader) return Promise.resolve(false)\n    if (this.isDead) return Promise.resolve(false)\n\n    // do nothing if already running\n    if (this._isApplying) {\n      this._reApply = true\n      return Promise.resolve(false)\n    }\n    this._isApplying = true\n\n    let stopCriteria = false\n    const received = []\n\n    const handleMessage = (msg) => {\n      if (msg.context === 'leader' && msg.token !== this.token) {\n        received.push(msg)\n\n        if (msg.action === 'apply') {\n          // Other is applying\n          if (msg.token > this.token) {\n            // Other has higher token, stop applying\n            stopCriteria = true\n          }\n        }\n\n        if (msg.action === 'tell') {\n          // Other is already leader\n          stopCriteria = true\n        }\n      }\n    }\n    this._channel.addEventListener('internal', handleMessage)\n\n    return _sendMessage(this, 'apply') // send out that this one is applying\n      .then(() => sleep(this._options.responseTime)) // let others time to respond\n      .then(() => {\n        if (stopCriteria) return Promise.reject(new Error())\n        else return _sendMessage(this, 'apply')\n      })\n      .then(() => sleep(this._options.responseTime)) // let others time to respond\n      .then(() => {\n        if (stopCriteria) return Promise.reject(new Error())\n        else return _sendMessage(this)\n      })\n      .then(() => beLeader(this)) // no one disagreed -> this one is now leader\n      .then(() => true)\n      .catch(() => false) // apply not successful\n      .then(success => {\n        this._channel.removeEventListener('internal', handleMessage)\n        this._isApplying = false\n        if (!success && this._reApply) {\n          this._reApply = false\n          return this.applyOnce()\n        } else return success\n      })\n  }\n\n  awaitLeadership () {\n    if (\n      !this._awaitLeadershipPromise\n    ) {\n      this._awaitLeadershipPromise = _awaitLeadershipOnce(this)\n    }\n    return this._awaitLeadershipPromise\n  }\n\n  set onDuplicate (fn) {\n    this._duplicateListeners = fn\n  }\n\n  /* istanbul ignore next */\n  get onDuplicate () {\n    return this._duplicateListeners\n  }\n\n  set onBeforeDie (fn) {\n    this._onBeforeDie = fn\n  }\n\n  /* istanbul ignore next */\n  get onBeforeDie () {\n    return this._onBeforeDie\n  }\n\n  async die () {\n    if (this.isDead) return\n    this.isDead = true\n\n    await this.onBeforeDie()\n    this._listeners.forEach(listener => this._channel.removeEventListener('internal', listener))\n    this._intervals.forEach(interval => clearInterval(interval))\n    this._unloadFns.forEach(uFn => {\n      if (IS_BROWSER) {\n        window.removeEventListener(uFn[0], uFn[1])\n      }\n    })\n    return _sendMessage(this, 'death')\n  }\n}\n\nfunction _awaitLeadershipOnce (leaderElector) {\n  if (leaderElector.isLeader) return Promise.resolve()\n\n  return new Promise(resolve => {\n    let resolved = false\n\n    function finish () {\n      /* istanbul ignore next */\n      if (resolved) {\n        return\n      }\n      resolved = true\n      clearInterval(interval)\n      leaderElector._channel.removeEventListener('internal', whenDeathListener)\n      resolve(true)\n    }\n\n    // try once now\n    leaderElector.applyOnce().then(() => {\n      if (leaderElector.isLeader) {\n        finish()\n      }\n    })\n\n    // try on fallbackInterval\n    const interval = setInterval(() => {\n      /* istanbul ignore next */\n      leaderElector.applyOnce().then(() => {\n        if (leaderElector.isLeader) {\n          finish()\n        }\n      })\n    }, leaderElector._options.fallbackInterval)\n    leaderElector._intervals.push(interval)\n\n    // try when other leader dies\n    const whenDeathListener = msg => {\n      if (msg.context === 'leader' && msg.action === 'death') {\n        leaderElector.applyOnce().then(() => {\n          if (leaderElector.isLeader) finish()\n        })\n      }\n    }\n    leaderElector._channel.addEventListener('internal', whenDeathListener)\n    leaderElector._listeners.push(whenDeathListener)\n  })\n}\n\n/**\n * Sends and internal message over the broadcast-channel\n */\nfunction _sendMessage (leaderElector, action) {\n  const msgJson = {\n    context: 'leader',\n    action,\n    token: leaderElector.token\n  }\n  return leaderElector._channel.postInternal(msgJson)\n}\n\nexport function beLeader (leaderElector) {\n  leaderElector.isLeader = true\n\n  const isLeaderListener = msg => {\n    if (msg.context === 'leader' && msg.action === 'apply') {\n      _sendMessage(leaderElector, 'tell')\n    }\n\n    if (msg.context === 'leader' && msg.action === 'tell' && !leaderElector._duplicateCalled) {\n      /**\n       * Another instance is also leader!\n       * This can happen on rare events\n       * like when the CPU is at 100% for long time\n       * or the tabs are open very long and the browser throttles them.\n       */\n      leaderElector._duplicateCalled = true\n      leaderElector._duplicateListeners() // message the lib user so the app can handle the problem\n      _sendMessage(leaderElector, 'tell') // ensure other leader also knows the problem\n    }\n  }\n  leaderElector._channel.addEventListener('internal', isLeaderListener)\n  leaderElector._listeners.push(isLeaderListener)\n  return _sendMessage(leaderElector, 'tell')\n}\n\nexport function createLeaderElection (channel, options) {\n  if (channel._leaderElector) {\n    throw new Error('❌ MessageChannel already has a leader-elector')\n  }\n\n  const elector = new LeaderElection(channel, options)\n  channel._beforeClose.push(async () => elector.die())\n\n  channel._leaderElector = elector\n  return elector\n}\n","import { MessageChannel, createLeaderElection } from './MessageChannel'\nexport const TabManager = ({\n  type,\n  channelName,\n  fallbackInterval,\n  responseTime,\n  emitOnAllTabs,\n  callbacks,\n  start,\n  reset,\n  pause,\n  resume\n}) => {\n  const channel = new MessageChannel(channelName, { type })\n  const elector = createLeaderElection(channel, { fallbackInterval, responseTime })\n  const registry = {}\n\n  // Register self\n  registry[elector.token] = false\n\n  let leader = false\n  let allIdle = true\n\n  const isLeader = () => leader\n\n  elector.awaitLeadership().then(() => {\n    leader = true\n  })\n\n  channel.addEventListener('message', ([type, id]) => {\n    switch (type) {\n      case 'register':\n        registry[id] = false\n        break\n      case 'deregister':\n        delete registry[id]\n        break\n      case 'idle':\n        idle(id)\n        break\n      case 'active':\n        active(id)\n        break\n      case 'emitIdle':\n        callbacks.onIdle()\n        break\n      case 'emitActive':\n        callbacks.onActive()\n        break\n      case 'start':\n        start(true)\n        break\n      case 'reset':\n        reset(true)\n        break\n      case 'pause':\n        pause(true)\n        break\n      case 'resume':\n        resume(true)\n        break\n      default:\n        // no op\n    }\n  })\n\n  const setAllIdle = bool => {\n    allIdle = bool\n  }\n\n  const isAllIdle = () => allIdle\n\n  const idle = (id = elector.token) => {\n    registry[id] = true\n    const isIdle = Object.values(registry).every(v => v)\n    if (!allIdle && isIdle) {\n      allIdle = true\n      if (isLeader()) {\n        callbacks.onIdle()\n        if (emitOnAllTabs) send('emitIdle')\n      } else {\n        send('idle')\n      }\n    }\n  }\n\n  const active = (id = elector.token) => {\n    registry[id] = false\n    const isActive = Object.values(registry).some(v => !v)\n    if (allIdle && isActive) {\n      allIdle = false\n      if (isLeader()) {\n        callbacks.onActive()\n        if (emitOnAllTabs) send('emitActive')\n      } else {\n        send('active')\n      }\n    }\n  }\n\n  /* istanbul ignore next */\n  elector.onDuplicate = async () => await elector.die()\n  elector.onBeforeDie = async () => await send('deregister')\n\n  const send = async message => channel.postMessage([message, elector.token])\n\n  const close = async () => {\n    await elector.die()\n    await channel.close()\n  }\n\n  // Register self with remote tabs\n  send('register')\n\n  return { close, send, isLeader, idle, active, isAllIdle, setAllIdle }\n}\n","/**\n *  ___    _ _     _____ _\n * |_ _|__| | | __|_   _(_)_ __ ___   ___ _ __\n *  | |/ _` | |/ _ \\| | | | '_ ` _ \\ / _ \\ '__|\n *  | | (_| | |  __/| | | | | | | | |  __/ |\n * |___\\__,_|_|\\___||_| |_|_| |_| |_|\\___|_|\n *\n * @name IdleTimer\n * @author Randy Lebeau\n * @private\n */\n\nimport { Component } from 'react'\nimport PropTypes from 'prop-types'\nimport { TabManager } from './TabManager'\nimport { IS_BROWSER, DEFAULT_ELEMENT, DEFAULT_EVENTS, debounced, throttled } from './utils'\n\n/**\n * Detects when your user is idle\n * @class IdleTimer\n * @private\n */\nclass IdleTimer extends Component {\n  /**\n   * Creates an instance of IdleTimer\n   * bind all of our internal events here\n   * for best performance\n   * @param {Object} props\n   * @return {IdleTimer}\n   * @private\n   */\n  constructor (props) {\n    super(props)\n\n    /**\n     * Sets initial component state\n     * @type {Object}\n     * @private\n     */\n    this.state = {\n      idle: false,\n      oldDate: +new Date(),\n      lastActive: +new Date(),\n      lastIdle: null,\n      idleTime: 0,\n      remaining: null,\n      pageX: null,\n      pageY: null\n    }\n\n    /**\n     * The timer instance\n     * @type {Timeout}\n     * @private\n     */\n    this.tId = null\n\n    /**\n     * Wether or not events are bound\n     * @type {boolean}\n     * @private\n     */\n    this.eventsBound = false\n\n    this.callbackRefs = {}\n\n    // Debounce and throttle can't both be set\n    if (props.debounce > 0 && props.throttle > 0) {\n      throw new Error('onAction can either be throttled or debounced (not both)')\n    }\n\n    // Create debounced action if applicable\n    if (props.debounce > 0) {\n      this._onAction = debounced(props.onAction, props.debounce)\n\n    // Create throttled action if applicable\n    } else if (props.throttle > 0) {\n      this._onAction = throttled(props.onAction, props.throttle)\n\n    // Set custom onAction\n    } else {\n      this._onAction = props.onAction\n    }\n\n    // Create a throttle event handler if applicable\n    if (props.eventsThrottle > 0) {\n      this.handleEvent = throttled(this._handleEvent.bind(this), props.eventsThrottle)\n    } else {\n      this.handleEvent = this._handleEvent.bind(this)\n    }\n\n    // If startOnMount is set, idle state defaults to true\n    if (!props.startOnMount || props.startManually) {\n      this.state.idle = true\n    }\n\n    // Bind all events to component scope, built for speed 🚀\n    this._toggleIdleState = this._toggleIdleState.bind(this)\n    this.start = this.start.bind(this)\n    this.reset = this.reset.bind(this)\n    this.pause = this.pause.bind(this)\n    this.resume = this.resume.bind(this)\n    this.isIdle = this.isIdle.bind(this)\n    this.getRemainingTime = this.getRemainingTime.bind(this)\n    this.getElapsedTime = this.getElapsedTime.bind(this)\n    this.getLastActiveTime = this.getLastActiveTime.bind(this)\n    this.getLastIdleTime = this.getLastIdleTime.bind(this)\n    this.getTotalIdleTime = this.getTotalIdleTime.bind(this)\n    this.getTotalActiveTime = this.getTotalActiveTime.bind(this)\n  }\n\n  /**\n   * Runs once the component has mounted\n   * here we handle automatically starting\n   * the idletimer\n   * @private\n   */\n  componentDidMount () {\n    const { startOnMount, startManually } = this.props\n\n    // Set up cross tab\n    this._setupTabManager()\n\n    if (startManually) return\n    if (startOnMount) {\n      this.start()\n    } else {\n      this._bindEvents()\n    }\n  }\n\n  componentDidUpdate (prevProps) {\n    // Update debounce function\n    if ((prevProps.debounce !== this.props.debounce) && this.props.debounce > 0) {\n      if (this._onAction.cancel) this._onAction.cancel()\n      this._onAction = debounced(this.props.onAction, this.props.debounce)\n    } else\n    // Update throttle function\n    if ((prevProps.throttle !== this.props.throttle) && this.props.throttle > 0) {\n      if (this._onAction.cancel) this._onAction.cancel()\n      this._onAction = throttled(this.props.onAction, this.props.throttle)\n    } else\n    // Remove throttle or debounce\n    if (\n      (prevProps.throttle && this.props.throttle === 0) ||\n      (prevProps.debounce && this.props.debounce === 0)\n    ) {\n      if (this._onAction.cancel) this._onAction.cancel()\n      this._onAction = this.props.onAction\n    }\n\n    // Update event throttle function\n    if (prevProps.eventsThrottle !== this.props.eventsThrottle) {\n      this._unbindEvents()\n      this.handleEvent = throttled(this._handleEvent.bind(this), this.props.eventsThrottle)\n      this._bindEvents()\n    }\n    // Update timeout value\n    if (prevProps.timeout !== this.props.timeout) {\n      if (this.state.idle) this.reset()\n    }\n\n    // Update callback refs\n    if (prevProps.onActive !== this.props.onActive) this.callbackRefs.onActive = this.props.onActive\n    if (prevProps.onIdle !== this.props.onIdle) this.callbackRefs.onIdle = this.props.onIdle\n  }\n\n  /**\n   * Called before the component un-mounts\n   * here we clear the timer and remove\n   * all the event listeners\n   * @private\n   */\n  componentWillUnmount () {\n    // Clear timeout to prevent delayed state changes\n    clearTimeout(this.tId)\n    this._unbindEvents(true)\n    // Cancel any debounced onAction handlers\n    if (this._onAction.cancel) this._onAction.cancel()\n    /* istanbul ignore next */\n    if (this.manager) {\n      this.manager.close().catch(console.error)\n    }\n  }\n\n  /**\n   * Render children if IdleTimer is used as a wrapper\n   * @return {Component} children\n   * @private\n   */\n  render () {\n    const { children } = this.props\n    return children || null\n  }\n\n  /**\n   * Setup the Tab Manager.\n   * @private\n   */\n  _setupTabManager () {\n    const { crossTab, onIdle, onActive } = this.props\n    this.callbackRefs = { onIdle, onActive }\n\n    /* istanbul ignore next */\n    if (crossTab) {\n      const {\n        type,\n        channelName,\n        fallbackInterval,\n        responseTime,\n        emitOnAllTabs\n      } = Object.assign({\n        channelName: 'idle-timer',\n        fallbackInterval: 2000,\n        responseTime: 100,\n        removeTimeout: 1000 * 60,\n        emitOnAllTabs: false\n      }, crossTab === true ? {} : crossTab)\n\n      this.manager = TabManager({\n        type,\n        channelName,\n        fallbackInterval,\n        responseTime,\n        emitOnAllTabs,\n        callbacks: this.callbackRefs,\n        start: this.start,\n        reset: this.reset,\n        pause: this.pause,\n        resume: this.resume\n      })\n    }\n  }\n\n  /**\n   * Binds the specified events\n   * @private\n   */\n  _bindEvents () {\n    // Don't bind events if\n    // we are not in a browser\n    if (!IS_BROWSER) return\n    // Otherwise we bind all the events\n    // to the supplied element\n    const { element, events, passive, capture } = this.props\n    if (!this.eventsBound) {\n      events.forEach(e => {\n        element.addEventListener(e, this.handleEvent, {\n          capture,\n          passive\n        })\n      })\n      this.eventsBound = true\n    }\n  }\n\n  /**\n   * Unbinds all the bound events\n   * @private\n   */\n  _unbindEvents (force = false) {\n    // If we are not in a browser\n    // we don't need to unbind events\n    if (!IS_BROWSER) return\n    // Unbind all events\n    const { element, events, passive, capture } = this.props\n    if (this.eventsBound || force) {\n      events.forEach(e => {\n        element.removeEventListener(e, this.handleEvent, {\n          capture,\n          passive\n        })\n      })\n      this.eventsBound = false\n    }\n  }\n\n  /**\n   * Toggles the idle state and calls\n   * the correct action function\n   * @private\n   */\n  _toggleIdleState (e) {\n    // Fire the appropriate action\n    // and pass the event through\n    // Toggle the idle state\n    this.setState((prevState) => ({\n      idle: !prevState.idle,\n      lastIdle: !prevState.idle ? (+new Date()) - this.props.timeout : prevState.lastIdle,\n      idleTime: prevState.idle ? prevState.idleTime + (+new Date()) - prevState.lastIdle : prevState.idleTime\n    }), () => {\n      const { onActive, onIdle, stopOnIdle } = this.props\n      const { idle } = this.state\n      if (idle) {\n        if (stopOnIdle) {\n          // Clear any existing timeout\n          clearTimeout(this.tId)\n          this.tId = null\n          // Unbind events\n          this._unbindEvents()\n        }\n\n        if (this.manager) {\n          /* istanbul ignore next */\n          this.manager.idle()\n        } else {\n          onIdle(e)\n        }\n      } else {\n        this._bindEvents()\n        if (this.manager) {\n          /* istanbul ignore next */\n          this.manager.active()\n        } else {\n          onActive(e)\n        }\n      }\n    })\n  }\n\n  /**\n   * Event handler for supported event types\n   * @param  {Object} e event object\n   * @private\n   */\n  _handleEvent (e) {\n    const { remaining, pageX, pageY, idle } = this.state\n    const { timeout, stopOnIdle } = this.props\n\n    // Fire onAction event\n    this._onAction(e)\n\n    // Already active, ignore events\n    if (remaining) return\n\n    // Mousemove event\n    if (e.type === 'mousemove') {\n      // If coords are same, it didn't move\n      /* istanbul ignore next */\n      if (e.pageX === pageX && e.pageY === pageY) {\n        return\n      }\n      // If coords don't exist how could it move\n      if (typeof e.pageX === 'undefined' && typeof e.pageY === 'undefined') {\n        return\n      }\n      // Under 200 ms is hard to do\n      // continuous activity will bypass this\n      /* istanbul ignore next */\n      const elapsed = this.getElapsedTime()\n      /* istanbul ignore next */\n      if (elapsed < 200) {\n        return\n      }\n    }\n\n    // Clear any existing timeout\n    clearTimeout(this.tId)\n    this.tId = null\n\n    // Determine last time User was active, as can't rely on setTimeout ticking at the correct interval\n    const elapsedTimeSinceLastActive = +new Date() - this.getLastActiveTime()\n\n    // If the user is idle or last active time is more than timeout, flip the idle state\n    if ((idle && !stopOnIdle) || (!idle && elapsedTimeSinceLastActive > timeout)) {\n      this._toggleIdleState(e)\n    }\n\n    // Store when the user was last active\n    // and update the mouse coordinates\n    this.setState({\n      lastActive: +new Date(),\n      pageX: e.pageX,\n      pageY: e.pageY\n    })\n\n    // If the user is idle and stopOnIdle flag is not set\n    // set a new timeout\n    if (idle) {\n      if (!stopOnIdle) {\n        this.tId = setTimeout(this._toggleIdleState, timeout)\n      }\n    } else {\n      this.tId = setTimeout(this._toggleIdleState, timeout)\n    }\n  }\n\n  /**\n   * Set initial state and start timer\n   * @name start\n   */\n  start (remote = true) {\n    // Clear timeout\n    clearTimeout(this.tId)\n    this.tId = null\n\n    // Bind the events\n    this._bindEvents()\n\n    // Reset state\n    this.setState({\n      idle: false,\n      oldDate: +new Date(),\n      lastActive: +new Date(),\n      remaining: null\n    })\n\n    if (this.manager) {\n      /* istanbul ignore next */\n      this.manager.setAllIdle(false)\n      /* istanbul ignore next */\n      if (!remote && this.props.crossTab.emitOnAllTabs) {\n        this.manager.send('start')\n      }\n    }\n\n    // Set new timeout\n    const { timeout } = this.props\n    this.tId = setTimeout(this._toggleIdleState, timeout)\n  }\n\n  /**\n   * Restore initial state and restart timer, calling onActive\n   * @name reset\n   */\n  reset (remote = false) {\n    // Clear timeout\n    clearTimeout(this.tId)\n    this.tId = null\n\n    // Bind the events\n    this._bindEvents()\n\n    if (this.state.idle) {\n      if (this.manager) {\n        /* istanbul ignore next */\n        this.manager.active()\n      } else {\n        this.props.onActive()\n      }\n    }\n\n    if (this.manager) {\n      /* istanbul ignore next */\n      this.manager.setAllIdle(false)\n      /* istanbul ignore next */\n      if (!remote && this.props.crossTab.emitOnAllTabs) {\n        this.manager.send('reset')\n      }\n    }\n\n    // Reset state\n    this.setState({\n      idle: false,\n      oldDate: +new Date(),\n      lastActive: +new Date(),\n      remaining: null\n    })\n\n    // Set new timeout\n    const { timeout } = this.props\n    this.tId = setTimeout(this._toggleIdleState, timeout)\n  }\n\n  /**\n   * Store remaining time and stop timer\n   * @name pause\n   */\n  pause (remote = false) {\n    // Timer is already paused\n    const { remaining } = this.state\n    if (remaining !== null) return\n\n    // Unbind events\n    this._unbindEvents()\n\n    // Clear existing timeout\n    clearTimeout(this.tId)\n    this.tId = null\n\n    // Send event to other tabs\n    if (this.manager) {\n      /* istanbul ignore next */\n      if (!remote && this.props.crossTab.emitOnAllTabs) {\n        this.manager.send('pause')\n      }\n    }\n\n    // Define how much is left on the timer\n    this.setState({\n      remaining: this.getRemainingTime()\n    })\n  }\n\n  /**\n   * Resumes a paused timer\n   * @name resume\n   */\n  resume (remote = false) {\n    // Timer is not paused\n    const { remaining, idle } = this.state\n    if (remaining === null) return\n\n    // Bind events\n    this._bindEvents()\n\n    // Send event to other tabs\n    if (this.manager) {\n      /* istanbul ignore next */\n      if (!remote && this.props.crossTab.emitOnAllTabs) {\n        this.manager.send('resume')\n      }\n    }\n\n    // Start timer and clear remaining\n    // if we are in the active state\n    if (!idle) {\n      // Set a new timeout\n      this.tId = setTimeout(this._toggleIdleState, remaining)\n      // Set new state\n      this.setState({ remaining: null, lastActive: +new Date() })\n    }\n  }\n\n  /**\n   * Time remaining before idle\n   * @name getRemainingTime\n   * @return {number} Milliseconds remaining\n   */\n  getRemainingTime () {\n    const { remaining, lastActive } = this.state\n    const { timeout } = this.props\n\n    // If idle there is no time remaining\n    if (remaining !== null) {\n      return remaining < 0 ? 0 : remaining\n    }\n\n    // Determine remaining, if negative idle didn't finish flipping, just return 0\n    const timeLeft = timeout - ((+new Date()) - lastActive)\n    return timeLeft < 0 ? 0 : timeLeft\n  }\n\n  /**\n   * How much time has elapsed\n   * @name getElapsedTime\n   * @return {Timestamp}\n   */\n  getElapsedTime () {\n    const { oldDate } = this.state\n    return (+new Date()) - oldDate\n  }\n\n  /**\n   * Last time the user was idle\n   * @name getLastIdleTime\n   * @return {Timestamp}\n   */\n  getLastIdleTime () {\n    const { lastIdle } = this.state\n    return lastIdle\n  }\n\n  /**\n   * Total time the user was idle\n   * @name getTotalIdleTime\n   * @return {number}\n   */\n  getTotalIdleTime () {\n    const { idle, lastIdle, idleTime } = this.state\n    if (idle) {\n      return ((+new Date()) - lastIdle) + idleTime\n    } else {\n      return idleTime\n    }\n  }\n\n  /**\n   * Last time the user was active\n   * @name getLastActiveTime\n   * @return {Timestamp}\n   */\n  getLastActiveTime () {\n    const { lastActive } = this.state\n    return lastActive\n  }\n\n  /**\n   * Total time the user was active\n   * @name getTotalActiveTime\n   * @return {number}\n   */\n  getTotalActiveTime () {\n    return this.getElapsedTime() - this.getTotalIdleTime()\n  }\n\n  /**\n   * Returns wether or not the user is idle\n   * @name isIdle\n   * @return {boolean}\n   */\n  isIdle () {\n    const { idle } = this.state\n    return idle\n  }\n\n  /**\n   * Returns wether or not this is the leader tab\n   * @name isLeader\n   * @return {boolean}\n   */\n  isLeader () {\n    return this.manager ? this.manager.isLeader() : true\n  }\n}\n\n/**\n * Type checks for every property\n * @type {Object}\n * @private\n */\nIdleTimer.propTypes = {\n  /**\n   * Activity Timeout in milliseconds\n   * default: 1200000\n   * @type {Number}\n   */\n  timeout: PropTypes.number,\n  /**\n   * DOM events to listen to\n   * default: see [default events](https://github.com/SupremeTechnopriest/react-idle-timer#default-events)\n   * @type {Array}\n   */\n  events: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * Function to call when user is idle\n   * default: () => {}\n   * @type {Function}\n   */\n  onIdle: PropTypes.func,\n  /**\n   * Function to call when user becomes active\n   * default: () => {}\n   * @type {Function}\n   */\n  onActive: PropTypes.func,\n  /**\n   * Function to call on user actions\n   * default: () => {}\n   * @type {Function}\n   */\n  onAction: PropTypes.func,\n  /**\n   * Debounce the onAction function by setting delay in milliseconds\n   * default: 0\n   * @type {Number}\n   */\n  debounce: PropTypes.number,\n  /**\n   * Throttle the onAction function by setting delay in milliseconds\n   * default: 0\n   * @type {Number}\n   */\n  throttle: PropTypes.number,\n  /**\n   * Throttle the event handler function by setting delay in milliseconds\n   * default: 200\n   * @type {Number}\n   */\n  eventsThrottle: PropTypes.number,\n  /**\n   * Element reference to bind activity listeners to\n   * default: document\n   * @type {Object}\n   */\n  element: PropTypes.oneOfType([PropTypes.object, PropTypes.element]),\n  /**\n   * Start the timer on mount\n   * default: true\n   * @type {Boolean}\n   */\n  startOnMount: PropTypes.bool,\n  /**\n   * Require the timer to be started manually.\n   * default: false\n   * @type {Boolean}\n   */\n  startManually: PropTypes.bool,\n  /**\n   * Once the user goes idle the IdleTimer will not\n   * reset on user input instead, reset() must be\n   * called manually to restart the timer\n   * default: false\n   * @type {Boolean}\n   */\n  stopOnIdle: PropTypes.bool,\n  /**\n   * Bind events passively\n   * default: true\n   * @type {Boolean}\n   */\n  passive: PropTypes.bool,\n  /**\n   * Capture events\n   * default: true\n   * @type {Boolean}\n   */\n  capture: PropTypes.bool,\n  /**\n   * Cross Tab functionality.\n   * default: false\n   * @type {Boolean|Object}\n   */\n  crossTab: PropTypes.oneOfType([\n    PropTypes.bool,\n    PropTypes.shape({\n      type: PropTypes.oneOf(['broadcastChannel', 'localStorage', 'simulate']),\n      channelName: PropTypes.string,\n      fallbackInterval: PropTypes.number,\n      responseTime: PropTypes.number,\n      removeTimeout: PropTypes.number,\n      emitOnAllTabs: PropTypes.bool\n    })\n  ])\n}\n\n/**\n * Sets default property values\n * @type {Object}\n * @private\n */\nIdleTimer.defaultProps = {\n  timeout: 1000 * 60 * 20,\n  element: DEFAULT_ELEMENT,\n  events: DEFAULT_EVENTS,\n  onIdle: () => { },\n  onActive: () => { },\n  onAction: () => { },\n  debounce: 0,\n  throttle: 0,\n  eventsThrottle: 200,\n  startOnMount: true,\n  startManually: false,\n  stopOnIdle: false,\n  capture: true,\n  passive: true,\n  crossTab: false\n}\n\nexport default IdleTimer\n","/**\n *  ___    _ _     _____ _\n * |_ _|__| | | __|_   _(_)_ __ ___   ___ _ __\n *  | |/ _` | |/ _ \\| | | | '_ ` _ \\ / _ \\ '__|\n *  | | (_| | |  __/| | | | | | | | |  __/ |\n * |___\\__,_|_|\\___||_| |_|_| |_| |_|\\___|_|\n *\n * @name useIdleTimer\n * @author Randy Lebeau\n * @private\n */\n\nimport { useEffect, useRef, useMemo } from 'react'\nimport PropTypes from 'prop-types'\nimport { TabManager } from './TabManager'\nimport { IS_BROWSER, DEFAULT_ELEMENT, DEFAULT_EVENTS, debounced, throttled } from './utils'\n\n/**\n * Detects when your user is idle\n * @function useIdleTimer\n * @private\n */\nfunction useIdleTimer ({\n  timeout = 1000 * 60 * 20,\n  element = DEFAULT_ELEMENT,\n  events = DEFAULT_EVENTS,\n  onIdle = () => { },\n  onActive = () => { },\n  onAction = () => { },\n  debounce = 0,\n  throttle = 0,\n  eventsThrottle = 200,\n  startOnMount = true,\n  startManually = false,\n  stopOnIdle = false,\n  capture = true,\n  passive = true,\n  crossTab = false\n} = {}) {\n  const eventsBound = useRef(false)\n  const idle = useRef(true)\n  const oldDate = useRef(+new Date())\n  const remaining = useRef(null)\n  const pageX = useRef(null)\n  const pageY = useRef(null)\n  const tId = useRef(null)\n  const lastActive = useRef(null)\n  const lastIdle = useRef(null)\n  const idleTime = useRef(0)\n  const firstLoad = useRef(true)\n  const _timeout = useRef(timeout)\n  const manager = useRef(null)\n\n  /* istanbul ignore next */\n  if (crossTab) {\n    if (crossTab === true) crossTab = {}\n    crossTab = Object.assign({\n      channelName: 'idle-timer',\n      fallbackInterval: 2000,\n      responseTime: 100,\n      removeTimeout: 1000 * 60,\n      emitOnAllTabs: false\n    }, crossTab)\n  }\n\n  // Event emitters\n  const emitOnIdle = useRef(onIdle)\n  const emitOnActive = useRef(onActive)\n  const emitOnAction = useRef(onAction)\n\n  useEffect(() => {\n    emitOnIdle.current = onIdle\n  }, [onIdle])\n\n  useEffect(() => {\n    emitOnActive.current = onActive\n  }, [onActive])\n\n  useEffect(() => {\n    emitOnAction.current = onAction\n  }, [onAction])\n\n  const intermediateOnAction = useMemo(() => {\n    function callOnAction (e) {\n      emitOnAction.current(e)\n    }\n\n    // Cancel any existing debounce timeouts\n    if (callOnAction.cancel) callOnAction.cancel()\n\n    // Create debounced action if applicable\n    if (debounce > 0) {\n      return debounced(callOnAction, debounce)\n\n      // Create throttled action if applicable\n    } else if (throttle > 0) {\n      return throttled(callOnAction, throttle)\n\n      // No throttle or debounce\n    } else {\n      return callOnAction\n    }\n  }, [throttle, debounce])\n\n  /**\n   * Toggles the idle state and calls\n   * the correct action function\n   * @private\n   */\n  const _toggleIdleState = e => {\n    const nextIdle = !idle.current\n    idle.current = nextIdle\n    if (nextIdle) {\n      if (stopOnIdle) {\n        // Clear any existing timeout\n        clearTimeout(tId.current)\n        tId.current = null\n        // Unbind events\n        _unbindEvents()\n      }\n      lastIdle.current = (+new Date()) - _timeout.current\n      if (manager.current) {\n        /* istanbul ignore next */\n        manager.current.idle()\n      } else {\n        emitOnIdle.current(e)\n      }\n    } else {\n      idleTime.current += (+new Date()) - lastIdle.current\n      _bindEvents()\n      if (manager.current) {\n        /* istanbul ignore next */\n        manager.current.active()\n      } else {\n        emitOnActive.current(e)\n      }\n    }\n  }\n\n  /**\n   * Event handler\n   * @param {Event} e\n   */\n  const _handleEvent = e => {\n    // Fire onAction event\n    intermediateOnAction(e)\n\n    // Already active, ignore events\n    if (remaining.current) return\n\n    // Mousemove event\n    /* istanbul ignore next */\n    if (e.type === 'mousemove') {\n      // If coords are same, it didn't move\n      if (e.pageX === pageX && e.pageY === pageY) {\n        return\n      }\n      // If coords don't exist how could it move\n      if (typeof e.pageX === 'undefined' && typeof e.pageY === 'undefined') {\n        return\n      }\n      // Under 200 ms is hard to do\n      // continuous activity will bypass this\n      const elapsed = getElapsedTime()\n      if (elapsed < 200) {\n        return\n      }\n    }\n\n    // Clear any existing timeout\n    clearTimeout(tId.current)\n    tId.current = null\n\n    // Determine last time User was active, as can't rely on setTimeout ticking at the correct interval\n    const elapsedTimeSinceLastActive = +new Date() - getLastActiveTime()\n\n    // If the user is idle or last active time is more than timeout, flip the idle state\n    if (\n      (idle.current && !stopOnIdle) ||\n      (!idle.current && elapsedTimeSinceLastActive > _timeout.current)\n    ) {\n      _toggleIdleState(e)\n    }\n\n    // Store when the user was last active\n    // and update the mouse coordinates\n    lastActive.current = +new Date()\n    pageX.current = e.pageX\n    pageY.current = e.pageY\n\n    // If the user is active, set a new timeout\n    if (!idle.current) {\n      tId.current = setTimeout(_toggleIdleState, _timeout.current)\n    }\n  }\n\n  /**\n   * Reference to current handleEvent function.\n   * @private\n   */\n  const handleEvent = useRef(_handleEvent)\n\n  /**\n   * Binds the specified events\n   * @private\n   */\n  const _bindEvents = () => {\n    // Don't bind events if\n    // we are not in a browser\n    if (!IS_BROWSER) return\n    // Otherwise we bind all the events\n    // to the supplied element\n    if (!eventsBound.current) {\n      events.forEach(e => {\n        element.addEventListener(e, handleEvent.current, {\n          capture,\n          passive\n        })\n      })\n      eventsBound.current = true\n    }\n  }\n\n  /**\n   * Unbinds all the bound events\n   * @private\n   */\n  const _unbindEvents = (force = false) => {\n    // If we are not in a browser\n    // we don't need to unbind events\n    if (!IS_BROWSER) return\n    // Unbind all events\n    if (eventsBound.current || force) {\n      events.forEach(e => {\n        element.removeEventListener(e, handleEvent.current, {\n          capture,\n          passive\n        })\n      })\n      eventsBound.current = false\n    }\n  }\n\n  /**\n   * Time remaining before idle\n   * @name getRemainingTime\n   * @return {number} Milliseconds remaining\n   */\n  const getRemainingTime = () => {\n    // If idle there is no time remaining\n    if (remaining.current !== null) {\n      return remaining.current < 0 ? 0 : remaining.current\n    }\n\n    // Determine remaining, if negative idle didn't finish flipping, just return 0\n    const timeLeft = _timeout.current - ((+new Date()) - lastActive.current)\n    return timeLeft < 0 ? 0 : timeLeft\n  }\n\n  /**\n   * How much time has elapsed\n   * @name getElapsedTime\n   * @return {Timestamp}\n   */\n  const getElapsedTime = () => (+new Date()) - oldDate.current\n\n  /**\n   * Last time the user was idle\n   * @name getLastIdleTime\n   * @return {Timestamp}\n   */\n  const getLastIdleTime = () => lastIdle.current\n\n  /**\n   * Get the total time user is idle\n   * @name getTotalIdleTime\n   * @return {number} Milliseconds idle\n   */\n  const getTotalIdleTime = () => {\n    if (idle.current) {\n      return ((+new Date()) - lastIdle.current) + idleTime.current\n    } else {\n      return idleTime.current\n    }\n  }\n\n  /**\n   * Last time the user was active\n   * @name getLastActiveTime\n   * @return {Timestamp}\n   */\n  const getLastActiveTime = () => lastActive.current\n\n  /**\n   * Get the total time user is active\n   * @name getTotalActiveTime\n   * @return {number} Milliseconds active\n   */\n  const getTotalActiveTime = () => getElapsedTime() - getTotalIdleTime()\n\n  /**\n   * Returns wether or not the user is idle\n   * @name isIdle\n   * @return {Boolean}\n   */\n  const isIdle = () => idle.current\n\n  /**\n   * Returns wether or not this is the leader tab\n   * @returns {Boolean}\n   */\n  const isLeader = () => manager.current ? manager.current.isLeader() : true\n\n  /**\n  * Set initial state and start timer\n  * @name reset\n  */\n  const start = (remote = false) => {\n    // Clear timeout\n    clearTimeout(tId.current)\n    tId.current = null\n\n    // Bind the events\n    _bindEvents()\n\n    // Set state\n    idle.current = false\n    oldDate.current = +new Date()\n    lastActive.current = +new Date()\n    remaining.current = null\n\n    if (manager.current) {\n      /* istanbul ignore next */\n      manager.current.setAllIdle(false)\n      /* istanbul ignore next */\n      if (!remote && crossTab.emitOnAllTabs) {\n        manager.current.send('start')\n      }\n    }\n\n    // Set new timeout\n    tId.current = setTimeout(_toggleIdleState, _timeout.current)\n  }\n\n  /**\n  * Restore initial state and restart timer, calling onActive\n  * @name reset\n  */\n  const reset = (remote = false) => {\n    // Clear timeout\n    clearTimeout(tId.current)\n    tId.current = null\n\n    // Bind the events\n    _bindEvents()\n\n    // Emit active\n    if (idle.current) {\n      if (manager.current) {\n        /* istanbul ignore next */\n        manager.current.active()\n      } else {\n        emitOnActive.current()\n      }\n    }\n\n    // Reset state\n    idle.current = false\n    oldDate.current = +new Date()\n    lastActive.current = +new Date()\n    remaining.current = null\n\n    if (manager.current) {\n      /* istanbul ignore next */\n      manager.current.setAllIdle(false)\n      /* istanbul ignore next */\n      if (!remote && crossTab.emitOnAllTabs) {\n        manager.current.send('reset')\n      }\n    }\n\n    // Set new timeout\n    tId.current = setTimeout(_toggleIdleState, _timeout.current)\n  }\n\n  /**\n   * Store remaining time and stop timer\n   * @name pause\n   */\n  const pause = (remote = false) => {\n    // Timer is already paused\n    if (remaining.current !== null) return\n\n    // Unbind events\n    _unbindEvents()\n\n    // Clear existing timeout\n    clearTimeout(tId.current)\n    tId.current = null\n\n    // Define how much is left on the timer\n    remaining.current = getRemainingTime()\n\n    if (manager.current) {\n      /* istanbul ignore next */\n      if (!remote && crossTab.emitOnAllTabs) {\n        manager.current.send('pause')\n      }\n    }\n  }\n\n  /**\n   * Resumes a paused timer\n   * @name resume\n   */\n  const resume = (remote = false) => {\n    // Timer is not paused\n    if (remaining.current === null) return\n\n    // Bind events\n    _bindEvents()\n\n    // Start timer and clear remaining\n    // if we are in the idle state\n    if (!idle.current) {\n      // Set a new timeout\n      tId.current = setTimeout(_toggleIdleState, remaining.current)\n      // Set states\n      remaining.current = null\n      lastActive.current = +new Date()\n    }\n\n    if (manager.current) {\n      /* istanbul ignore next */\n      if (!remote && crossTab.emitOnAllTabs) {\n        manager.current.send('resume')\n      }\n    }\n  }\n\n  /**\n   * Hook lifecycle\n   */\n  useEffect(() => {\n    // Debounce and throttle can't both be set\n    if (debounce > 0 && throttle > 0) {\n      throw new Error('onAction can either be throttled or debounced (not both)')\n    }\n\n    // Set up cross tab\n    /* istanbul ignore next */\n    if (crossTab) {\n      manager.current = TabManager({\n        type: crossTab.type,\n        channelName: crossTab.channelName,\n        fallbackInterval: crossTab.fallbackInterval,\n        responseTime: crossTab.responseTime,\n        emitOnAllTabs: crossTab.emitOnAllTabs,\n        callbacks: {\n          onIdle: emitOnIdle.current,\n          onActive: emitOnActive.current\n        },\n        start,\n        reset,\n        pause,\n        resume\n      })\n    }\n\n    // If startOnMount is enabled, start the timer\n    if (startManually) {\n      return async () => {\n        clearTimeout(tId.current)\n        _unbindEvents(true)\n        if (crossTab) await manager.current.close()\n      }\n    }\n\n    if (startOnMount) {\n      start()\n    } else {\n      _bindEvents()\n    }\n\n    // Clear and unbind on unmount\n    return async () => {\n      clearTimeout(tId.current)\n      _unbindEvents(true)\n      if (intermediateOnAction.cancel) intermediateOnAction.cancel()\n      if (crossTab) await manager.current.close()\n    }\n  }, [])\n\n  useEffect(() => {\n    const eventsWereBound = eventsBound.current\n    if (eventsWereBound) _unbindEvents()\n    if (eventsThrottle > 0) {\n      handleEvent.current = throttled(_handleEvent, eventsThrottle)\n    } else {\n      handleEvent.current = _handleEvent\n    }\n    if (eventsWereBound) _bindEvents()\n  }, [eventsThrottle])\n\n  useEffect(() => {\n    _timeout.current = timeout\n    if (!firstLoad.current && idle.current) {\n      reset()\n    }\n    firstLoad.current = false\n  }, [timeout])\n\n  return {\n    isIdle,\n    isLeader,\n    start,\n    pause,\n    reset,\n    resume,\n    getLastIdleTime,\n    getTotalIdleTime,\n    getLastActiveTime,\n    getTotalActiveTime,\n    getElapsedTime,\n    getRemainingTime\n  }\n}\n\n/**\n * Type checks for every property\n * @type {Object}\n * @private\n */\nuseIdleTimer.propTypes = {\n  /**\n   * Activity Timeout in milliseconds\n   * default: 1200000\n   * @type {number}\n   */\n  timeout: PropTypes.number,\n  /**\n   * DOM events to listen to\n   * default: see [default events](https://github.com/SupremeTechnopriest/react-idle-timer#default-events)\n   * @type {Array}\n   */\n  events: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * Function to call when user is idle.\n   * default: () => {}\n   * @type {Function}\n   */\n  onIdle: PropTypes.func,\n  /**\n   * Function to call when user becomes active.\n   * default: () => {}\n   * @type {Function}\n   */\n  onActive: PropTypes.func,\n  /**\n   * Function to call on user actions.\n   * default: () => {}\n   * @type {Function}\n   */\n  onAction: PropTypes.func,\n  /**\n   * Debounce the onAction function by setting delay in milliseconds.\n   * default: 0\n   * @type {number}\n   */\n  debounce: PropTypes.number,\n  /**\n   * Throttle the onAction function by setting delay in milliseconds.\n   * default: 0\n   * @type {number}\n   */\n  throttle: PropTypes.number,\n  /**\n   * Throttle the event handler function by setting delay in milliseconds.\n   * default: 200\n   * @type {number}\n   */\n  eventsThrottle: PropTypes.number,\n  /**\n   * Element reference to bind activity listeners to.\n   * default: document\n   * @type {Object}\n   */\n  element: PropTypes.oneOfType([PropTypes.object, PropTypes.element]),\n  /**\n   * Start the timer on mount.\n   * default: true\n   * @type {Boolean}\n   */\n  startOnMount: PropTypes.bool,\n  /**\n   * Require the timer to be started manually.\n   * default: false\n   * @type {Boolean}\n   */\n  startManually: PropTypes.bool,\n  /**\n   * Once the user goes idle the IdleTimer will not\n   * reset on user input instead, start() or reset() must be\n   * called manually to restart the timer.\n   * default: false\n   * @type {Boolean}\n   */\n  stopOnIdle: PropTypes.bool,\n  /**\n   * Bind events passively.\n   * default: true\n   * @type {Boolean}\n   */\n  passive: PropTypes.bool,\n  /**\n   * Capture events.\n   * default: true\n   * @type {Boolean}\n   */\n  capture: PropTypes.bool,\n  /**\n   * Cross Tab functionality.\n   * default: false\n   * @type {Boolean|Object}\n   */\n  crossTab: PropTypes.oneOfType([\n    PropTypes.bool,\n    PropTypes.shape({\n      type: PropTypes.oneOf(['broadcastChannel', 'localStorage', 'simulate']),\n      channelName: PropTypes.string,\n      fallbackInterval: PropTypes.number,\n      responseTime: PropTypes.number,\n      removeTimeout: PropTypes.number,\n      emitOnAllTabs: PropTypes.bool\n    })\n  ])\n}\n\n/**\n * Sets default property values\n * @type {Object}\n * @private\n */\nuseIdleTimer.defaultProps = {\n  timeout: 1000 * 60 * 20,\n  element: DEFAULT_ELEMENT,\n  events: DEFAULT_EVENTS,\n  onIdle: () => { },\n  onActive: () => { },\n  onAction: () => { },\n  debounce: 0,\n  throttle: 0,\n  eventsThrottle: 200,\n  startOnMount: true,\n  startManually: false,\n  stopOnIdle: false,\n  capture: true,\n  passive: true,\n  crossTab: false\n}\n\nexport default useIdleTimer\n","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\n\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = require(\"regenerator-runtime\");\n","/*!\n  Copyright (c) 2018 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames() {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString === Object.prototype.toString) {\n\t\t\t\t\tfor (var key in arg) {\n\t\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport React from 'react';\nimport PropTypes from 'prop-types';\nvar boxStyle = {\n    position: 'relative',\n    display: 'inline-flex',\n    overflow: 'hidden',\n};\nexport var createRipples = function (defaultProps) {\n    if (defaultProps === void 0) { defaultProps = {}; }\n    var _a;\n    return _a = (function (_super) {\n            __extends(class_1, _super);\n            function class_1(props) {\n                var _this = _super.call(this, props) || this;\n                _this.timer = 0;\n                _this.onClick = function (ev) {\n                    var _a = _this.props, during = _a.during, onClick = _a.onClick, color = _a.color;\n                    ev.stopPropagation();\n                    var pageX = ev.pageX, pageY = ev.pageY, currentTarget = ev.currentTarget;\n                    var rect = currentTarget.getBoundingClientRect();\n                    var left = pageX - (rect.left + window.scrollX);\n                    var top = pageY - (rect.top + window.scrollY);\n                    var size = Math.max(rect.width, rect.height);\n                    _this.setState(function (state) {\n                        return {\n                            rippleStyle: __assign({}, state.rippleStyle, { left: left,\n                                top: top, opacity: 1, transform: 'translate(-50%, -50%)', transition: 'initial', backgroundColor: color }),\n                        };\n                    }, function () {\n                        _this.timer = setTimeout(function () {\n                            _this.setState(function (state) { return ({\n                                rippleStyle: __assign({}, state.rippleStyle, { opacity: 0, transform: \"scale(\" + size / 9 + \")\", transition: \"all \" + during + \"ms\" }),\n                            }); });\n                        }, 50);\n                    });\n                    if (onClick)\n                        onClick(ev);\n                };\n                _this.state = {\n                    rippleStyle: {\n                        position: 'absolute',\n                        borderRadius: '50%',\n                        opacity: 0,\n                        width: 35,\n                        height: 35,\n                        transform: 'translate(-50%, -50%)',\n                        pointerEvents: 'none',\n                    },\n                };\n                return _this;\n            }\n            class_1.prototype.componentWillUnmount = function () {\n                clearTimeout(this.timer);\n            };\n            class_1.prototype.render = function () {\n                var _a = this.props, children = _a.children, during = _a.during, color = _a.color, onClick = _a.onClick, className = _a.className, props = __rest(_a, [\"children\", \"during\", \"color\", \"onClick\", \"className\"]);\n                var rippleStyle = this.state.rippleStyle;\n                return (React.createElement(\"div\", __assign({}, props, { className: (\"react-ripples \" + className).trim(), style: boxStyle, onClick: this.onClick }),\n                    children,\n                    React.createElement(\"s\", { style: rippleStyle })));\n            };\n            return class_1;\n        }(React.PureComponent)),\n        _a.displayName = 'Ripples',\n        _a.propTypes = {\n            during: PropTypes.number,\n            color: PropTypes.string,\n            onClick: PropTypes.func,\n            className: PropTypes.string,\n        },\n        _a.defaultProps = __assign({ during: 600, color: 'rgba(0, 0, 0, .3)', className: '', onClick: function () { } }, defaultProps),\n        _a;\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport React from 'react';\nvar withAttrs = function (Component) { return function (props) { return (React.createElement(Component, __assign({}, props))); }; };\nexport default withAttrs;\n","import { createRipples } from './createRipples';\nimport withAttrs from './withAttrs';\nexport default withAttrs(createRipples());\nexport * from './createRipples';\n","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(null);","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import { Children, cloneElement, isValidElement } from 'react';\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\n\nexport function getChildMapping(children, mapFn) {\n  var mapper = function mapper(child) {\n    return mapFn && isValidElement(child) ? mapFn(child) : child;\n  };\n\n  var result = Object.create(null);\n  if (children) Children.map(children, function (c) {\n    return c;\n  }).forEach(function (child) {\n    // run the map function here instead so that the key is the computed one\n    result[child.key] = mapper(child);\n  });\n  return result;\n}\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\n\nexport function mergeChildMappings(prev, next) {\n  prev = prev || {};\n  next = next || {};\n\n  function getValueForKey(key) {\n    return key in next ? next[key] : prev[key];\n  } // For each key of `next`, the list of keys to insert before that key in\n  // the combined list\n\n\n  var nextKeysPending = Object.create(null);\n  var pendingKeys = [];\n\n  for (var prevKey in prev) {\n    if (prevKey in next) {\n      if (pendingKeys.length) {\n        nextKeysPending[prevKey] = pendingKeys;\n        pendingKeys = [];\n      }\n    } else {\n      pendingKeys.push(prevKey);\n    }\n  }\n\n  var i;\n  var childMapping = {};\n\n  for (var nextKey in next) {\n    if (nextKeysPending[nextKey]) {\n      for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n        var pendingNextKey = nextKeysPending[nextKey][i];\n        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n      }\n    }\n\n    childMapping[nextKey] = getValueForKey(nextKey);\n  } // Finally, add the keys which didn't appear before any key in `next`\n\n\n  for (i = 0; i < pendingKeys.length; i++) {\n    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n  }\n\n  return childMapping;\n}\n\nfunction getProp(child, prop, props) {\n  return props[prop] != null ? props[prop] : child.props[prop];\n}\n\nexport function getInitialChildMapping(props, onExited) {\n  return getChildMapping(props.children, function (child) {\n    return cloneElement(child, {\n      onExited: onExited.bind(null, child),\n      in: true,\n      appear: getProp(child, 'appear', props),\n      enter: getProp(child, 'enter', props),\n      exit: getProp(child, 'exit', props)\n    });\n  });\n}\nexport function getNextChildMapping(nextProps, prevChildMapping, onExited) {\n  var nextChildMapping = getChildMapping(nextProps.children);\n  var children = mergeChildMappings(prevChildMapping, nextChildMapping);\n  Object.keys(children).forEach(function (key) {\n    var child = children[key];\n    if (!isValidElement(child)) return;\n    var hasPrev = (key in prevChildMapping);\n    var hasNext = (key in nextChildMapping);\n    var prevChild = prevChildMapping[key];\n    var isLeaving = isValidElement(prevChild) && !prevChild.props.in; // item is new (entering)\n\n    if (hasNext && (!hasPrev || isLeaving)) {\n      // console.log('entering', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: true,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    } else if (!hasNext && hasPrev && !isLeaving) {\n      // item is old (exiting)\n      // console.log('leaving', key)\n      children[key] = cloneElement(child, {\n        in: false\n      });\n    } else if (hasNext && hasPrev && isValidElement(prevChild)) {\n      // item hasn't changed transition states\n      // copy over the last transition props;\n      // console.log('unchanged', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: prevChild.props.in,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    }\n  });\n  return children;\n}","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { getChildMapping, getInitialChildMapping, getNextChildMapping } from './utils/ChildMapping';\n\nvar values = Object.values || function (obj) {\n  return Object.keys(obj).map(function (k) {\n    return obj[k];\n  });\n};\n\nvar defaultProps = {\n  component: 'div',\n  childFactory: function childFactory(child) {\n    return child;\n  }\n};\n/**\n * The `<TransitionGroup>` component manages a set of transition components\n * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition\n * components, `<TransitionGroup>` is a state machine for managing the mounting\n * and unmounting of components over time.\n *\n * Consider the example below. As items are removed or added to the TodoList the\n * `in` prop is toggled automatically by the `<TransitionGroup>`.\n *\n * Note that `<TransitionGroup>`  does not define any animation behavior!\n * Exactly _how_ a list item animates is up to the individual transition\n * component. This means you can mix and match animations across different list\n * items.\n */\n\nvar TransitionGroup = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(TransitionGroup, _React$Component);\n\n  function TransitionGroup(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n\n    var handleExited = _this.handleExited.bind(_assertThisInitialized(_this)); // Initial children should all be entering, dependent on appear\n\n\n    _this.state = {\n      contextValue: {\n        isMounting: true\n      },\n      handleExited: handleExited,\n      firstRender: true\n    };\n    return _this;\n  }\n\n  var _proto = TransitionGroup.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.mounted = true;\n    this.setState({\n      contextValue: {\n        isMounting: false\n      }\n    });\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.mounted = false;\n  };\n\n  TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {\n    var prevChildMapping = _ref.children,\n        handleExited = _ref.handleExited,\n        firstRender = _ref.firstRender;\n    return {\n      children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),\n      firstRender: false\n    };\n  } // node is `undefined` when user provided `nodeRef` prop\n  ;\n\n  _proto.handleExited = function handleExited(child, node) {\n    var currentChildMapping = getChildMapping(this.props.children);\n    if (child.key in currentChildMapping) return;\n\n    if (child.props.onExited) {\n      child.props.onExited(node);\n    }\n\n    if (this.mounted) {\n      this.setState(function (state) {\n        var children = _extends({}, state.children);\n\n        delete children[child.key];\n        return {\n          children: children\n        };\n      });\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        Component = _this$props.component,\n        childFactory = _this$props.childFactory,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"childFactory\"]);\n\n    var contextValue = this.state.contextValue;\n    var children = values(this.state.children).map(childFactory);\n    delete props.appear;\n    delete props.enter;\n    delete props.exit;\n\n    if (Component === null) {\n      return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n        value: contextValue\n      }, children);\n    }\n\n    return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n      value: contextValue\n    }, /*#__PURE__*/React.createElement(Component, props, children));\n  };\n\n  return TransitionGroup;\n}(React.Component);\n\nTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * `<TransitionGroup>` renders a `<div>` by default. You can change this\n   * behavior by providing a `component` prop.\n   * If you use React v16+ and would like to avoid a wrapping `<div>` element\n   * you can pass in `component={null}`. This is useful if the wrapping div\n   * borks your css styles.\n   */\n  component: PropTypes.any,\n\n  /**\n   * A set of `<Transition>` components, that are toggled `in` and out as they\n   * leave. the `<TransitionGroup>` will inject specific transition props, so\n   * remember to spread them through if you are wrapping the `<Transition>` as\n   * with our `<Fade>` example.\n   *\n   * While this component is meant for multiple `Transition` or `CSSTransition`\n   * children, sometimes you may want to have a single transition child with\n   * content that you want to be transitioned out and in when you change it\n   * (e.g. routes, images etc.) In that case you can change the `key` prop of\n   * the transition child as you change its content, this will cause\n   * `TransitionGroup` to transition the child out and back in.\n   */\n  children: PropTypes.node,\n\n  /**\n   * A convenience prop that enables or disables appear animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables enter animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables exit animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * You may need to apply reactive updates to a child as it is exiting.\n   * This is generally done by using `cloneElement` however in the case of an exiting\n   * child the element has already been removed and not accessible to the consumer.\n   *\n   * If you do need to update a child as it leaves you can provide a `childFactory`\n   * to wrap every child, even the ones that are leaving.\n   *\n   * @type Function(child: ReactElement) -> ReactElement\n   */\n  childFactory: PropTypes.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\nexport default TransitionGroup;","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React, { Component, isValidElement, cloneElement } from 'react';\nimport PropTypes from 'prop-types';\nimport cx from 'classnames';\nimport { Transition, TransitionGroup } from 'react-transition-group';\nimport { render } from 'react-dom';\n\nvar POSITION = {\n  TOP_LEFT: 'top-left',\n  TOP_RIGHT: 'top-right',\n  TOP_CENTER: 'top-center',\n  BOTTOM_LEFT: 'bottom-left',\n  BOTTOM_RIGHT: 'bottom-right',\n  BOTTOM_CENTER: 'bottom-center'\n};\nvar TYPE = {\n  INFO: 'info',\n  SUCCESS: 'success',\n  WARNING: 'warning',\n  ERROR: 'error',\n  DEFAULT: 'default'\n};\nvar ACTION = {\n  SHOW: 0,\n  CLEAR: 1,\n  DID_MOUNT: 2,\n  WILL_UNMOUNT: 3,\n  ON_CHANGE: 4\n};\nvar NOOP = function NOOP() {};\nvar RT_NAMESPACE = 'Toastify';\n\nfunction isValidDelay(val) {\n  return typeof val === 'number' && !isNaN(val) && val > 0;\n}\nfunction objectValues(obj) {\n  return Object.keys(obj).map(function (key) {\n    return obj[key];\n  });\n}\nvar canUseDom = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n\nfunction withRequired(fn) {\n  fn.isRequired = function (props, propName, componentName) {\n    var prop = props[propName];\n\n    if (typeof prop === 'undefined') {\n      return new Error(\"The prop \" + propName + \" is marked as required in \\n      \" + componentName + \", but its value is undefined.\");\n    }\n\n    fn(props, propName, componentName);\n  };\n\n  return fn;\n}\n\nvar falseOrDelay = withRequired(function (props, propName, componentName) {\n  var prop = props[propName];\n\n  if (prop !== false && !isValidDelay(prop)) {\n    return new Error(componentName + \" expect \" + propName + \" \\n      to be a valid Number > 0 or equal to false. \" + prop + \" given.\");\n  }\n\n  return null;\n});\n\nvar eventManager = {\n  list: new Map(),\n  emitQueue: new Map(),\n  on: function on(event, callback) {\n    this.list.has(event) || this.list.set(event, []);\n    this.list.get(event).push(callback);\n    return this;\n  },\n  off: function off(event) {\n    this.list.delete(event);\n    return this;\n  },\n  cancelEmit: function cancelEmit(event) {\n    var timers = this.emitQueue.get(event);\n\n    if (timers) {\n      timers.forEach(function (timer) {\n        return clearTimeout(timer);\n      });\n      this.emitQueue.delete(event);\n    }\n\n    return this;\n  },\n\n  /**\n   * Enqueue the event at the end of the call stack\n   * Doing so let the user call toast as follow:\n   * toast('1')\n   * toast('2')\n   * toast('3')\n   * Without setTimemout the code above will not work\n   */\n  emit: function emit(event) {\n    var _this = this;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    this.list.has(event) && this.list.get(event).forEach(function (callback) {\n      var timer = setTimeout(function () {\n        callback.apply(void 0, args);\n      }, 0);\n      _this.emitQueue.has(event) || _this.emitQueue.set(event, []);\n\n      _this.emitQueue.get(event).push(timer);\n    });\n  }\n};\n\nfunction cssTransition(_ref) {\n  var enter = _ref.enter,\n      exit = _ref.exit,\n      _ref$duration = _ref.duration,\n      duration = _ref$duration === void 0 ? 750 : _ref$duration,\n      _ref$appendPosition = _ref.appendPosition,\n      appendPosition = _ref$appendPosition === void 0 ? false : _ref$appendPosition;\n  return function Animation(_ref2) {\n    var children = _ref2.children,\n        position = _ref2.position,\n        preventExitTransition = _ref2.preventExitTransition,\n        props = _objectWithoutPropertiesLoose(_ref2, [\"children\", \"position\", \"preventExitTransition\"]);\n\n    var enterClassName = appendPosition ? enter + \"--\" + position : enter;\n    var exitClassName = appendPosition ? exit + \"--\" + position : exit;\n    var enterDuration, exitDuration;\n\n    if (Array.isArray(duration) && duration.length === 2) {\n      enterDuration = duration[0];\n      exitDuration = duration[1];\n    } else {\n      enterDuration = exitDuration = duration;\n    }\n\n    var onEnter = function onEnter(node) {\n      node.classList.add(enterClassName);\n      node.style.animationFillMode = 'forwards';\n      node.style.animationDuration = enterDuration * 0.001 + \"s\";\n    };\n\n    var onEntered = function onEntered(node) {\n      node.classList.remove(enterClassName);\n      node.style.cssText = '';\n    };\n\n    var onExit = function onExit(node) {\n      node.classList.add(exitClassName);\n      node.style.animationFillMode = 'forwards';\n      node.style.animationDuration = exitDuration * 0.001 + \"s\";\n    };\n\n    return React.createElement(Transition, _extends({}, props, {\n      timeout: preventExitTransition ? 0 : {\n        enter: enterDuration,\n        exit: exitDuration\n      },\n      onEnter: onEnter,\n      onEntered: onEntered,\n      onExit: preventExitTransition ? NOOP : onExit\n    }), children);\n  };\n}\n\nfunction ProgressBar(_ref) {\n  var _cx, _animationEvent;\n\n  var delay = _ref.delay,\n      isRunning = _ref.isRunning,\n      closeToast = _ref.closeToast,\n      type = _ref.type,\n      hide = _ref.hide,\n      className = _ref.className,\n      userStyle = _ref.style,\n      controlledProgress = _ref.controlledProgress,\n      progress = _ref.progress,\n      rtl = _ref.rtl;\n\n  var style = _extends({}, userStyle, {\n    animationDuration: delay + \"ms\",\n    animationPlayState: isRunning ? 'running' : 'paused',\n    opacity: hide ? 0 : 1,\n    transform: controlledProgress ? \"scaleX(\" + progress + \")\" : null\n  });\n\n  var classNames = cx(RT_NAMESPACE + \"__progress-bar\", controlledProgress ? RT_NAMESPACE + \"__progress-bar--controlled\" : RT_NAMESPACE + \"__progress-bar--animated\", RT_NAMESPACE + \"__progress-bar--\" + type, (_cx = {}, _cx[RT_NAMESPACE + \"__progress-bar--rtl\"] = rtl, _cx), className);\n  var animationEvent = (_animationEvent = {}, _animationEvent[controlledProgress && progress >= 1 ? 'onTransitionEnd' : 'onAnimationEnd'] = controlledProgress && progress < 1 ? null : closeToast, _animationEvent);\n  return React.createElement(\"div\", _extends({\n    className: classNames,\n    style: style\n  }, animationEvent));\n}\n\nProgressBar.propTypes = {\n  /**\n   * The animation delay which determine when to close the toast\n   */\n  delay: falseOrDelay.isRequired,\n\n  /**\n   * Whether or not the animation is running or paused\n   */\n  isRunning: PropTypes.bool.isRequired,\n\n  /**\n   * Func to close the current toast\n   */\n  closeToast: PropTypes.func.isRequired,\n\n  /**\n   * Support rtl content\n   */\n  rtl: PropTypes.bool.isRequired,\n\n  /**\n   * Optional type : info, success ...\n   */\n  type: PropTypes.string,\n\n  /**\n   * Hide or not the progress bar\n   */\n  hide: PropTypes.bool,\n\n  /**\n   * Optionnal className\n   */\n  className: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n\n  /**\n   * Controlled progress value\n   */\n  progress: PropTypes.number,\n\n  /**\n   * Tell wether or not controlled progress bar is used\n   */\n  controlledProgress: PropTypes.bool\n};\nProgressBar.defaultProps = {\n  type: TYPE.DEFAULT,\n  hide: false\n};\n\nfunction getX(e) {\n  return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientX : e.clientX;\n}\n\nfunction getY(e) {\n  return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientY : e.clientY;\n}\n\nvar iLoveInternetExplorer = canUseDom && /(msie|trident)/i.test(navigator.userAgent);\n\nvar Toast =\n/*#__PURE__*/\nfunction (_Component) {\n  _inheritsLoose(Toast, _Component);\n\n  function Toast() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _Component.call.apply(_Component, [this].concat(args)) || this;\n    _this.state = {\n      isRunning: true,\n      preventExitTransition: false\n    };\n    _this.flag = {\n      canCloseOnClick: true,\n      canDrag: false\n    };\n    _this.drag = {\n      start: 0,\n      x: 0,\n      y: 0,\n      deltaX: 0,\n      removalDistance: 0\n    };\n    _this.boundingRect = null;\n    _this.ref = null;\n\n    _this.pauseToast = function () {\n      if (_this.props.autoClose) {\n        _this.setState({\n          isRunning: false\n        });\n      }\n    };\n\n    _this.playToast = function () {\n      if (_this.props.autoClose) {\n        _this.setState({\n          isRunning: true\n        });\n      }\n    };\n\n    _this.onDragStart = function (e) {\n      _this.flag.canCloseOnClick = true;\n      _this.flag.canDrag = true;\n      _this.boundingRect = _this.ref.getBoundingClientRect();\n      _this.ref.style.transition = '';\n      _this.drag.start = _this.drag.x = getX(e.nativeEvent);\n      _this.drag.removalDistance = _this.ref.offsetWidth * (_this.props.draggablePercent / 100);\n    };\n\n    _this.onDragMove = function (e) {\n      if (_this.flag.canDrag) {\n        if (_this.state.isRunning) {\n          _this.pauseToast();\n        }\n\n        _this.drag.x = getX(e);\n        _this.drag.deltaX = _this.drag.x - _this.drag.start;\n        _this.drag.y = getY(e); // prevent false positif during a toast click\n\n        _this.drag.start !== _this.drag.x && (_this.flag.canCloseOnClick = false);\n        _this.ref.style.transform = \"translateX(\" + _this.drag.deltaX + \"px)\";\n        _this.ref.style.opacity = 1 - Math.abs(_this.drag.deltaX / _this.drag.removalDistance);\n      }\n    };\n\n    _this.onDragEnd = function (e) {\n      if (_this.flag.canDrag) {\n        _this.flag.canDrag = false;\n\n        if (Math.abs(_this.drag.deltaX) > _this.drag.removalDistance) {\n          _this.setState({\n            preventExitTransition: true\n          }, _this.props.closeToast);\n\n          return;\n        }\n\n        _this.ref.style.transition = 'transform 0.2s, opacity 0.2s';\n        _this.ref.style.transform = 'translateX(0)';\n        _this.ref.style.opacity = 1;\n      }\n    };\n\n    _this.onDragTransitionEnd = function () {\n      if (_this.boundingRect) {\n        var _this$boundingRect = _this.boundingRect,\n            top = _this$boundingRect.top,\n            bottom = _this$boundingRect.bottom,\n            left = _this$boundingRect.left,\n            right = _this$boundingRect.right;\n\n        if (_this.props.pauseOnHover && _this.drag.x >= left && _this.drag.x <= right && _this.drag.y >= top && _this.drag.y <= bottom) {\n          _this.pauseToast();\n        } else {\n          _this.playToast();\n        }\n      }\n    };\n\n    _this.onExitTransitionEnd = function () {\n      if (iLoveInternetExplorer) {\n        _this.props.onExited();\n\n        return;\n      }\n\n      var height = _this.ref.scrollHeight;\n      var style = _this.ref.style;\n      requestAnimationFrame(function () {\n        style.minHeight = 'initial';\n        style.height = height + 'px';\n        style.transition = 'all 0.4s ';\n        requestAnimationFrame(function () {\n          style.height = 0;\n          style.padding = 0;\n          style.margin = 0;\n        });\n        setTimeout(function () {\n          return _this.props.onExited();\n        }, 400);\n      });\n    };\n\n    return _this;\n  }\n\n  var _proto = Toast.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.props.onOpen(this.props.children.props);\n\n    if (this.props.draggable) {\n      this.bindDragEvents();\n    } // Maybe I could bind the event in the ToastContainer and rely on delegation\n\n\n    if (this.props.pauseOnFocusLoss) {\n      this.bindFocusEvents();\n    }\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (prevProps.draggable !== this.props.draggable) {\n      if (this.props.draggable) {\n        this.bindDragEvents();\n      } else {\n        this.unbindDragEvents();\n      }\n    }\n\n    if (prevProps.pauseOnFocusLoss !== this.props.pauseOnFocusLoss) {\n      if (this.props.pauseOnFocusLoss) {\n        this.bindFocusEvents();\n      } else {\n        this.unbindFocusEvents();\n      }\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.props.onClose(this.props.children.props);\n\n    if (this.props.draggable) {\n      this.unbindDragEvents();\n    }\n\n    if (this.props.pauseOnFocusLoss) {\n      this.unbindFocusEvents();\n    }\n  };\n\n  _proto.bindFocusEvents = function bindFocusEvents() {\n    window.addEventListener('focus', this.playToast);\n    window.addEventListener('blur', this.pauseToast);\n  };\n\n  _proto.unbindFocusEvents = function unbindFocusEvents() {\n    window.removeEventListener('focus', this.playToast);\n    window.removeEventListener('blur', this.pauseToast);\n  };\n\n  _proto.bindDragEvents = function bindDragEvents() {\n    document.addEventListener('mousemove', this.onDragMove);\n    document.addEventListener('mouseup', this.onDragEnd);\n    document.addEventListener('touchmove', this.onDragMove);\n    document.addEventListener('touchend', this.onDragEnd);\n  };\n\n  _proto.unbindDragEvents = function unbindDragEvents() {\n    document.removeEventListener('mousemove', this.onDragMove);\n    document.removeEventListener('mouseup', this.onDragEnd);\n    document.removeEventListener('touchmove', this.onDragMove);\n    document.removeEventListener('touchend', this.onDragEnd);\n  };\n\n  _proto.render = function render() {\n    var _cx,\n        _this2 = this;\n\n    var _this$props = this.props,\n        closeButton = _this$props.closeButton,\n        children = _this$props.children,\n        autoClose = _this$props.autoClose,\n        pauseOnHover = _this$props.pauseOnHover,\n        onClick = _this$props.onClick,\n        closeOnClick = _this$props.closeOnClick,\n        type = _this$props.type,\n        hideProgressBar = _this$props.hideProgressBar,\n        closeToast = _this$props.closeToast,\n        Transition = _this$props.transition,\n        position = _this$props.position,\n        className = _this$props.className,\n        bodyClassName = _this$props.bodyClassName,\n        progressClassName = _this$props.progressClassName,\n        progressStyle = _this$props.progressStyle,\n        updateId = _this$props.updateId,\n        role = _this$props.role,\n        progress = _this$props.progress,\n        rtl = _this$props.rtl;\n    var toastProps = {\n      className: cx(RT_NAMESPACE + \"__toast\", RT_NAMESPACE + \"__toast--\" + type, (_cx = {}, _cx[RT_NAMESPACE + \"__toast--rtl\"] = rtl, _cx), className)\n    };\n\n    if (autoClose && pauseOnHover) {\n      toastProps.onMouseEnter = this.pauseToast;\n      toastProps.onMouseLeave = this.playToast;\n    } // prevent toast from closing when user drags the toast\n\n\n    if (closeOnClick) {\n      toastProps.onClick = function (e) {\n        onClick && onClick(e);\n        _this2.flag.canCloseOnClick && closeToast();\n      };\n    }\n\n    var controlledProgress = parseFloat(progress) === progress;\n    return React.createElement(Transition, {\n      in: this.props.in,\n      appear: true,\n      onExited: this.onExitTransitionEnd,\n      position: position,\n      preventExitTransition: this.state.preventExitTransition\n    }, React.createElement(\"div\", _extends({\n      onClick: onClick\n    }, toastProps, {\n      ref: function ref(_ref) {\n        return _this2.ref = _ref;\n      },\n      onMouseDown: this.onDragStart,\n      onTouchStart: this.onDragStart,\n      onMouseUp: this.onDragTransitionEnd,\n      onTouchEnd: this.onDragTransitionEnd\n    }), React.createElement(\"div\", _extends({}, this.props.in && {\n      role: role\n    }, {\n      className: cx(RT_NAMESPACE + \"__toast-body\", bodyClassName)\n    }), children), closeButton && closeButton, (autoClose || controlledProgress) && React.createElement(ProgressBar, _extends({}, updateId && !controlledProgress ? {\n      key: \"pb-\" + updateId\n    } : {}, {\n      rtl: rtl,\n      delay: autoClose,\n      isRunning: this.state.isRunning,\n      closeToast: closeToast,\n      hide: hideProgressBar,\n      type: type,\n      style: progressStyle,\n      className: progressClassName,\n      controlledProgress: controlledProgress,\n      progress: progress\n    }))));\n  };\n\n  return Toast;\n}(Component);\n\nToast.propTypes = {\n  closeButton: PropTypes.oneOfType([PropTypes.node, PropTypes.bool]).isRequired,\n  autoClose: falseOrDelay.isRequired,\n  children: PropTypes.node.isRequired,\n  closeToast: PropTypes.func.isRequired,\n  position: PropTypes.oneOf(objectValues(POSITION)).isRequired,\n  pauseOnHover: PropTypes.bool.isRequired,\n  pauseOnFocusLoss: PropTypes.bool.isRequired,\n  closeOnClick: PropTypes.bool.isRequired,\n  transition: PropTypes.func.isRequired,\n  rtl: PropTypes.bool.isRequired,\n  hideProgressBar: PropTypes.bool.isRequired,\n  draggable: PropTypes.bool.isRequired,\n  draggablePercent: PropTypes.number.isRequired,\n  in: PropTypes.bool,\n  onExited: PropTypes.func,\n  onOpen: PropTypes.func,\n  onClose: PropTypes.func,\n  type: PropTypes.oneOf(objectValues(TYPE)),\n  className: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n  bodyClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n  progressClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n  progressStyle: PropTypes.object,\n  progress: PropTypes.number,\n  updateId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),\n  ariaLabel: PropTypes.string,\n  containerId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),\n  role: PropTypes.string\n};\nToast.defaultProps = {\n  type: TYPE.DEFAULT,\n  in: true,\n  onOpen: NOOP,\n  onClose: NOOP,\n  className: null,\n  bodyClassName: null,\n  progressClassName: null,\n  updateId: null\n};\n\nfunction CloseButton(_ref) {\n  var closeToast = _ref.closeToast,\n      type = _ref.type,\n      ariaLabel = _ref.ariaLabel;\n  return React.createElement(\"button\", {\n    className: RT_NAMESPACE + \"__close-button \" + RT_NAMESPACE + \"__close-button--\" + type,\n    type: \"button\",\n    onClick: function onClick(e) {\n      e.stopPropagation();\n      closeToast(e);\n    },\n    \"aria-label\": ariaLabel\n  }, \"\\u2716\\uFE0E\");\n}\n\nCloseButton.propTypes = {\n  closeToast: PropTypes.func,\n  arialLabel: PropTypes.string\n};\nCloseButton.defaultProps = {\n  ariaLabel: 'close'\n};\n\nvar Bounce = cssTransition({\n  enter: RT_NAMESPACE + \"__bounce-enter\",\n  exit: RT_NAMESPACE + \"__bounce-exit\",\n  appendPosition: true\n});\nvar Slide = cssTransition({\n  enter: RT_NAMESPACE + \"__slide-enter\",\n  exit: RT_NAMESPACE + \"__slide-exit\",\n  duration: [450, 750],\n  appendPosition: true\n});\nvar Zoom = cssTransition({\n  enter: RT_NAMESPACE + \"__zoom-enter\",\n  exit: RT_NAMESPACE + \"__zoom-exit\"\n});\nvar Flip = cssTransition({\n  enter: RT_NAMESPACE + \"__flip-enter\",\n  exit: RT_NAMESPACE + \"__flip-exit\"\n});\n\nvar ToastContainer =\n/*#__PURE__*/\nfunction (_Component) {\n  _inheritsLoose(ToastContainer, _Component);\n\n  function ToastContainer() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _Component.call.apply(_Component, [this].concat(args)) || this;\n    _this.state = {\n      toast: []\n    };\n    _this.toastKey = 1;\n    _this.collection = {};\n\n    _this.isToastActive = function (id) {\n      return _this.state.toast.indexOf(id) !== -1;\n    };\n\n    return _this;\n  }\n\n  var _proto = ToastContainer.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    var _this2 = this;\n\n    eventManager.cancelEmit(ACTION.WILL_UNMOUNT).on(ACTION.SHOW, function (content, options) {\n      return _this2.ref ? _this2.buildToast(content, options) : null;\n    }).on(ACTION.CLEAR, function (id) {\n      return !_this2.ref ? null : id == null ? _this2.clear() : _this2.removeToast(id);\n    }).emit(ACTION.DID_MOUNT, this);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    eventManager.emit(ACTION.WILL_UNMOUNT, this);\n  };\n\n  _proto.removeToast = function removeToast(id) {\n    this.setState({\n      toast: this.state.toast.filter(function (v) {\n        return v !== id;\n      })\n    }, this.dispatchChange);\n  };\n\n  _proto.dispatchChange = function dispatchChange() {\n    eventManager.emit(ACTION.ON_CHANGE, this.state.toast.length, this.props.containerId);\n  };\n\n  _proto.makeCloseButton = function makeCloseButton(toastClose, toastId, type) {\n    var _this3 = this;\n\n    var closeButton = this.props.closeButton;\n\n    if (isValidElement(toastClose) || toastClose === false) {\n      closeButton = toastClose;\n    } else if (toastClose === true) {\n      closeButton = this.props.closeButton && typeof this.props.closeButton !== 'boolean' ? this.props.closeButton : React.createElement(CloseButton, null);\n    }\n\n    return closeButton === false ? false : cloneElement(closeButton, {\n      closeToast: function closeToast() {\n        return _this3.removeToast(toastId);\n      },\n      type: type\n    });\n  };\n\n  _proto.getAutoCloseDelay = function getAutoCloseDelay(toastAutoClose) {\n    return toastAutoClose === false || isValidDelay(toastAutoClose) ? toastAutoClose : this.props.autoClose;\n  };\n\n  _proto.canBeRendered = function canBeRendered(content) {\n    return isValidElement(content) || typeof content === 'string' || typeof content === 'number' || typeof content === 'function';\n  };\n\n  _proto.parseClassName = function parseClassName(prop) {\n    if (typeof prop === 'string') {\n      return prop;\n    } else if (prop !== null && typeof prop === 'object' && 'toString' in prop) {\n      return prop.toString();\n    }\n\n    return null;\n  };\n\n  _proto.belongToContainer = function belongToContainer(_ref) {\n    var containerId = _ref.containerId;\n    return containerId === this.props.containerId;\n  };\n\n  _proto.buildToast = function buildToast(content, _ref2) {\n    var _this4 = this;\n\n    var delay = _ref2.delay,\n        options = _objectWithoutPropertiesLoose(_ref2, [\"delay\"]);\n\n    if (!this.canBeRendered(content)) {\n      throw new Error(\"The element you provided cannot be rendered. You provided an element of type \" + typeof content);\n    }\n\n    var toastId = options.toastId,\n        updateId = options.updateId; // Check for multi-container and also for duplicate toastId\n    // Maybe it would be better to extract it\n\n    if (this.props.enableMultiContainer && !this.belongToContainer(options) || this.isToastActive(toastId) && updateId == null) {\n      return;\n    }\n\n    var closeToast = function closeToast() {\n      return _this4.removeToast(toastId);\n    };\n\n    var toastOptions = {\n      id: toastId,\n      // ⚠️ if no options.key, this.toastKey - 1 is assigned\n      key: options.key || this.toastKey++,\n      type: options.type,\n      closeToast: closeToast,\n      updateId: options.updateId,\n      rtl: this.props.rtl,\n      position: options.position || this.props.position,\n      transition: options.transition || this.props.transition,\n      className: this.parseClassName(options.className || this.props.toastClassName),\n      bodyClassName: this.parseClassName(options.bodyClassName || this.props.bodyClassName),\n      onClick: options.onClick || this.props.onClick,\n      closeButton: this.makeCloseButton(options.closeButton, toastId, options.type),\n      pauseOnHover: typeof options.pauseOnHover === 'boolean' ? options.pauseOnHover : this.props.pauseOnHover,\n      pauseOnFocusLoss: typeof options.pauseOnFocusLoss === 'boolean' ? options.pauseOnFocusLoss : this.props.pauseOnFocusLoss,\n      draggable: typeof options.draggable === 'boolean' ? options.draggable : this.props.draggable,\n      draggablePercent: typeof options.draggablePercent === 'number' && !isNaN(options.draggablePercent) ? options.draggablePercent : this.props.draggablePercent,\n      closeOnClick: typeof options.closeOnClick === 'boolean' ? options.closeOnClick : this.props.closeOnClick,\n      progressClassName: this.parseClassName(options.progressClassName || this.props.progressClassName),\n      progressStyle: this.props.progressStyle,\n      autoClose: this.getAutoCloseDelay(options.autoClose),\n      hideProgressBar: typeof options.hideProgressBar === 'boolean' ? options.hideProgressBar : this.props.hideProgressBar,\n      progress: parseFloat(options.progress),\n      role: typeof options.role === 'string' ? options.role : this.props.role\n    };\n    typeof options.onOpen === 'function' && (toastOptions.onOpen = options.onOpen);\n    typeof options.onClose === 'function' && (toastOptions.onClose = options.onClose); // add closeToast function to react component only\n\n    if (isValidElement(content) && typeof content.type !== 'string' && typeof content.type !== 'number') {\n      content = cloneElement(content, {\n        closeToast: closeToast\n      });\n    } else if (typeof content === 'function') {\n      content = content({\n        closeToast: closeToast\n      });\n    }\n\n    if (isValidDelay(delay)) {\n      setTimeout(function () {\n        _this4.appendToast(toastOptions, content, options.staleToastId);\n      }, delay);\n    } else {\n      this.appendToast(toastOptions, content, options.staleToastId);\n    }\n  };\n\n  _proto.appendToast = function appendToast(options, content, staleToastId) {\n    var _extends2;\n\n    var id = options.id,\n        updateId = options.updateId;\n    this.collection = _extends({}, this.collection, (_extends2 = {}, _extends2[id] = {\n      options: options,\n      content: content,\n      position: options.position\n    }, _extends2));\n    this.setState({\n      toast: (updateId ? [].concat(this.state.toast) : [].concat(this.state.toast, [id])).filter(function (id) {\n        return id !== staleToastId;\n      })\n    }, this.dispatchChange);\n  };\n\n  _proto.clear = function clear() {\n    this.setState({\n      toast: []\n    });\n  };\n\n  _proto.renderToast = function renderToast() {\n    var _this5 = this;\n\n    var toastToRender = {};\n    var _this$props = this.props,\n        className = _this$props.className,\n        style = _this$props.style,\n        newestOnTop = _this$props.newestOnTop;\n    var collection = newestOnTop ? Object.keys(this.collection).reverse() : Object.keys(this.collection); // group toast by position\n\n    collection.forEach(function (toastId) {\n      var _this5$collection$toa = _this5.collection[toastId],\n          position = _this5$collection$toa.position,\n          options = _this5$collection$toa.options,\n          content = _this5$collection$toa.content;\n      toastToRender[position] || (toastToRender[position] = []);\n\n      if (_this5.state.toast.indexOf(options.id) !== -1) {\n        toastToRender[position].push(React.createElement(Toast, _extends({}, options, {\n          isDocumentHidden: _this5.state.isDocumentHidden,\n          key: \"toast-\" + options.key\n        }), content));\n      } else {\n        toastToRender[position].push(null);\n        delete _this5.collection[toastId];\n      }\n    });\n    return Object.keys(toastToRender).map(function (position) {\n      var _cx;\n\n      var disablePointer = toastToRender[position].length === 1 && toastToRender[position][0] === null;\n      var props = {\n        className: cx(RT_NAMESPACE + \"__toast-container\", RT_NAMESPACE + \"__toast-container--\" + position, (_cx = {}, _cx[RT_NAMESPACE + \"__toast-container--rtl\"] = _this5.props.rtl, _cx), _this5.parseClassName(className)),\n        style: disablePointer ? _extends({}, style, {\n          pointerEvents: 'none'\n        }) : _extends({}, style)\n      };\n      return React.createElement(TransitionGroup, _extends({}, props, {\n        key: \"container-\" + position\n      }), toastToRender[position]);\n    });\n  };\n\n  _proto.render = function render() {\n    var _this6 = this;\n\n    return React.createElement(\"div\", {\n      ref: function ref(node) {\n        return _this6.ref = node;\n      },\n      className: \"\" + RT_NAMESPACE\n    }, this.renderToast());\n  };\n\n  return ToastContainer;\n}(Component);\n\nToastContainer.propTypes = {\n  /**\n   * Set toast position\n   */\n  position: PropTypes.oneOf(objectValues(POSITION)),\n\n  /**\n   * Disable or set autoClose delay\n   */\n  autoClose: falseOrDelay,\n\n  /**\n   * Disable or set a custom react element for the close button\n   */\n  closeButton: PropTypes.oneOfType([PropTypes.node, PropTypes.bool]),\n\n  /**\n   * Hide or not progress bar when autoClose is enabled\n   */\n  hideProgressBar: PropTypes.bool,\n\n  /**\n   * Pause toast duration on hover\n   */\n  pauseOnHover: PropTypes.bool,\n\n  /**\n   * Dismiss toast on click\n   */\n  closeOnClick: PropTypes.bool,\n\n  /**\n   * Newest on top\n   */\n  newestOnTop: PropTypes.bool,\n\n  /**\n   * An optional className\n   */\n  className: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n\n  /**\n   * An optional style\n   */\n  style: PropTypes.object,\n\n  /**\n   * An optional className for the toast\n   */\n  toastClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n\n  /**\n   * An optional className for the toast body\n   */\n  bodyClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n\n  /**\n   * An optional className for the toast progress bar\n   */\n  progressClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n\n  /**\n   * An optional style for the toast progress bar\n   */\n  progressStyle: PropTypes.object,\n\n  /**\n   * Define enter and exit transition using react-transition-group\n   */\n  transition: PropTypes.func,\n\n  /**\n   * Support rtl display\n   */\n  rtl: PropTypes.bool,\n\n  /**\n   * Allow toast to be draggable\n   */\n  draggable: PropTypes.bool,\n\n  /**\n   * The percentage of the toast's width it takes for a drag to dismiss a toast\n   */\n  draggablePercent: PropTypes.number,\n\n  /**\n   * Pause the toast on focus loss\n   */\n  pauseOnFocusLoss: PropTypes.bool,\n\n  /**\n   * Show the toast only if it includes containerId and it's the same as containerId\n   */\n  enableMultiContainer: PropTypes.bool,\n\n  /**\n   * Set id to handle multiple container\n   */\n  containerId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),\n\n  /**\n   * Set role attribute for the toast body\n   */\n  role: PropTypes.string,\n\n  /**\n   * Fired when clicking inside toaster\n   */\n  onClick: PropTypes.func\n};\nToastContainer.defaultProps = {\n  position: POSITION.TOP_RIGHT,\n  transition: Bounce,\n  rtl: false,\n  autoClose: 5000,\n  hideProgressBar: false,\n  closeButton: React.createElement(CloseButton, null),\n  pauseOnHover: true,\n  pauseOnFocusLoss: true,\n  closeOnClick: true,\n  newestOnTop: false,\n  draggable: true,\n  draggablePercent: 80,\n  className: null,\n  style: null,\n  toastClassName: null,\n  bodyClassName: null,\n  progressClassName: null,\n  progressStyle: null,\n  role: 'alert'\n};\n\nvar containers = new Map();\nvar latestInstance = null;\nvar containerDomNode = null;\nvar containerConfig = {};\nvar queue = [];\nvar lazy = false;\n/**\n * Check whether any container is currently mounted in the DOM\n */\n\nfunction isAnyContainerMounted() {\n  return containers.size > 0;\n}\n/**\n * Get the container by id. Returns the last container declared when no id is given.\n */\n\n\nfunction getContainer(containerId) {\n  if (!isAnyContainerMounted()) return null;\n  if (!containerId) return containers.get(latestInstance);\n  return containers.get(containerId);\n}\n/**\n * Get the toast by id, given it's in the DOM, otherwise returns null\n */\n\n\nfunction getToast(toastId, _ref) {\n  var containerId = _ref.containerId;\n  var container = getContainer(containerId);\n  if (!container) return null;\n  var toast = container.collection[toastId];\n  if (typeof toast === 'undefined') return null;\n  return toast;\n}\n/**\n * Merge provided options with the defaults settings and generate the toastId\n */\n\n\nfunction mergeOptions(options, type) {\n  return _extends({}, options, {\n    type: type,\n    toastId: getToastId(options)\n  });\n}\n/**\n * Generate a random toastId\n */\n\n\nfunction generateToastId() {\n  return (Math.random().toString(36) + Date.now().toString(36)).substr(2, 10);\n}\n/**\n * Generate a toastId or use the one provided\n */\n\n\nfunction getToastId(options) {\n  if (options && (typeof options.toastId === 'string' || typeof options.toastId === 'number' && !isNaN(options.toastId))) {\n    return options.toastId;\n  }\n\n  return generateToastId();\n}\n/**\n * If the container is not mounted, the toast is enqueued and\n * the container lazy mounted\n */\n\n\nfunction dispatchToast(content, options) {\n  if (isAnyContainerMounted()) {\n    eventManager.emit(ACTION.SHOW, content, options);\n  } else {\n    queue.push({\n      action: ACTION.SHOW,\n      content: content,\n      options: options\n    });\n\n    if (lazy && canUseDom) {\n      lazy = false;\n      containerDomNode = document.createElement('div');\n      document.body.appendChild(containerDomNode);\n      render(React.createElement(ToastContainer, containerConfig), containerDomNode);\n    }\n  }\n\n  return options.toastId;\n}\n\nvar toast = function toast(content, options) {\n  return dispatchToast(content, mergeOptions(options, options && options.type || TYPE.DEFAULT));\n};\n/**\n * For each available type create a shortcut\n */\n\n\nvar _loop = function _loop(t) {\n  if (TYPE[t] !== TYPE.DEFAULT) {\n    toast[TYPE[t].toLowerCase()] = function (content, options) {\n      return dispatchToast(content, mergeOptions(options, options && options.type || TYPE[t]));\n    };\n  }\n};\n\nfor (var t in TYPE) {\n  _loop(t);\n}\n/**\n * Maybe I should remove warning in favor of warn, I don't know\n */\n\n\ntoast.warn = toast.warning;\n/**\n * Remove toast programmaticaly\n */\n\ntoast.dismiss = function (id) {\n  if (id === void 0) {\n    id = null;\n  }\n\n  return isAnyContainerMounted() && eventManager.emit(ACTION.CLEAR, id);\n};\n/**\n * return true if one container is displaying the toast\n */\n\n\ntoast.isActive = function (id) {\n  var isToastActive = false;\n\n  if (containers.size > 0) {\n    containers.forEach(function (container) {\n      if (container.isToastActive(id)) {\n        isToastActive = true;\n      }\n    });\n  }\n\n  return isToastActive;\n};\n\ntoast.update = function (toastId, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  // if you call toast and toast.update directly nothing will be displayed\n  // this is why I defered the update\n  setTimeout(function () {\n    var toast = getToast(toastId, options);\n\n    if (toast) {\n      var oldOptions = toast.options,\n          oldContent = toast.content;\n\n      var nextOptions = _extends({}, oldOptions, {}, options, {\n        toastId: options.toastId || toastId\n      });\n\n      if (!options.toastId || options.toastId === toastId) {\n        nextOptions.updateId = generateToastId();\n      } else {\n        nextOptions.staleToastId = toastId;\n      }\n\n      var content = typeof nextOptions.render !== 'undefined' ? nextOptions.render : oldContent;\n      delete nextOptions.render;\n      dispatchToast(content, nextOptions);\n    }\n  }, 0);\n};\n/**\n * Used for controlled progress bar.\n */\n\n\ntoast.done = function (id) {\n  toast.update(id, {\n    progress: 1\n  });\n};\n/**\n * Track changes. The callback get the number of toast displayed\n */\n\n\ntoast.onChange = function (callback) {\n  if (typeof callback === 'function') {\n    eventManager.on(ACTION.ON_CHANGE, callback);\n  }\n};\n/**\n * Configure the ToastContainer when lazy mounted\n */\n\n\ntoast.configure = function (config) {\n  lazy = true;\n  containerConfig = config;\n};\n\ntoast.POSITION = POSITION;\ntoast.TYPE = TYPE;\n/**\n * Wait until the ToastContainer is mounted to dispatch the toast\n * and attach isActive method\n */\n\neventManager.on(ACTION.DID_MOUNT, function (containerInstance) {\n  latestInstance = containerInstance.props.containerId || containerInstance;\n  containers.set(latestInstance, containerInstance);\n  queue.forEach(function (item) {\n    eventManager.emit(item.action, item.content, item.options);\n  });\n  queue = [];\n}).on(ACTION.WILL_UNMOUNT, function (containerInstance) {\n  if (containerInstance) containers.delete(containerInstance.props.containerId || containerInstance);else containers.clear();\n\n  if (containers.size === 0) {\n    eventManager.off(ACTION.SHOW).off(ACTION.CLEAR);\n  }\n\n  if (canUseDom && containerDomNode) {\n    document.body.removeChild(containerDomNode);\n  }\n});\n\nexport { Bounce, Flip, Slide, ToastContainer, POSITION as ToastPosition, TYPE as ToastType, Zoom, cssTransition, toast };\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  define(Gp, \"constructor\", GeneratorFunctionPrototype);\n  define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction);\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n"],"sourceRoot":""}