{"version":3,"sources":["../node_modules/redux/es/redux.js","../../src/useInterval.ts","../../src/utils.ts","../../src/useInfiniteScroll.ts","../../src/useWindowSize.ts","../node_modules/symbol-observable/es/index.js","../node_modules/webpack/buildin/harmony-module.js","../node_modules/symbol-observable/es/ponyfill.js"],"names":["randomString","Math","random","toString","substring","split","join","ActionTypes","INIT","REPLACE","PROBE_UNKNOWN_ACTION","isPlainObject","obj","proto","Object","getPrototypeOf","createStore","reducer","preloadedState","enhancer","_ref2","arguments","Error","undefined","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","slice","getState","subscribe","listener","isSubscribed","push","index","indexOf","splice","dispatch","action","type","listeners","i","length","replaceReducer","nextReducer","$$observable","_ref","outerSubscribe","observer","TypeError","observeState","next","unsubscribe","this","useInterval","callback","delay","savedCallback","useRef","useEffect","current","id","setInterval","tick","clearInterval","isNullOrUndefined","value","includes","PARENT","getElementSizes","element","parentRect","getBoundingClientRect","top","bottom","left","right","isElementInView","windowHeight","windowWidth","loading","hasNextPage","onLoadMore","threshold","checkInterval","scrollContainer","WINDOW","ref","validWindow","window","getSize","useCallback","width","innerWidth","height","innerHeight","useState","size","setSize","handleResize","addEventListener","removeEventListener","useWindowSize","listen","setListen","listenBottomOffset","parent","parentNode","isParentInView","isListInView","bottomOffset","getBottomOffset","root","self","global","module","result","ponyfill","exports","originalModule","webpackPolyfill","create","children","defineProperty","enumerable","get","l","symbolObservablePonyfill","Symbol","observable"],"mappings":"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","file":"static/js/4.7ad4f9a5.chunk.js","sourcesContent":["import $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nvar randomString = function randomString() {\n  return Math.random().toString(36).substring(7).split('').join('.');\n};\n\nvar ActionTypes = {\n  INIT: \"@@redux/INIT\" + randomString(),\n  REPLACE: \"@@redux/REPLACE\" + randomString(),\n  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {\n    return \"@@redux/PROBE_UNKNOWN_ACTION\" + randomString();\n  }\n};\n\n/**\n * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\nfunction isPlainObject(obj) {\n  if (typeof obj !== 'object' || obj === null) return false;\n  var proto = obj;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(obj) === proto;\n}\n\n/**\n * Creates a Redux store that holds the state tree.\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n\nfunction createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {\n    throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function.');\n  }\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error('Expected the enhancer to be a function.');\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error('Expected the reducer to be a function.');\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n  /**\n   * This makes a shallow copy of currentListeners so we can use\n   * nextListeners as a temporary list while dispatching.\n   *\n   * This prevents any bugs around consumers calling\n   * subscribe/unsubscribe in the middle of a dispatch.\n   */\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n\n\n  function getState() {\n    if (isDispatching) {\n      throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');\n    }\n\n    return currentState;\n  }\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n\n\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected the listener to be a function.');\n    }\n\n    if (isDispatching) {\n      throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');\n    }\n\n    var isSubscribed = true;\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      if (isDispatching) {\n        throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');\n      }\n\n      isSubscribed = false;\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n      currentListeners = null;\n    };\n  }\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n\n\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n    }\n\n    if (isDispatching) {\n      throw new Error('Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n\n\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.\n    // Any reducers that existed in both the new and old rootReducer\n    // will receive the previous state. This effectively populates\n    // the new state tree with any relevant data from the old one.\n\n    dispatch({\n      type: ActionTypes.REPLACE\n    });\n  }\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n\n\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object' || observer === null) {\n          throw new TypeError('Expected the observer to be an object.');\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return {\n          unsubscribe: unsubscribe\n        };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  } // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n\n\n  dispatch({\n    type: ActionTypes.INIT\n  });\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}\n\n/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nfunction warning(message) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message);\n  }\n  /* eslint-enable no-console */\n\n\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message);\n  } catch (e) {} // eslint-disable-line no-empty\n\n}\n\nfunction getUndefinedStateErrorMessage(key, action) {\n  var actionType = action && action.type;\n  var actionDescription = actionType && \"action \\\"\" + String(actionType) + \"\\\"\" || 'an action';\n  return \"Given \" + actionDescription + \", reducer \\\"\" + key + \"\\\" returned undefined. \" + \"To ignore an action, you must explicitly return the previous state. \" + \"If you want this reducer to hold no value, you can return null instead of undefined.\";\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  var reducerKeys = Object.keys(reducers);\n  var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n  if (reducerKeys.length === 0) {\n    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n  }\n\n  if (!isPlainObject(inputState)) {\n    return \"The \" + argumentName + \" has unexpected type of \\\"\" + {}.toString.call(inputState).match(/\\s([a-z|A-Z]+)/)[1] + \"\\\". Expected argument to be an object with the following \" + (\"keys: \\\"\" + reducerKeys.join('\", \"') + \"\\\"\");\n  }\n\n  var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n  });\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\n  if (action && action.type === ActionTypes.REPLACE) return;\n\n  if (unexpectedKeys.length > 0) {\n    return \"Unexpected \" + (unexpectedKeys.length > 1 ? 'keys' : 'key') + \" \" + (\"\\\"\" + unexpectedKeys.join('\", \"') + \"\\\" found in \" + argumentName + \". \") + \"Expected to find one of the known reducer keys instead: \" + (\"\\\"\" + reducerKeys.join('\", \"') + \"\\\". Unexpected keys will be ignored.\");\n  }\n}\n\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach(function (key) {\n    var reducer = reducers[key];\n    var initialState = reducer(undefined, {\n      type: ActionTypes.INIT\n    });\n\n    if (typeof initialState === 'undefined') {\n      throw new Error(\"Reducer \\\"\" + key + \"\\\" returned undefined during initialization. \" + \"If the state passed to the reducer is undefined, you must \" + \"explicitly return the initial state. The initial state may \" + \"not be undefined. If you don't want to set a value for this reducer, \" + \"you can use null instead of undefined.\");\n    }\n\n    if (typeof reducer(undefined, {\n      type: ActionTypes.PROBE_UNKNOWN_ACTION()\n    }) === 'undefined') {\n      throw new Error(\"Reducer \\\"\" + key + \"\\\" returned undefined when probed with a random type. \" + (\"Don't try to handle \" + ActionTypes.INIT + \" or other actions in \\\"redux/*\\\" \") + \"namespace. They are considered private. Instead, you must return the \" + \"current state for any unknown actions, unless it is undefined, \" + \"in which case you must return the initial state, regardless of the \" + \"action type. The initial state may not be undefined, but can be null.\");\n    }\n  });\n}\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\n\n\nfunction combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\n\n  for (var i = 0; i < reducerKeys.length; i++) {\n    var key = reducerKeys[i];\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof reducers[key] === 'undefined') {\n        warning(\"No reducer provided for key \\\"\" + key + \"\\\"\");\n      }\n    }\n\n    if (typeof reducers[key] === 'function') {\n      finalReducers[key] = reducers[key];\n    }\n  }\n\n  var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same\n  // keys multiple times.\n\n  var unexpectedKeyCache;\n\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError;\n\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination(state, action) {\n    if (state === void 0) {\n      state = {};\n    }\n\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\n\n    for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n      var _key = finalReducerKeys[_i];\n      var reducer = finalReducers[_key];\n      var previousStateForKey = state[_key];\n      var nextStateForKey = reducer(previousStateForKey, action);\n\n      if (typeof nextStateForKey === 'undefined') {\n        var errorMessage = getUndefinedStateErrorMessage(_key, action);\n        throw new Error(errorMessage);\n      }\n\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n\n    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;\n    return hasChanged ? nextState : state;\n  };\n}\n\nfunction bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(this, arguments));\n  };\n}\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass an action creator as the first argument,\n * and get a dispatch wrapped function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\n\n\nfunction bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === 'function') {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n\n  if (typeof actionCreators !== 'object' || actionCreators === null) {\n    throw new Error(\"bindActionCreators expected an object or a function, instead received \" + (actionCreators === null ? 'null' : typeof actionCreators) + \". \" + \"Did you write \\\"import ActionCreators from\\\" instead of \\\"import * as ActionCreators from\\\"?\");\n  }\n\n  var boundActionCreators = {};\n\n  for (var key in actionCreators) {\n    var actionCreator = actionCreators[key];\n\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n\n  return boundActionCreators;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    keys.push.apply(keys, Object.getOwnPropertySymbols(object));\n  }\n\n  if (enumerableOnly) keys = keys.filter(function (sym) {\n    return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n  });\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\n/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\nfunction compose() {\n  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {\n    funcs[_key] = arguments[_key];\n  }\n\n  if (funcs.length === 0) {\n    return function (arg) {\n      return arg;\n    };\n  }\n\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n\n  return funcs.reduce(function (a, b) {\n    return function () {\n      return a(b.apply(void 0, arguments));\n    };\n  });\n}\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\n\nfunction applyMiddleware() {\n  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function () {\n      var store = createStore.apply(void 0, arguments);\n\n      var _dispatch = function dispatch() {\n        throw new Error('Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.');\n      };\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch() {\n          return _dispatch.apply(void 0, arguments);\n        }\n      };\n      var chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(void 0, chain)(store.dispatch);\n      return _objectSpread2({}, store, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}\n\n/*\n * This is a dummy function to check if the function name has been altered by minification.\n * If the function has been minified and NODE_ENV !== 'production', warn the user.\n */\n\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n  warning('You are currently using minified code outside of NODE_ENV === \"production\". ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or setting mode to production in webpack (https://webpack.js.org/concepts/mode/) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexport { ActionTypes as __DO_NOT_USE__ActionTypes, applyMiddleware, bindActionCreators, combineReducers, compose, createStore };\n","import { useRef, useEffect } from 'react';\r\nimport { Maybe } from './types';\r\n\r\nfunction useInterval(callback: VoidFunction, delay: number) {\r\n  const savedCallback = useRef<Maybe<VoidFunction>>(null);\r\n\r\n  useEffect(() => {\r\n    savedCallback.current = callback;\r\n  }, [callback]);\r\n\r\n  useEffect(() => {\r\n    function tick() {\r\n      savedCallback.current?.();\r\n    }\r\n\r\n    if (delay) {\r\n      const id = setInterval(() => {\r\n        tick();\r\n      }, delay);\r\n      return () => {\r\n        clearInterval(id);\r\n      };\r\n    }\r\n  }, [delay]);\r\n}\r\n\r\nexport default useInterval;\r\n","import { NullOrUndefined } from './types';\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport function isNullOrUndefined(value: any): value is NullOrUndefined {\r\n  return [null, undefined].includes(value);\r\n}\r\n","import { useEffect, useRef, useState } from 'react';\r\nimport useWindowSize from './useWindowSize';\r\nimport useInterval from './useInterval';\r\nimport { isNullOrUndefined } from './utils';\r\nexport type InfiniteScrollContainer = 'window' | 'parent';\r\nconst WINDOW: InfiniteScrollContainer = 'window';\r\nconst PARENT: InfiniteScrollContainer = 'parent';\r\n\r\ntype InfiniteContainer = HTMLElement | (Node & ParentNode);\r\n\r\nfunction getElementSizes(element: InfiniteContainer) {\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  const parentRect = (element as any).getBoundingClientRect();\r\n  const { top, bottom, left, right } = parentRect;\r\n  return { top, bottom, left, right };\r\n}\r\n\r\nfunction isElementInView(\r\n  element: InfiniteContainer,\r\n  windowHeight: number,\r\n  windowWidth: number,\r\n) {\r\n  if (element) {\r\n    const { left, right, top, bottom } = getElementSizes(element);\r\n    if (left > windowWidth) {\r\n      return false;\r\n    } else if (right < 0) {\r\n      return false;\r\n    } else if (top > windowHeight) {\r\n      return false;\r\n    } else if (bottom < 0) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\nexport interface UseInfiniteScrollArgs {\r\n  // Some sort of \"fetching\" info of the request.\r\n  loading: boolean;\r\n  // If the list has more items to load.\r\n  hasNextPage: boolean;\r\n  // The callback function to execute when the threshold is exceeded.\r\n  onLoadMore: Function;\r\n  // Maximum distance to bottom of the window/parent to trigger the callback. Default is 150.\r\n  threshold?: number;\r\n  // Frequency to check the dom. Default is 200.\r\n  checkInterval?: number;\r\n  // May be `\"window\"` or `\"parent\"`. Default is `\"window\"`. If you want to use a scrollable parent for the infinite list, use `\"parent\"`.\r\n  scrollContainer?: InfiniteScrollContainer;\r\n}\r\n\r\nfunction useInfiniteScroll<T extends HTMLElement>({\r\n  loading,\r\n  hasNextPage,\r\n  onLoadMore,\r\n  threshold = 150,\r\n  checkInterval = 200,\r\n  scrollContainer = WINDOW,\r\n}: UseInfiniteScrollArgs) {\r\n  const ref = useRef<T>(null);\r\n  const { height: windowHeight, width: windowWidth } = useWindowSize();\r\n  // Normally we could use the \"loading\" prop, but when you set \"checkInterval\" to a very small\r\n  // number (like 10 etc.), some request components can't set its loading state\r\n  // immediately (I had this problem with react-apollo's Query component. In some cases, it runs\r\n  // \"updateQuery\" twice). Thus we set our own \"listen\" state which immeadiately turns to \"false\" on\r\n  // calling \"onLoadMore\".\r\n  const [listen, setListen] = useState(true);\r\n\r\n  useEffect(() => {\r\n    if (!loading) {\r\n      setListen(true);\r\n    }\r\n  }, [loading]);\r\n\r\n  function getBottomOffset() {\r\n    const element = ref.current;\r\n\r\n    if (!element || isNullOrUndefined(windowHeight)) {\r\n      return null;\r\n    }\r\n\r\n    const rect = element.getBoundingClientRect();\r\n\r\n    const bottom = rect.bottom;\r\n    let bottomOffset = bottom - windowHeight;\r\n\r\n    if (scrollContainer === PARENT) {\r\n      const parent = element.parentNode;\r\n      if (!parent) {\r\n        return null;\r\n      }\r\n      const { bottom: parentBottom } = getElementSizes(parent);\r\n      // Distance between bottom of list and its parent\r\n      bottomOffset = bottom - parentBottom;\r\n    }\r\n\r\n    return bottomOffset;\r\n  }\r\n\r\n  function isParentInView() {\r\n    const parent = ref.current?.parentNode;\r\n    if (\r\n      !parent ||\r\n      isNullOrUndefined(windowHeight) ||\r\n      isNullOrUndefined(windowWidth)\r\n    ) {\r\n      return false;\r\n    }\r\n    return isElementInView(parent, windowHeight, windowWidth);\r\n  }\r\n\r\n  function isListInView() {\r\n    const element = ref.current;\r\n    if (\r\n      !element ||\r\n      isNullOrUndefined(windowHeight) ||\r\n      isNullOrUndefined(windowWidth)\r\n    ) {\r\n      return false;\r\n    }\r\n    return isElementInView(element, windowHeight, windowWidth);\r\n  }\r\n\r\n  function listenBottomOffset() {\r\n    if (listen && !loading && hasNextPage) {\r\n      if (ref.current) {\r\n        if (scrollContainer === PARENT) {\r\n          if (!isParentInView()) {\r\n            // Do nothing if the parent is out of screen\r\n            return;\r\n          }\r\n        } else if (!isListInView()) {\r\n          return;\r\n        }\r\n\r\n        // Check if the distance between bottom of the container and bottom of the window or parent\r\n        // is less than \"threshold\"\r\n        const bottomOffset = getBottomOffset();\r\n\r\n        if (isNullOrUndefined(bottomOffset)) {\r\n          return;\r\n        }\r\n\r\n        const validOffset = bottomOffset < threshold;\r\n\r\n        if (validOffset) {\r\n          setListen(false);\r\n          onLoadMore();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  useInterval(\r\n    () => {\r\n      listenBottomOffset();\r\n    },\r\n    // Stop interval when there is no next page.\r\n    hasNextPage ? checkInterval : 0,\r\n  );\r\n\r\n  return ref;\r\n}\r\n\r\nexport default useInfiniteScroll;\r\n","import { useState, useEffect, useCallback } from 'react';\r\n\r\nfunction useWindowSize() {\r\n  const validWindow = typeof window === 'object';\r\n\r\n  const getSize = useCallback(() => {\r\n    const size = {\r\n      width: validWindow ? window.innerWidth : undefined,\r\n      height: validWindow ? window.innerHeight : undefined,\r\n    };\r\n\r\n    return size;\r\n  }, [validWindow]);\r\n\r\n  const [size, setSize] = useState(getSize());\r\n\r\n  useEffect(() => {\r\n    function handleResize() {\r\n      setSize(getSize());\r\n    }\r\n\r\n    if (validWindow) {\r\n      window.addEventListener('resize', handleResize);\r\n\r\n      return () => {\r\n        window.removeEventListener('resize', handleResize);\r\n      };\r\n    }\r\n  }, [getSize, validWindow]);\r\n\r\n  return size;\r\n}\r\n\r\nexport default useWindowSize;\r\n","/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n"],"sourceRoot":""}