text: function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
  
  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  import { createStore } from 'redux';
  import { FLUSH, PAUSE, PERSIST, RESYNC, PURGE, REGISTER, REHYDRATE } from './constants';
  var initialState = {
    registry: [],
    bootstrapped: false
  };
  
  var persistorReducer = function persistorReducer() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
    var action = arguments.length > 1 ? arguments[1] : undefined;
  
    switch (action.type) {
      case REGISTER:
        return _objectSpread({}, state, {
          registry: [].concat(_toConsumableArray(state.registry), [action.key])
        });
  
      case REHYDRATE:
        var firstIndex = state.registry.indexOf(action.key);
  
        var registry = _toConsumableArray(state.registry);
  
        registry.splice(firstIndex, 1);
        return _objectSpread({}, state, {
          registry: registry,
          bootstrapped: registry.length === 0
        });
  
      default:
        return state;
    }
  };
  
  export default function persistStore(store, options, cb) {
    // help catch incorrect usage of passing PersistConfig in as PersistorOptions
    if (process.env.NODE_ENV !== 'production') {
      var optionsToTest = options || {};
      var bannedKeys = ['blacklist', 'whitelist', 'transforms', 'storage', 'keyPrefix', 'migrate'];
      bannedKeys.forEach(function (k) {
        if (!!optionsToTest[k]) console.error("redux-persist: invalid option passed to persistStore: \"".concat(k, "\". You may be incorrectly passing persistConfig into persistStore, whereas it should be passed into persistReducer."));
      });
    }
  
    var boostrappedCb = cb || false;
  
    var _pStore = createStore(persistorReducer, initialState, options && options.enhancer ? options.enhancer : undefined);
  
    var register = function register(key) {
      _pStore.dispatch({
        type: REGISTER,
        key: key
      });
    };
  
    var rehydrate = function rehydrate(key, payload, err) {
      var rehydrateAction = {
        type: REHYDRATE,
        payload: payload,
        err: err,
        key: key // dispatch to `store` to rehydrate and `persistor` to track result
  
      };
      store.dispatch(rehydrateAction);
  
      _pStore.dispatch(rehydrateAction);
  
      if (boostrappedCb && persistor.getState().bootstrapped) {
        boostrappedCb();
        boostrappedCb = false;
      }
    };
  
    var persistor = _objectSpread({}, _pStore, {
      purge: function purge() {
        var results = [];
        store.dispatch({
          type: PURGE,
          result: function result(purgeResult) {
            results.push(purgeResult);
          }
        });
        return Promise.all(results);
      },
      flush: function flush() {
        var results = [];
        store.dispatch({
          type: FLUSH,
          result: function result(flushResult) {
            results.push(flushResult);
          }
        });
        return Promise.all(results);
      },
      pause: function pause() {
        store.dispatch({
          type: PAUSE
        });
      },
      persist: function persist() {
        store.dispatch({
          type: PERSIST,
          register: register,
          rehydrate: rehydrate
        });
      },
      resync: function resync() {
        return new Promise(function (resolve) {
          store.dispatch({
            type: RESYNC,
            rehydrate: rehydrate,
            result: function result() {
              return resolve();
            }
          });
        });
      }
    });
  
    if (!(options && options.manualPersist)) {
      persistor.persist();
    }
  
    return persistor;
  }