{"version":3,"sources":["webpack:///(webpack)/buildin/harmony-module.js","webpack:///./node_modules/symbol-observable/es/ponyfill.js","webpack:///./node_modules/lodash-es/_freeGlobal.js","webpack:///./node_modules/symbol-observable/es/index.js","webpack:///./node_modules/lodash-es/_root.js","webpack:///./node_modules/lodash-es/_Symbol.js","webpack:///./node_modules/lodash-es/_getRawTag.js","webpack:///./node_modules/lodash-es/_objectToString.js","webpack:///./node_modules/lodash-es/_baseGetTag.js","webpack:///./node_modules/lodash-es/_overArg.js","webpack:///./node_modules/lodash-es/_getPrototype.js","webpack:///./node_modules/lodash-es/isObjectLike.js","webpack:///./node_modules/lodash-es/isPlainObject.js","webpack:///./node_modules/redux/es/createStore.js","webpack:///./node_modules/redux/es/combineReducers.js","webpack:///./node_modules/redux/es/bindActionCreators.js","webpack:///./node_modules/redux/es/compose.js","webpack:///./node_modules/redux/es/applyMiddleware.js","webpack:///./node_modules/redux-thunk/es/index.js","webpack:///(webpack)/buildin/global.js"],"names":["module","exports","originalModule","webpackPolyfill","Object","create","children","defineProperty","enumerable","get","l","i","symbolObservablePonyfill","root","result","Symbol","observable","__webpack_require__","d","__webpack_exports__","global","freeGlobal","r","_ponyfill_js__WEBPACK_IMPORTED_MODULE_0__","self","window","freeSelf","_freeGlobal","Function","_root","_Symbol","objectProto","prototype","_getRawTag_hasOwnProperty","hasOwnProperty","nativeObjectToString","toString","symToStringTag","toStringTag","undefined","_getRawTag","value","isOwn","call","tag","unmasked","e","_objectToString_objectProto","_objectToString_nativeObjectToString","_objectToString","nullTag","undefinedTag","_baseGetTag_symToStringTag","_baseGetTag","_overArg","func","transform","arg","getPrototype","getPrototypeOf","_getPrototype","lodash_es_isObjectLike","objectTag","funcProto","isPlainObject_objectProto","funcToString","isPlainObject_hasOwnProperty","objectCtorString","lodash_es_isPlainObject","proto","Ctor","constructor","ActionTypes","INIT","createStore_createStore","reducer","preloadedState","enhancer","_ref2","Error","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","slice","getState","subscribe","listener","isSubscribed","push","index","indexOf","splice","dispatch","action","type","listeners","length","replaceReducer","nextReducer","es","_ref","outerSubscribe","observer","TypeError","observeState","next","unsubscribe","this","getUndefinedStateErrorMessage","key","actionType","actionName","combineReducers","reducers","reducerKeys","keys","finalReducers","finalReducerKeys","shapeAssertionError","forEach","initialState","Math","random","substring","split","join","assertReducerShape","state","arguments","hasChanged","nextState","_i","_key","previousStateForKey","nextStateForKey","errorMessage","bindActionCreator","actionCreator","apply","bindActionCreators","actionCreators","boundActionCreators","compose","_len","funcs","Array","reduce","a","b","_extends","assign","target","source","applyMiddleware","middlewares","createStore","chain","store","_dispatch","middlewareAPI","map","middleware","createThunkMiddleware","extraArgument","thunk","withExtraArgument","g"],"mappings":"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","file":"vendors.921c38f50c57719049aa.js","sourcesContent":["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","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\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","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","import isPlainObject from 'lodash-es/isPlainObject';\nimport $$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 */\nexport var ActionTypes = {\n  INIT: '@@redux/INIT'\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};export default function createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\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  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\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  function getState() {\n    return currentState;\n  }\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  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected listener to be a function.');\n    }\n\n    var isSubscribed = true;\n\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      isSubscribed = false;\n\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n    };\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  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    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\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  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer;\n    dispatch({ type: ActionTypes.INIT });\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  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') {\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 { unsubscribe: unsubscribe };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  }\n\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  dispatch({ 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}","import { ActionTypes } from './createStore';\nimport isPlainObject from 'lodash-es/isPlainObject';\nimport warning from './utils/warning';\n\nfunction getUndefinedStateErrorMessage(key, action) {\n  var actionType = action && action.type;\n  var actionName = actionType && '\"' + actionType.toString() + '\"' || 'an action';\n\n  return 'Given action ' + actionName + ', 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\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\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, { type: ActionTypes.INIT });\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    var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');\n    if (typeof reducer(undefined, { type: type }) === '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/**\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 */\nexport default function combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\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  var finalReducerKeys = Object.keys(finalReducers);\n\n  var unexpectedKeyCache = void 0;\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError = void 0;\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination() {\n    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var action = arguments[1];\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      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\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      if (typeof nextStateForKey === 'undefined') {\n        var errorMessage = getUndefinedStateErrorMessage(_key, action);\n        throw new Error(errorMessage);\n      }\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n    return hasChanged ? nextState : state;\n  };\n}","function bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(undefined, arguments));\n  };\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 a single function as the first argument,\n * and get a 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 */\nexport default function 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 keys = Object.keys(actionCreators);\n  var boundActionCreators = {};\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    var actionCreator = actionCreators[key];\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n  return boundActionCreators;\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\nexport default function compose() {\n  for (var _len = arguments.length, funcs = 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(undefined, arguments));\n    };\n  });\n}","var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nimport compose from './compose';\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 */\nexport default function applyMiddleware() {\n  for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function (reducer, preloadedState, enhancer) {\n      var store = createStore(reducer, preloadedState, enhancer);\n      var _dispatch = store.dispatch;\n      var chain = [];\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch(action) {\n          return _dispatch(action);\n        }\n      };\n      chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(undefined, chain)(store.dispatch);\n\n      return _extends({}, store, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}","function createThunkMiddleware(extraArgument) {\n  return function (_ref) {\n    var dispatch = _ref.dispatch,\n        getState = _ref.getState;\n    return function (next) {\n      return function (action) {\n        if (typeof action === 'function') {\n          return action(dispatch, getState, extraArgument);\n        }\n\n        return next(action);\n      };\n    };\n  };\n}\n\nvar thunk = createThunkMiddleware();\nthunk.withExtraArgument = createThunkMiddleware;\n\nexport default thunk;","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}