{"version":3,"sources":["../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../node_modules/redux-persist/es/constants.js","../node_modules/redux-persist/es/stateReconciler/autoMergeLevel1.js","../node_modules/redux-persist/es/createPersistoid.js","../node_modules/redux-persist/es/getStoredState.js","../node_modules/redux-persist/es/purgeStoredState.js","../node_modules/redux-persist/es/persistReducer.js","../node_modules/redux-persist/es/stateReconciler/autoMergeLevel2.js","../node_modules/redux-persist/es/persistStore.js","../node_modules/redux/es/redux.js","../node_modules/symbol-observable/es/index.js","../node_modules/webpack/buildin/harmony-module.js","../node_modules/symbol-observable/es/ponyfill.js"],"names":["__webpack_require__","d","__webpack_exports__","_objectSpread2","_defineProperty__WEBPACK_IMPORTED_MODULE_0__","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","target","i","arguments","length","source","forEach","key","getOwnPropertyDescriptors","defineProperties","defineProperty","REHYDRATE","REGISTER","_typeof","Symbol","iterator","obj","constructor","prototype","_extends","assign","hasOwnProperty","call","autoMergeLevel1","inboundState","originalState","reducedState","_ref","debug","newState","createPersistoid","config","blacklist","whitelist","transforms","throttle","storageKey","undefined","keyPrefix","storage","serialize","x","defaultSerialize","lastState","stagedState","keysToProcess","timeIterator","writePromise","processNextKey","clearInterval","shift","endState","reduce","subState","transformer","in","err","console","error","setItem","catch","onWriteFail","update","state","indexOf","passWhitelistBlacklist","setInterval","flush","Promise","resolve","data","JSON","stringify","getStoredState_getStoredState","deserialize","defaultDeserialize","getItem","then","serialized","rawState","reduceRight","out","serial","parse","warnIfRemoveError","persistReducer_extends","persistReducer","baseReducer","version","stateReconciler","getStoredState","timeout","_persistoid","_purge","_paused","conditionalUpdate","_persist","rehydrated","action","restState","_objectWithoutProperties","type","_sealed","_rehydrate","payload","rehydrate","setTimeout","Error","register","restoredState","migrate","s","v","migratedState","migrateErr","result","removeItem","purgeStoredState","reconciledRest","_newState","persistStore_extends","_toConsumableArray","arr","Array","isArray","arr2","from","initialState","registry","bootstrapped","persistStore_persistorReducer","concat","firstIndex","splice","persistStore","store","options","cb","boostrappedCb","_pStore","redux","enhancer","dispatch","rehydrateAction","persistor","getState","purge","results","purgeResult","all","flushResult","pause","persist","r","ActionTypes","applyMiddleware","bindActionCreators","combineReducers","compose","createStore","symbol_observable__WEBPACK_IMPORTED_MODULE_0__","randomString","Math","random","toString","substring","split","join","INIT","REPLACE","PROBE_UNKNOWN_ACTION","isPlainObject","proto","getPrototypeOf","reducer","preloadedState","_ref2","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","slice","subscribe","listener","isSubscribed","index","listeners","replaceReducer","nextReducer","observable","outerSubscribe","observer","TypeError","observeState","next","unsubscribe","this","getUndefinedStateErrorMessage","actionType","String","reducers","reducerKeys","finalReducers","shapeAssertionError","finalReducerKeys","assertReducerShape","e","hasChanged","nextState","_i","_key","previousStateForKey","nextStateForKey","errorMessage","bindActionCreator","actionCreator","actionCreators","boundActionCreators","_defineProperty","value","configurable","writable","_len","funcs","arg","a","b","middlewares","_dispatch","middlewareAPI","chain","map","middleware","global","module","root","_ponyfill_js__WEBPACK_IMPORTED_MODULE_0__","self","window","exports","originalModule","webpackPolyfill","create","children","get","l","symbolObservablePonyfill"],"mappings":"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","file":"static/js/3.08683c2f.chunk.js","sourcesContent":["import defineProperty from \"./defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nexport default function _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(Object(source), true).forEach(function (key) {\n        defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}","export var KEY_PREFIX = 'persist:';\nexport var FLUSH = 'persist/FLUSH';\nexport var REHYDRATE = 'persist/REHYDRATE';\nexport var PAUSE = 'persist/PAUSE';\nexport var PERSIST = 'persist/PERSIST';\nexport var PURGE = 'persist/PURGE';\nexport var REGISTER = 'persist/REGISTER';\nexport var DEFAULT_VERSION = -1;","var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nexport default function autoMergeLevel1(inboundState, originalState, reducedState, _ref) {\n  var debug = _ref.debug;\n\n  var newState = _extends({}, reducedState); // only rehydrate if inboundState exists and is an object\n\n\n  if (inboundState && (typeof inboundState === 'undefined' ? 'undefined' : _typeof(inboundState)) === 'object') {\n    Object.keys(inboundState).forEach(function (key) {\n      // ignore _persist data\n      if (key === '_persist') return; // if reducer modifies substate, skip auto rehydration\n\n      if (originalState[key] !== reducedState[key]) {\n        if (process.env.NODE_ENV !== 'production' && debug) console.log('redux-persist/stateReconciler: sub state for key `%s` modified, skipping.', key);\n        return;\n      } // otherwise hard set the new value\n\n\n      newState[key] = inboundState[key];\n    });\n  }\n\n  if (process.env.NODE_ENV !== 'production' && debug && inboundState && (typeof inboundState === 'undefined' ? 'undefined' : _typeof(inboundState)) === 'object') console.log('redux-persist/stateReconciler: rehydrated keys \\'' + Object.keys(inboundState).join(', ') + '\\'');\n  return newState;\n}\n/*\n  autoMergeLevel1: \n    - merges 1 level of substate\n    - skips substate if already modified\n*/","import { KEY_PREFIX, REHYDRATE } from './constants'; // @TODO remove once flow < 0.63 support is no longer required.\n\nexport default function createPersistoid(config) {\n  // defaults\n  var blacklist = config.blacklist || null;\n  var whitelist = config.whitelist || null;\n  var transforms = config.transforms || [];\n  var throttle = config.throttle || 0;\n  var storageKey = '' + (config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX) + config.key;\n  var storage = config.storage;\n  var serialize = config.serialize === false ? function (x) {\n    return x;\n  } : defaultSerialize; // initialize stateful values\n\n  var lastState = {};\n  var stagedState = {};\n  var keysToProcess = [];\n  var timeIterator = null;\n  var writePromise = null;\n\n  var update = function update(state) {\n    // add any changed keys to the queue\n    Object.keys(state).forEach(function (key) {\n      if (!passWhitelistBlacklist(key)) return; // is keyspace ignored? noop\n\n      if (lastState[key] === state[key]) return; // value unchanged? noop\n\n      if (keysToProcess.indexOf(key) !== -1) return; // is key already queued? noop\n\n      keysToProcess.push(key); // add key to queue\n    }); //if any key is missing in the new state which was present in the lastState,\n    //add it for processing too\n\n    Object.keys(lastState).forEach(function (key) {\n      if (state[key] === undefined) {\n        keysToProcess.push(key);\n      }\n    }); // start the time iterator if not running (read: throttle)\n\n    if (timeIterator === null) {\n      timeIterator = setInterval(processNextKey, throttle);\n    }\n\n    lastState = state;\n  };\n\n  function processNextKey() {\n    if (keysToProcess.length === 0) {\n      if (timeIterator) clearInterval(timeIterator);\n      timeIterator = null;\n      return;\n    }\n\n    var key = keysToProcess.shift();\n    var endState = transforms.reduce(function (subState, transformer) {\n      return transformer.in(subState, key, lastState);\n    }, lastState[key]);\n\n    if (endState !== undefined) {\n      try {\n        stagedState[key] = serialize(endState);\n      } catch (err) {\n        console.error('redux-persist/createPersistoid: error serializing state', err);\n      }\n    } else {\n      //if the endState is undefined, no need to persist the existing serialized content\n      delete stagedState[key];\n    }\n\n    if (keysToProcess.length === 0) {\n      writeStagedState();\n    }\n  }\n\n  function writeStagedState() {\n    // cleanup any removed keys just before write.\n    Object.keys(stagedState).forEach(function (key) {\n      if (lastState[key] === undefined) {\n        delete stagedState[key];\n      }\n    });\n    writePromise = storage.setItem(storageKey, serialize(stagedState)).catch(onWriteFail);\n  }\n\n  function passWhitelistBlacklist(key) {\n    if (whitelist && whitelist.indexOf(key) === -1 && key !== '_persist') return false;\n    if (blacklist && blacklist.indexOf(key) !== -1) return false;\n    return true;\n  }\n\n  function onWriteFail(err) {\n    // @TODO add fail handlers (typically storage full)\n    if (err && process.env.NODE_ENV !== 'production') {\n      console.error('Error storing data', err);\n    }\n  }\n\n  var flush = function flush() {\n    while (keysToProcess.length !== 0) {\n      processNextKey();\n    }\n\n    return writePromise || Promise.resolve();\n  }; // return `persistoid`\n\n\n  return {\n    update: update,\n    flush: flush\n  };\n} // @NOTE in the future this may be exposed via config\n\nfunction defaultSerialize(data) {\n  return JSON.stringify(data);\n}","import { KEY_PREFIX } from './constants';\nexport default function getStoredState(config) {\n  var transforms = config.transforms || [];\n  var storageKey = '' + (config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX) + config.key;\n  var storage = config.storage;\n  var debug = config.debug;\n  var deserialize = config.serialize === false ? function (x) {\n    return x;\n  } : defaultDeserialize;\n  return storage.getItem(storageKey).then(function (serialized) {\n    if (!serialized) return undefined;else {\n      try {\n        var state = {};\n        var rawState = deserialize(serialized);\n        Object.keys(rawState).forEach(function (key) {\n          state[key] = transforms.reduceRight(function (subState, transformer) {\n            return transformer.out(subState, key, rawState);\n          }, deserialize(rawState[key]));\n        });\n        return state;\n      } catch (err) {\n        if (process.env.NODE_ENV !== 'production' && debug) console.log('redux-persist/getStoredState: Error restoring data ' + serialized, err);\n        throw err;\n      }\n    }\n  });\n}\n\nfunction defaultDeserialize(serial) {\n  return JSON.parse(serial);\n}","import { KEY_PREFIX } from './constants';\nexport default function purgeStoredState(config) {\n  var storage = config.storage;\n  var storageKey = '' + (config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX) + config.key;\n  return storage.removeItem(storageKey, warnIfRemoveError);\n}\n\nfunction warnIfRemoveError(err) {\n  if (err && process.env.NODE_ENV !== 'production') {\n    console.error('redux-persist/purgeStoredState: Error purging data stored state', err);\n  }\n}","var _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nfunction _objectWithoutProperties(obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n}\n\nimport { FLUSH, PAUSE, PERSIST, PURGE, REHYDRATE, DEFAULT_VERSION } from './constants';\nimport autoMergeLevel1 from './stateReconciler/autoMergeLevel1';\nimport createPersistoid from './createPersistoid';\nimport defaultGetStoredState from './getStoredState';\nimport purgeStoredState from './purgeStoredState';\nvar DEFAULT_TIMEOUT = 5000;\n/*\n  @TODO add validation / handling for:\n  - persisting a reducer which has nested _persist\n  - handling actions that fire before reydrate is called\n*/\n\nexport default function persistReducer(config, baseReducer) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!config) throw new Error('config is required for persistReducer');\n    if (!config.key) throw new Error('key is required in persistor config');\n    if (!config.storage) throw new Error(\"redux-persist: config.storage is required. Try using one of the provided storage engines `import storage from 'redux-persist/lib/storage'`\");\n  }\n\n  var version = config.version !== undefined ? config.version : DEFAULT_VERSION;\n  var debug = config.debug || false;\n  var stateReconciler = config.stateReconciler === undefined ? autoMergeLevel1 : config.stateReconciler;\n  var getStoredState = config.getStoredState || defaultGetStoredState;\n  var timeout = config.timeout !== undefined ? config.timeout : DEFAULT_TIMEOUT;\n  var _persistoid = null;\n  var _purge = false;\n  var _paused = true;\n\n  var conditionalUpdate = function conditionalUpdate(state) {\n    // update the persistoid only if we are rehydrated and not paused\n    state._persist.rehydrated && _persistoid && !_paused && _persistoid.update(state);\n    return state;\n  };\n\n  return function (state, action) {\n    var _ref = state || {},\n        _persist = _ref._persist,\n        rest = _objectWithoutProperties(_ref, ['_persist']);\n\n    var restState = rest;\n\n    if (action.type === PERSIST) {\n      var _sealed = false;\n\n      var _rehydrate = function _rehydrate(payload, err) {\n        // dev warning if we are already sealed\n        if (process.env.NODE_ENV !== 'production' && _sealed) console.error('redux-persist: rehydrate for \"' + config.key + '\" called after timeout.', payload, err); // only rehydrate if we are not already sealed\n\n        if (!_sealed) {\n          action.rehydrate(config.key, payload, err);\n          _sealed = true;\n        }\n      };\n\n      timeout && setTimeout(function () {\n        !_sealed && _rehydrate(undefined, new Error('redux-persist: persist timed out for persist key \"' + config.key + '\"'));\n      }, timeout); // @NOTE PERSIST resumes if paused.\n\n      _paused = false; // @NOTE only ever create persistoid once, ensure we call it at least once, even if _persist has already been set\n\n      if (!_persistoid) _persistoid = createPersistoid(config); // @NOTE PERSIST can be called multiple times, noop after the first\n\n      if (_persist) return state;\n      if (typeof action.rehydrate !== 'function' || typeof action.register !== 'function') throw new Error('redux-persist: either rehydrate or register is not a function on the PERSIST action. This can happen if the action is being replayed. This is an unexplored use case, please open an issue and we will figure out a resolution.');\n      action.register(config.key);\n      getStoredState(config).then(function (restoredState) {\n        var migrate = config.migrate || function (s, v) {\n          return Promise.resolve(s);\n        };\n\n        migrate(restoredState, version).then(function (migratedState) {\n          _rehydrate(migratedState);\n        }, function (migrateErr) {\n          if (process.env.NODE_ENV !== 'production' && migrateErr) console.error('redux-persist: migration error', migrateErr);\n\n          _rehydrate(undefined, migrateErr);\n        });\n      }, function (err) {\n        _rehydrate(undefined, err);\n      });\n      return _extends({}, baseReducer(restState, action), {\n        _persist: {\n          version: version,\n          rehydrated: false\n        }\n      });\n    } else if (action.type === PURGE) {\n      _purge = true;\n      action.result(purgeStoredState(config));\n      return _extends({}, baseReducer(restState, action), {\n        _persist: _persist\n      });\n    } else if (action.type === FLUSH) {\n      action.result(_persistoid && _persistoid.flush());\n      return _extends({}, baseReducer(restState, action), {\n        _persist: _persist\n      });\n    } else if (action.type === PAUSE) {\n      _paused = true;\n    } else if (action.type === REHYDRATE) {\n      // noop on restState if purging\n      if (_purge) return _extends({}, restState, {\n        _persist: _extends({}, _persist, {\n          rehydrated: true\n        }) // @NOTE if key does not match, will continue to default else below\n\n      });\n\n      if (action.key === config.key) {\n        var reducedState = baseReducer(restState, action);\n        var inboundState = action.payload; // only reconcile state if stateReconciler and inboundState are both defined\n\n        var reconciledRest = stateReconciler !== false && inboundState !== undefined ? stateReconciler(inboundState, state, reducedState, config) : reducedState;\n\n        var _newState = _extends({}, reconciledRest, {\n          _persist: _extends({}, _persist, {\n            rehydrated: true\n          })\n        });\n\n        return conditionalUpdate(_newState);\n      }\n    } // if we have not already handled PERSIST, straight passthrough\n\n\n    if (!_persist) return baseReducer(state, action); // run base reducer:\n    // is state modified ? return original : return updated\n\n    var newState = baseReducer(restState, action);\n    if (newState === restState) return state;else {\n      newState._persist = _persist;\n      return conditionalUpdate(newState);\n    }\n  };\n}","var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nexport default function autoMergeLevel2(inboundState, originalState, reducedState, _ref) {\n  var debug = _ref.debug;\n\n  var newState = _extends({}, reducedState); // only rehydrate if inboundState exists and is an object\n\n\n  if (inboundState && (typeof inboundState === 'undefined' ? 'undefined' : _typeof(inboundState)) === 'object') {\n    Object.keys(inboundState).forEach(function (key) {\n      // ignore _persist data\n      if (key === '_persist') return; // if reducer modifies substate, skip auto rehydration\n\n      if (originalState[key] !== reducedState[key]) {\n        if (process.env.NODE_ENV !== 'production' && debug) console.log('redux-persist/stateReconciler: sub state for key `%s` modified, skipping.', key);\n        return;\n      }\n\n      if (isPlainEnoughObject(reducedState[key])) {\n        // if object is plain enough shallow merge the new values (hence \"Level2\")\n        newState[key] = _extends({}, newState[key], inboundState[key]);\n        return;\n      } // otherwise hard set\n\n\n      newState[key] = inboundState[key];\n    });\n  }\n\n  if (process.env.NODE_ENV !== 'production' && debug && inboundState && (typeof inboundState === 'undefined' ? 'undefined' : _typeof(inboundState)) === 'object') console.log('redux-persist/stateReconciler: rehydrated keys \\'' + Object.keys(inboundState).join(', ') + '\\'');\n  return newState;\n}\n/*\n  autoMergeLevel2: \n    - merges 2 level of substate\n    - skips substate if already modified\n    - this is essentially redux-perist v4 behavior\n*/\n\nfunction isPlainEnoughObject(o) {\n  return o !== null && !Array.isArray(o) && (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === 'object';\n}","var _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\n\nimport { createStore } from 'redux';\nimport persistReducer from './persistReducer';\nimport { FLUSH, PAUSE, PERSIST, PURGE, REGISTER, REHYDRATE } from './constants';\nvar initialState = {\n  registry: [],\n  bootstrapped: false\n};\n\nvar persistorReducer = function persistorReducer() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;\n  var action = arguments[1];\n\n  switch (action.type) {\n    case REGISTER:\n      return _extends({}, state, {\n        registry: [].concat(_toConsumableArray(state.registry), [action.key])\n      });\n\n    case REHYDRATE:\n      var firstIndex = state.registry.indexOf(action.key);\n      var registry = [].concat(_toConsumableArray(state.registry));\n      registry.splice(firstIndex, 1);\n      return _extends({}, state, {\n        registry: registry,\n        bootstrapped: registry.length === 0\n      });\n\n    default:\n      return state;\n  }\n};\n\nexport default function persistStore(store, options, cb) {\n  // help catch incorrect usage of passing PersistConfig in as PersistorOptions\n  if (process.env.NODE_ENV !== 'production') {\n    var optionsToTest = options || {};\n    var bannedKeys = ['blacklist', 'whitelist', 'transforms', 'storage', 'keyPrefix', 'migrate'];\n    bannedKeys.forEach(function (k) {\n      if (!!optionsToTest[k]) console.error('redux-persist: invalid option passed to persistStore: \"' + k + '\". You may be incorrectly passing persistConfig into persistStore, whereas it should be passed into persistReducer.');\n    });\n  }\n\n  var boostrappedCb = cb || false;\n\n  var _pStore = createStore(persistorReducer, initialState, options ? options.enhancer : undefined);\n\n  var register = function register(key) {\n    _pStore.dispatch({\n      type: REGISTER,\n      key: key\n    });\n  };\n\n  var rehydrate = function rehydrate(key, payload, err) {\n    var rehydrateAction = {\n      type: REHYDRATE,\n      payload: payload,\n      err: err,\n      key: key // dispatch to `store` to rehydrate and `persistor` to track result\n\n    };\n    store.dispatch(rehydrateAction);\n\n    _pStore.dispatch(rehydrateAction);\n\n    if (boostrappedCb && persistor.getState().bootstrapped) {\n      boostrappedCb();\n      boostrappedCb = false;\n    }\n  };\n\n  var persistor = _extends({}, _pStore, {\n    purge: function purge() {\n      var results = [];\n      store.dispatch({\n        type: PURGE,\n        result: function result(purgeResult) {\n          results.push(purgeResult);\n        }\n      });\n      return Promise.all(results);\n    },\n    flush: function flush() {\n      var results = [];\n      store.dispatch({\n        type: FLUSH,\n        result: function result(flushResult) {\n          results.push(flushResult);\n        }\n      });\n      return Promise.all(results);\n    },\n    pause: function pause() {\n      store.dispatch({\n        type: PAUSE\n      });\n    },\n    persist: function persist() {\n      store.dispatch({\n        type: PERSIST,\n        register: register,\n        rehydrate: rehydrate\n      });\n    }\n  });\n\n  persistor.persist();\n  return persistor;\n}","import $$observable from 'symbol-observable';\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 */\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 * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\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 * 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\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 * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\n\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 * 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 */\n\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 * 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\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 * 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\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 };","/* global window */\nimport ponyfill from './ponyfill.js';\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;","module.exports = function (originalModule) {\n  if (!originalModule.webpackPolyfill) {\n    var module = Object.create(originalModule); // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    Object.defineProperty(module, \"exports\", {\n      enumerable: true\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","export default function symbolObservablePonyfill(root) {\n  var result;\n  var Symbol = root.Symbol;\n\n  if (typeof Symbol === 'function') {\n    if (Symbol.observable) {\n      result = Symbol.observable;\n    } else {\n      result = Symbol('observable');\n      Symbol.observable = result;\n    }\n  } else {\n    result = '@@observable';\n  }\n\n  return result;\n}\n;"],"sourceRoot":""}