{"version":3,"sources":["vuex.js"],"names":["global","factory","exports","module","define","amd","Vuex","this","devtoolHook","window","__VUE_DEVTOOLS_GLOBAL_HOOK__","forEachValue","obj","fn","Object","keys","forEach","key","assert","condition","msg","Error","Module","rawModule","runtime","_children","create","rawState","_rawModule","state","prototypeAccessors$1","namespaced","configurable","get","prototype","addChild","removeChild","getChild","update","actions","mutations","getters","forEachChild","forEachGetter","forEachAction","forEachMutation","defineProperties","ModuleCollection","rawRootModule","register","path","reduce","root","getNamespace","namespace","targetModule","newModule","assertRawModule","modules","console","warn","concat","this$1","length","slice","rawChildModule","unregister","parent","Vue","functionAssert","value","expected","assertTypes","handler","assertOptions","type","buf","join","JSON","stringify","makeAssertionMessage","Store","options","install","Promise","plugins","strict","_committing","_actions","_actionSubscribers","_mutations","_wrappedGetters","_modules","_modulesNamespaceMap","_subscribers","_watcherVM","store","dispatch","commit","payload","call","installModule","resetStoreVM","plugin","config","devtools","_devtoolHook","emit","on","targetState","replaceState","subscribe","mutation","prototypeAccessors","genericSubscribe","subs","indexOf","push","i","splice","resetStore","hot","oldVm","_vm","wrappedGetters","computed","defineProperty","enumerable","silent","data","$$state","$watch","_data","deep","sync","_withCommit","nextTick","$destroy","rootState","isRoot","parentState","getNestedState","moduleName","set","noNamespace","local","context","_type","_payload","_options","args","unifyObjectStyle","error","gettersProxy","splitPos","localType","action","cb","val","res","rootGetters","then","resolve","catch","err","getter","rawGetter","registerGetter","child","_Vue","Number","version","split","mixin","beforeCreate","vuexInit","_init","init","$options","$store","applyMixin","v","ref","entry","sub","all","map","subscribeAction","watch","registerModule","Array","isArray","preserveState","unregisterModule","delete","hotUpdate","newOptions","committing","mapState","normalizeNamespace","states","normalizeMap","getModuleByNamespace","vuex","mapMutations","len","arguments","apply","mapGetters","mapActions","charAt","helper","createNamespacedHelpers","bind"],"mappings":"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","file":"vuex.js","sourcesContent":["/**\n * vuex v3.0.1\n * (c) 2017 Evan You\n * @license MIT\n */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.Vuex = factory());\n}(this, (function () { 'use strict';\n\nvar applyMixin = function (Vue) {\n  var version = Number(Vue.version.split('.')[0]);\n\n  if (version >= 2) {\n    Vue.mixin({ beforeCreate: vuexInit });\n  } else {\n    // override init and inject vuex init procedure\n    // for 1.x backwards compatibility.\n    var _init = Vue.prototype._init;\n    Vue.prototype._init = function (options) {\n      if ( options === void 0 ) options = {};\n\n      options.init = options.init\n        ? [vuexInit].concat(options.init)\n        : vuexInit;\n      _init.call(this, options);\n    };\n  }\n\n  /**\n   * Vuex init hook, injected into each instances init hooks list.\n   */\n\n  function vuexInit () {\n    var options = this.$options;\n    // store injection\n    if (options.store) {\n      this.$store = typeof options.store === 'function'\n        ? options.store()\n        : options.store;\n    } else if (options.parent && options.parent.$store) {\n      this.$store = options.parent.$store;\n    }\n  }\n};\n\nvar devtoolHook =\n  typeof window !== 'undefined' &&\n  window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\nfunction devtoolPlugin (store) {\n  if (!devtoolHook) { return }\n\n  store._devtoolHook = devtoolHook;\n\n  devtoolHook.emit('vuex:init', store);\n\n  devtoolHook.on('vuex:travel-to-state', function (targetState) {\n    store.replaceState(targetState);\n  });\n\n  store.subscribe(function (mutation, state) {\n    devtoolHook.emit('vuex:mutation', mutation, state);\n  });\n}\n\n/**\n * Get the first item that pass the test\n * by second argument function\n *\n * @param {Array} list\n * @param {Function} f\n * @return {*}\n */\n/**\n * Deep copy the given object considering circular structure.\n * This function caches all nested objects and its copies.\n * If it detects circular structure, use cached copy to avoid infinite loop.\n *\n * @param {*} obj\n * @param {Array<Object>} cache\n * @return {*}\n */\n\n\n/**\n * forEach for object\n */\nfunction forEachValue (obj, fn) {\n  Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });\n}\n\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\nfunction isPromise (val) {\n  return val && typeof val.then === 'function'\n}\n\nfunction assert (condition, msg) {\n  if (!condition) { throw new Error((\"[vuex] \" + msg)) }\n}\n\nvar Module = function Module (rawModule, runtime) {\n  this.runtime = runtime;\n  this._children = Object.create(null);\n  this._rawModule = rawModule;\n  var rawState = rawModule.state;\n  this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};\n};\n\nvar prototypeAccessors$1 = { namespaced: { configurable: true } };\n\nprototypeAccessors$1.namespaced.get = function () {\n  return !!this._rawModule.namespaced\n};\n\nModule.prototype.addChild = function addChild (key, module) {\n  this._children[key] = module;\n};\n\nModule.prototype.removeChild = function removeChild (key) {\n  delete this._children[key];\n};\n\nModule.prototype.getChild = function getChild (key) {\n  return this._children[key]\n};\n\nModule.prototype.update = function update (rawModule) {\n  this._rawModule.namespaced = rawModule.namespaced;\n  if (rawModule.actions) {\n    this._rawModule.actions = rawModule.actions;\n  }\n  if (rawModule.mutations) {\n    this._rawModule.mutations = rawModule.mutations;\n  }\n  if (rawModule.getters) {\n    this._rawModule.getters = rawModule.getters;\n  }\n};\n\nModule.prototype.forEachChild = function forEachChild (fn) {\n  forEachValue(this._children, fn);\n};\n\nModule.prototype.forEachGetter = function forEachGetter (fn) {\n  if (this._rawModule.getters) {\n    forEachValue(this._rawModule.getters, fn);\n  }\n};\n\nModule.prototype.forEachAction = function forEachAction (fn) {\n  if (this._rawModule.actions) {\n    forEachValue(this._rawModule.actions, fn);\n  }\n};\n\nModule.prototype.forEachMutation = function forEachMutation (fn) {\n  if (this._rawModule.mutations) {\n    forEachValue(this._rawModule.mutations, fn);\n  }\n};\n\nObject.defineProperties( Module.prototype, prototypeAccessors$1 );\n\nvar ModuleCollection = function ModuleCollection (rawRootModule) {\n  // register root module (Vuex.Store options)\n  this.register([], rawRootModule, false);\n};\n\nModuleCollection.prototype.get = function get (path) {\n  return path.reduce(function (module, key) {\n    return module.getChild(key)\n  }, this.root)\n};\n\nModuleCollection.prototype.getNamespace = function getNamespace (path) {\n  var module = this.root;\n  return path.reduce(function (namespace, key) {\n    module = module.getChild(key);\n    return namespace + (module.namespaced ? key + '/' : '')\n  }, '')\n};\n\nModuleCollection.prototype.update = function update$1 (rawRootModule) {\n  update([], this.root, rawRootModule);\n};\n\nModuleCollection.prototype.register = function register (path, rawModule, runtime) {\n    var this$1 = this;\n    if ( runtime === void 0 ) runtime = true;\n\n  {\n    assertRawModule(path, rawModule);\n  }\n\n  var newModule = new Module(rawModule, runtime);\n  if (path.length === 0) {\n    this.root = newModule;\n  } else {\n    var parent = this.get(path.slice(0, -1));\n    parent.addChild(path[path.length - 1], newModule);\n  }\n\n  // register nested modules\n  if (rawModule.modules) {\n    forEachValue(rawModule.modules, function (rawChildModule, key) {\n      this$1.register(path.concat(key), rawChildModule, runtime);\n    });\n  }\n};\n\nModuleCollection.prototype.unregister = function unregister (path) {\n  var parent = this.get(path.slice(0, -1));\n  var key = path[path.length - 1];\n  if (!parent.getChild(key).runtime) { return }\n\n  parent.removeChild(key);\n};\n\nfunction update (path, targetModule, newModule) {\n  {\n    assertRawModule(path, newModule);\n  }\n\n  // update target module\n  targetModule.update(newModule);\n\n  // update nested modules\n  if (newModule.modules) {\n    for (var key in newModule.modules) {\n      if (!targetModule.getChild(key)) {\n        {\n          console.warn(\n            \"[vuex] trying to add a new module '\" + key + \"' on hot reloading, \" +\n            'manual reload is needed'\n          );\n        }\n        return\n      }\n      update(\n        path.concat(key),\n        targetModule.getChild(key),\n        newModule.modules[key]\n      );\n    }\n  }\n}\n\nvar functionAssert = {\n  assert: function (value) { return typeof value === 'function'; },\n  expected: 'function'\n};\n\nvar objectAssert = {\n  assert: function (value) { return typeof value === 'function' ||\n    (typeof value === 'object' && typeof value.handler === 'function'); },\n  expected: 'function or object with \"handler\" function'\n};\n\nvar assertTypes = {\n  getters: functionAssert,\n  mutations: functionAssert,\n  actions: objectAssert\n};\n\nfunction assertRawModule (path, rawModule) {\n  Object.keys(assertTypes).forEach(function (key) {\n    if (!rawModule[key]) { return }\n\n    var assertOptions = assertTypes[key];\n\n    forEachValue(rawModule[key], function (value, type) {\n      assert(\n        assertOptions.assert(value),\n        makeAssertionMessage(path, key, type, value, assertOptions.expected)\n      );\n    });\n  });\n}\n\nfunction makeAssertionMessage (path, key, type, value, expected) {\n  var buf = key + \" should be \" + expected + \" but \\\"\" + key + \".\" + type + \"\\\"\";\n  if (path.length > 0) {\n    buf += \" in module \\\"\" + (path.join('.')) + \"\\\"\";\n  }\n  buf += \" is \" + (JSON.stringify(value)) + \".\";\n  return buf\n}\n\nvar Vue; // bind on install\n\nvar Store = function Store (options) {\n  var this$1 = this;\n  if ( options === void 0 ) options = {};\n\n  // Auto install if it is not done yet and `window` has `Vue`.\n  // To allow users to avoid auto-installation in some cases,\n  // this code should be placed here. See #731\n  if (!Vue && typeof window !== 'undefined' && window.Vue) {\n    install(window.Vue);\n  }\n\n  {\n    assert(Vue, \"must call Vue.use(Vuex) before creating a store instance.\");\n    assert(typeof Promise !== 'undefined', \"vuex requires a Promise polyfill in this browser.\");\n    assert(this instanceof Store, \"Store must be called with the new operator.\");\n  }\n\n  var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];\n  var strict = options.strict; if ( strict === void 0 ) strict = false;\n\n  var state = options.state; if ( state === void 0 ) state = {};\n  if (typeof state === 'function') {\n    state = state() || {};\n  }\n\n  // store internal state\n  this._committing = false;\n  this._actions = Object.create(null);\n  this._actionSubscribers = [];\n  this._mutations = Object.create(null);\n  this._wrappedGetters = Object.create(null);\n  this._modules = new ModuleCollection(options);\n  this._modulesNamespaceMap = Object.create(null);\n  this._subscribers = [];\n  this._watcherVM = new Vue();\n\n  // bind commit and dispatch to self\n  var store = this;\n  var ref = this;\n  var dispatch = ref.dispatch;\n  var commit = ref.commit;\n  this.dispatch = function boundDispatch (type, payload) {\n    return dispatch.call(store, type, payload)\n  };\n  this.commit = function boundCommit (type, payload, options) {\n    return commit.call(store, type, payload, options)\n  };\n\n  // strict mode\n  this.strict = strict;\n\n  // init root module.\n  // this also recursively registers all sub-modules\n  // and collects all module getters inside this._wrappedGetters\n  installModule(this, state, [], this._modules.root);\n\n  // initialize the store vm, which is responsible for the reactivity\n  // (also registers _wrappedGetters as computed properties)\n  resetStoreVM(this, state);\n\n  // apply plugins\n  plugins.forEach(function (plugin) { return plugin(this$1); });\n\n  if (Vue.config.devtools) {\n    devtoolPlugin(this);\n  }\n};\n\nvar prototypeAccessors = { state: { configurable: true } };\n\nprototypeAccessors.state.get = function () {\n  return this._vm._data.$$state\n};\n\nprototypeAccessors.state.set = function (v) {\n  {\n    assert(false, \"Use store.replaceState() to explicit replace store state.\");\n  }\n};\n\nStore.prototype.commit = function commit (_type, _payload, _options) {\n    var this$1 = this;\n\n  // check object-style commit\n  var ref = unifyObjectStyle(_type, _payload, _options);\n    var type = ref.type;\n    var payload = ref.payload;\n    var options = ref.options;\n\n  var mutation = { type: type, payload: payload };\n  var entry = this._mutations[type];\n  if (!entry) {\n    {\n      console.error((\"[vuex] unknown mutation type: \" + type));\n    }\n    return\n  }\n  this._withCommit(function () {\n    entry.forEach(function commitIterator (handler) {\n      handler(payload);\n    });\n  });\n  this._subscribers.forEach(function (sub) { return sub(mutation, this$1.state); });\n\n  if (\n    \"development\" !== 'production' &&\n    options && options.silent\n  ) {\n    console.warn(\n      \"[vuex] mutation type: \" + type + \". Silent option has been removed. \" +\n      'Use the filter functionality in the vue-devtools'\n    );\n  }\n};\n\nStore.prototype.dispatch = function dispatch (_type, _payload) {\n    var this$1 = this;\n\n  // check object-style dispatch\n  var ref = unifyObjectStyle(_type, _payload);\n    var type = ref.type;\n    var payload = ref.payload;\n\n  var action = { type: type, payload: payload };\n  var entry = this._actions[type];\n  if (!entry) {\n    {\n      console.error((\"[vuex] unknown action type: \" + type));\n    }\n    return\n  }\n\n  this._actionSubscribers.forEach(function (sub) { return sub(action, this$1.state); });\n\n  return entry.length > 1\n    ? Promise.all(entry.map(function (handler) { return handler(payload); }))\n    : entry[0](payload)\n};\n\nStore.prototype.subscribe = function subscribe (fn) {\n  return genericSubscribe(fn, this._subscribers)\n};\n\nStore.prototype.subscribeAction = function subscribeAction (fn) {\n  return genericSubscribe(fn, this._actionSubscribers)\n};\n\nStore.prototype.watch = function watch (getter, cb, options) {\n    var this$1 = this;\n\n  {\n    assert(typeof getter === 'function', \"store.watch only accepts a function.\");\n  }\n  return this._watcherVM.$watch(function () { return getter(this$1.state, this$1.getters); }, cb, options)\n};\n\nStore.prototype.replaceState = function replaceState (state) {\n    var this$1 = this;\n\n  this._withCommit(function () {\n    this$1._vm._data.$$state = state;\n  });\n};\n\nStore.prototype.registerModule = function registerModule (path, rawModule, options) {\n    if ( options === void 0 ) options = {};\n\n  if (typeof path === 'string') { path = [path]; }\n\n  {\n    assert(Array.isArray(path), \"module path must be a string or an Array.\");\n    assert(path.length > 0, 'cannot register the root module by using registerModule.');\n  }\n\n  this._modules.register(path, rawModule);\n  installModule(this, this.state, path, this._modules.get(path), options.preserveState);\n  // reset store to update getters...\n  resetStoreVM(this, this.state);\n};\n\nStore.prototype.unregisterModule = function unregisterModule (path) {\n    var this$1 = this;\n\n  if (typeof path === 'string') { path = [path]; }\n\n  {\n    assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  }\n\n  this._modules.unregister(path);\n  this._withCommit(function () {\n    var parentState = getNestedState(this$1.state, path.slice(0, -1));\n    Vue.delete(parentState, path[path.length - 1]);\n  });\n  resetStore(this);\n};\n\nStore.prototype.hotUpdate = function hotUpdate (newOptions) {\n  this._modules.update(newOptions);\n  resetStore(this, true);\n};\n\nStore.prototype._withCommit = function _withCommit (fn) {\n  var committing = this._committing;\n  this._committing = true;\n  fn();\n  this._committing = committing;\n};\n\nObject.defineProperties( Store.prototype, prototypeAccessors );\n\nfunction genericSubscribe (fn, subs) {\n  if (subs.indexOf(fn) < 0) {\n    subs.push(fn);\n  }\n  return function () {\n    var i = subs.indexOf(fn);\n    if (i > -1) {\n      subs.splice(i, 1);\n    }\n  }\n}\n\nfunction resetStore (store, hot) {\n  store._actions = Object.create(null);\n  store._mutations = Object.create(null);\n  store._wrappedGetters = Object.create(null);\n  store._modulesNamespaceMap = Object.create(null);\n  var state = store.state;\n  // init all modules\n  installModule(store, state, [], store._modules.root, true);\n  // reset vm\n  resetStoreVM(store, state, hot);\n}\n\nfunction resetStoreVM (store, state, hot) {\n  var oldVm = store._vm;\n\n  // bind store public getters\n  store.getters = {};\n  var wrappedGetters = store._wrappedGetters;\n  var computed = {};\n  forEachValue(wrappedGetters, function (fn, key) {\n    // use computed to leverage its lazy-caching mechanism\n    computed[key] = function () { return fn(store); };\n    Object.defineProperty(store.getters, key, {\n      get: function () { return store._vm[key]; },\n      enumerable: true // for local getters\n    });\n  });\n\n  // use a Vue instance to store the state tree\n  // suppress warnings just in case the user has added\n  // some funky global mixins\n  var silent = Vue.config.silent;\n  Vue.config.silent = true;\n  store._vm = new Vue({\n    data: {\n      $$state: state\n    },\n    computed: computed\n  });\n  Vue.config.silent = silent;\n\n  // enable strict mode for new vm\n  if (store.strict) {\n    enableStrictMode(store);\n  }\n\n  if (oldVm) {\n    if (hot) {\n      // dispatch changes in all subscribed watchers\n      // to force getter re-evaluation for hot reloading.\n      store._withCommit(function () {\n        oldVm._data.$$state = null;\n      });\n    }\n    Vue.nextTick(function () { return oldVm.$destroy(); });\n  }\n}\n\nfunction installModule (store, rootState, path, module, hot) {\n  var isRoot = !path.length;\n  var namespace = store._modules.getNamespace(path);\n\n  // register in namespace map\n  if (module.namespaced) {\n    store._modulesNamespaceMap[namespace] = module;\n  }\n\n  // set state\n  if (!isRoot && !hot) {\n    var parentState = getNestedState(rootState, path.slice(0, -1));\n    var moduleName = path[path.length - 1];\n    store._withCommit(function () {\n      Vue.set(parentState, moduleName, module.state);\n    });\n  }\n\n  var local = module.context = makeLocalContext(store, namespace, path);\n\n  module.forEachMutation(function (mutation, key) {\n    var namespacedType = namespace + key;\n    registerMutation(store, namespacedType, mutation, local);\n  });\n\n  module.forEachAction(function (action, key) {\n    var type = action.root ? key : namespace + key;\n    var handler = action.handler || action;\n    registerAction(store, type, handler, local);\n  });\n\n  module.forEachGetter(function (getter, key) {\n    var namespacedType = namespace + key;\n    registerGetter(store, namespacedType, getter, local);\n  });\n\n  module.forEachChild(function (child, key) {\n    installModule(store, rootState, path.concat(key), child, hot);\n  });\n}\n\n/**\n * make localized dispatch, commit, getters and state\n * if there is no namespace, just use root ones\n */\nfunction makeLocalContext (store, namespace, path) {\n  var noNamespace = namespace === '';\n\n  var local = {\n    dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (\"development\" !== 'production' && !store._actions[type]) {\n          console.error((\"[vuex] unknown local action type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      return store.dispatch(type, payload)\n    },\n\n    commit: noNamespace ? store.commit : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (\"development\" !== 'production' && !store._mutations[type]) {\n          console.error((\"[vuex] unknown local mutation type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      store.commit(type, payload, options);\n    }\n  };\n\n  // getters and state object must be gotten lazily\n  // because they will be changed by vm update\n  Object.defineProperties(local, {\n    getters: {\n      get: noNamespace\n        ? function () { return store.getters; }\n        : function () { return makeLocalGetters(store, namespace); }\n    },\n    state: {\n      get: function () { return getNestedState(store.state, path); }\n    }\n  });\n\n  return local\n}\n\nfunction makeLocalGetters (store, namespace) {\n  var gettersProxy = {};\n\n  var splitPos = namespace.length;\n  Object.keys(store.getters).forEach(function (type) {\n    // skip if the target getter is not match this namespace\n    if (type.slice(0, splitPos) !== namespace) { return }\n\n    // extract local getter type\n    var localType = type.slice(splitPos);\n\n    // Add a port to the getters proxy.\n    // Define as getter property because\n    // we do not want to evaluate the getters in this time.\n    Object.defineProperty(gettersProxy, localType, {\n      get: function () { return store.getters[type]; },\n      enumerable: true\n    });\n  });\n\n  return gettersProxy\n}\n\nfunction registerMutation (store, type, handler, local) {\n  var entry = store._mutations[type] || (store._mutations[type] = []);\n  entry.push(function wrappedMutationHandler (payload) {\n    handler.call(store, local.state, payload);\n  });\n}\n\nfunction registerAction (store, type, handler, local) {\n  var entry = store._actions[type] || (store._actions[type] = []);\n  entry.push(function wrappedActionHandler (payload, cb) {\n    var res = handler.call(store, {\n      dispatch: local.dispatch,\n      commit: local.commit,\n      getters: local.getters,\n      state: local.state,\n      rootGetters: store.getters,\n      rootState: store.state\n    }, payload, cb);\n    if (!isPromise(res)) {\n      res = Promise.resolve(res);\n    }\n    if (store._devtoolHook) {\n      return res.catch(function (err) {\n        store._devtoolHook.emit('vuex:error', err);\n        throw err\n      })\n    } else {\n      return res\n    }\n  });\n}\n\nfunction registerGetter (store, type, rawGetter, local) {\n  if (store._wrappedGetters[type]) {\n    {\n      console.error((\"[vuex] duplicate getter key: \" + type));\n    }\n    return\n  }\n  store._wrappedGetters[type] = function wrappedGetter (store) {\n    return rawGetter(\n      local.state, // local state\n      local.getters, // local getters\n      store.state, // root state\n      store.getters // root getters\n    )\n  };\n}\n\nfunction enableStrictMode (store) {\n  store._vm.$watch(function () { return this._data.$$state }, function () {\n    {\n      assert(store._committing, \"Do not mutate vuex store state outside mutation handlers.\");\n    }\n  }, { deep: true, sync: true });\n}\n\nfunction getNestedState (state, path) {\n  return path.length\n    ? path.reduce(function (state, key) { return state[key]; }, state)\n    : state\n}\n\nfunction unifyObjectStyle (type, payload, options) {\n  if (isObject(type) && type.type) {\n    options = payload;\n    payload = type;\n    type = type.type;\n  }\n\n  {\n    assert(typeof type === 'string', (\"Expects string as the type, but found \" + (typeof type) + \".\"));\n  }\n\n  return { type: type, payload: payload, options: options }\n}\n\nfunction install (_Vue) {\n  if (Vue && _Vue === Vue) {\n    {\n      console.error(\n        '[vuex] already installed. Vue.use(Vuex) should be called only once.'\n      );\n    }\n    return\n  }\n  Vue = _Vue;\n  applyMixin(Vue);\n}\n\nvar mapState = normalizeNamespace(function (namespace, states) {\n  var res = {};\n  normalizeMap(states).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedState () {\n      var state = this.$store.state;\n      var getters = this.$store.getters;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapState', namespace);\n        if (!module) {\n          return\n        }\n        state = module.context.state;\n        getters = module.context.getters;\n      }\n      return typeof val === 'function'\n        ? val.call(this, state, getters)\n        : state[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapMutations = normalizeNamespace(function (namespace, mutations) {\n  var res = {};\n  normalizeMap(mutations).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedMutation () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      var commit = this.$store.commit;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapMutations', namespace);\n        if (!module) {\n          return\n        }\n        commit = module.context.commit;\n      }\n      return typeof val === 'function'\n        ? val.apply(this, [commit].concat(args))\n        : commit.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nvar mapGetters = normalizeNamespace(function (namespace, getters) {\n  var res = {};\n  normalizeMap(getters).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedGetter () {\n      if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {\n        return\n      }\n      if (\"development\" !== 'production' && !(val in this.$store.getters)) {\n        console.error((\"[vuex] unknown getter: \" + val));\n        return\n      }\n      return this.$store.getters[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapActions = normalizeNamespace(function (namespace, actions) {\n  var res = {};\n  normalizeMap(actions).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedAction () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      var dispatch = this.$store.dispatch;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapActions', namespace);\n        if (!module) {\n          return\n        }\n        dispatch = module.context.dispatch;\n      }\n      return typeof val === 'function'\n        ? val.apply(this, [dispatch].concat(args))\n        : dispatch.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nvar createNamespacedHelpers = function (namespace) { return ({\n  mapState: mapState.bind(null, namespace),\n  mapGetters: mapGetters.bind(null, namespace),\n  mapMutations: mapMutations.bind(null, namespace),\n  mapActions: mapActions.bind(null, namespace)\n}); };\n\nfunction normalizeMap (map) {\n  return Array.isArray(map)\n    ? map.map(function (key) { return ({ key: key, val: key }); })\n    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })\n}\n\nfunction normalizeNamespace (fn) {\n  return function (namespace, map) {\n    if (typeof namespace !== 'string') {\n      map = namespace;\n      namespace = '';\n    } else if (namespace.charAt(namespace.length - 1) !== '/') {\n      namespace += '/';\n    }\n    return fn(namespace, map)\n  }\n}\n\nfunction getModuleByNamespace (store, helper, namespace) {\n  var module = store._modulesNamespaceMap[namespace];\n  if (\"development\" !== 'production' && !module) {\n    console.error((\"[vuex] module namespace not found in \" + helper + \"(): \" + namespace));\n  }\n  return module\n}\n\nvar index = {\n  Store: Store,\n  install: install,\n  version: '3.0.1',\n  mapState: mapState,\n  mapMutations: mapMutations,\n  mapGetters: mapGetters,\n  mapActions: mapActions,\n  createNamespacedHelpers: createNamespacedHelpers\n};\n\nreturn index;\n\n})));\n"]}