{"version":3,"file":"js/934-99b1e96c95e29310322f.js","mappings":"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","sources":["webpack://evalarmjs/../../shared/node_modules/redux/es/createStore.js","webpack://evalarmjs/../../shared/node_modules/redux/es/combineReducers.js","webpack://evalarmjs/../../shared/node_modules/redux/es/bindActionCreators.js","webpack://evalarmjs/../../shared/node_modules/redux/es/compose.js","webpack://evalarmjs/../../shared/node_modules/redux/es/applyMiddleware.js","webpack://evalarmjs/../../shared/node_modules/symbol-observable/es/index.js","webpack://evalarmjs/../../shared/node_modules/symbol-observable/es/ponyfill.js"],"sourcesContent":["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}","/* 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","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"],"names":["INIT","createStore","reducer","preloadedState","enhancer","_ref2","undefined","Error","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","slice","getState","subscribe","listener","isSubscribed","push","index","indexOf","splice","dispatch","action","type","listeners","i","length","replaceReducer","nextReducer","_ref","outerSubscribe","observer","TypeError","observeState","next","unsubscribe","this","getUndefinedStateErrorMessage","key","actionType","toString","combineReducers","reducers","reducerKeys","Object","keys","finalReducers","finalReducerKeys","shapeAssertionError","forEach","Math","random","substring","split","join","assertReducerShape","e","state","arguments","hasChanged","nextState","_i","_key","previousStateForKey","nextStateForKey","errorMessage","bindActionCreator","actionCreator","apply","bindActionCreators","actionCreators","boundActionCreators","compose","_len","funcs","Array","arg","reduce","a","b","_extends","assign","target","source","prototype","hasOwnProperty","call","applyMiddleware","middlewares","chain","store","_dispatch","middlewareAPI","map","middleware","root","result","Symbol","observable","self","window","g","module"],"sourceRoot":""}