docs: function createStore(reducer, preloadedState, enhancer) {
  	  var _ref2;
  	
  	  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
  	    enhancer = preloadedState;
  	    preloadedState = undefined;
  	  }
  	
  	  if (typeof enhancer !== 'undefined') {
  	    if (typeof enhancer !== 'function') {
  	      throw new Error('Expected the enhancer to be a function.');
  	    }
  	
  	    return enhancer(createStore)(reducer, preloadedState);
  	  }
  	
  	  if (typeof reducer !== 'function') {
  	    throw new Error('Expected the reducer to be a function.');
  	  }
  	
  	  var currentReducer = reducer;
  	  var currentState = preloadedState;
  	  var currentListeners = [];
  	  var nextListeners = currentListeners;
  	  var isDispatching = false;
  	
  	  function ensureCanMutateNextListeners() {
  	    if (nextListeners === currentListeners) {
  	      nextListeners = currentListeners.slice();
  	    }
  	  }
  	
  	  /**
  	   * Reads the state tree managed by the store.
  	   *
  	   * @returns {any} The current state tree of your application.
  	   */
  	  function getState() {
  	    return currentState;
  	  }
  	
  	  /**
  	   * Adds a change listener. It will be called any time an action is dispatched,
  	   * and some part of the state tree may potentially have changed. You may then
  	   * call `getState()` to read the current state tree inside the callback.
  	   *
  	   * You may call `dispatch()` from a change listener, with the following
  	   * caveats:
  	   *
  	   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
  	   * If you subscribe or unsubscribe while the listeners are being invoked, this
  	   * will not have any effect on the `dispatch()` that is currently in progress.
  	   * However, the next `dispatch()` call, whether nested or not, will use a more
  	   * recent snapshot of the subscription list.
  	   *
  	   * 2. The listener should not expect to see all state changes, as the state
  	   * might have been updated multiple times during a nested `dispatch()` before
  	   * the listener is called. It is, however, guaranteed that all subscribers
  	   * registered before the `dispatch()` started will be called with the latest
  	   * state by the time it exits.
  	   *
  	   * @param {Function} listener A callback to be invoked on every dispatch.
  	   * @returns {Function} A function to remove this change listener.
  	   */
  	  function subscribe(listener) {
  	    if (typeof listener !== 'function') {
  	      throw new Error('Expected listener to be a function.');
  	    }
  	
  	    var isSubscribed = true;
  	
  	    ensureCanMutateNextListeners();
  	    nextListeners.push(listener);
  	
  	    return function unsubscribe() {
  	      if (!isSubscribed) {
  	        return;
  	      }
  	
  	      isSubscribed = false;
  	
  	      ensureCanMutateNextListeners();
  	      var index = nextListeners.indexOf(listener);
  	      nextListeners.splice(index, 1);
  	    };
  	  }
  	
  	  /**
  	   * Dispatches an action. It is the only way to trigger a state change.
  	   *
  	   * The `reducer` function, used to create the store, will be called with the
  	   * current state tree and the given `action`. Its return value will
  	   * be considered the **next** state of the tree, and the change listeners
  	   * will be notified.
  	   *
  	   * The base implementation only supports plain object actions. If you want to
  	   * dispatch a Promise, an Observable, a thunk, or something else, you need to
  	   * wrap your store creating function into the corresponding middleware. For
  	   * example, see the documentation for the `redux-thunk` package. Even the
  	   * middleware will eventually dispatch plain object actions using this method.
  	   *
  	   * @param {Object} action A plain object representing “what changed”. It is
  	   * a good idea to keep actions serializable so you can record and replay user
  	   * sessions, or use the time travelling `redux-devtools`. An action must have
  	   * a `type` property which may not be `undefined`. It is a good idea to use
  	   * string constants for action types.
  	   *
  	   * @returns {Object} For convenience, the same action object you dispatched.
  	   *
  	   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
  	   * return something else (for example, a Promise you can await).
  	   */
  	  function dispatch(action) {
  	    if (!(0, _isPlainObject2['default'])(action)) {
  	      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
  	    }
  	
  	    if (typeof action.type === 'undefined') {
  	      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
  	    }
  	
  	    if (isDispatching) {
  	      throw new Error('Reducers may not dispatch actions.');
  	    }
  	
  	    try {
  	      isDispatching = true;
  	      currentState = currentReducer(currentState, action);
  	    } finally {
  	      isDispatching = false;
  	    }
  	
  	    var listeners = currentListeners = nextListeners;
  	    for (var i = 0; i < listeners.length; i++) {
  	      listeners[i]();
  	    }
  	
  	    return action;
  	  }
  	
  	  /**
  	   * Replaces the reducer currently used by the store to calculate the state.
  	   *
  	   * You might need this if your app implements code splitting and you want to
  	   * load some of the reducers dynamically. You might also need this if you
  	   * implement a hot reloading mechanism for Redux.
  	   *
  	   * @param {Function} nextReducer The reducer for the store to use instead.
  	   * @returns {void}
  	   */
  	  function replaceReducer(nextReducer) {
  	    if (typeof nextReducer !== 'function') {
  	      throw new Error('Expected the nextReducer to be a function.');
  	    }
  	
  	    currentReducer = nextReducer;
  	    dispatch({ type: ActionTypes.INIT });
  	  }
  	
  	  /**
  	   * Interoperability point for observable/reactive libraries.
  	   * @returns {observable} A minimal observable of state changes.
  	   * For more information, see the observable proposal:
  	   * https://github.com/zenparsing/es-observable
  	   */
  	  function observable() {
  	    var _ref;
  	
  	    var outerSubscribe = subscribe;
  	    return _ref = {
  	      /**
  	       * The minimal observable subscription method.
  	       * @param {Object} observer Any object that can be used as an observer.
  	       * The observer object should have a `next` method.
  	       * @returns {subscription} An object with an `unsubscribe` method that can
  	       * be used to unsubscribe the observable from the store, and prevent further
  	       * emission of values from the observable.
  	       */
  	      subscribe: function subscribe(observer) {
  	        if (typeof observer !== 'object') {
  	          throw new TypeError('Expected the observer to be an object.');
  	        }
  	
  	        function observeState() {
  	          if (observer.next) {
  	            observer.next(getState());
  	          }
  	        }
  	
  	        observeState();
  	        var unsubscribe = outerSubscribe(observeState);
  	        return { unsubscribe: unsubscribe };
  	      }
  	    }, _ref[_symbolObservable2['default']] = function () {
  	      return this;
  	    }, _ref;
  	  }
  	
  	  // When a store is created, an "INIT" action is dispatched so that every
  	  // reducer returns their initial state. This effectively populates
  	  // the initial state tree.
  	  dispatch({ type: ActionTypes.INIT });
  	
  	  return _ref2 = {
  	    dispatch: dispatch,
  	    subscribe: subscribe,
  	    getState: getState,
  	    replaceReducer: replaceReducer
  	  }, _ref2[_symbolObservable2['default']] = observable, _ref2;
  	}