service-flow-designer 0.0.1-beta.5 → 0.0.2-tmp10

package/dist/es/node_modules/.pnpm/vuex@4.1.0_vue@3.4.27/node_modules/vuex/dist/vuex.esm-bundler.js

@@ -1,989 +0,0 @@
-import { watch, effectScope, reactive, computed } from "vue";
-import { setupDevtoolsPlugin } from "../../../../@vue_devtools-api@6.6.3/node_modules/@vue/devtools-api/lib/esm/index.js";
-/*!
- * vuex v4.1.0
- * (c) 2022 Evan You
- * @license MIT
- */
-var storeKey = "store";
-function forEachValue(obj, fn) {
-  Object.keys(obj).forEach(function(key) {
-    return fn(obj[key], key);
-  });
-}
-function isObject(obj) {
-  return obj !== null && typeof obj === "object";
-}
-function isPromise(val) {
-  return val && typeof val.then === "function";
-}
-function assert(condition, msg) {
-  if (!condition) {
-    throw new Error("[vuex] " + msg);
-  }
-}
-function partial(fn, arg) {
-  return function() {
-    return fn(arg);
-  };
-}
-function genericSubscribe(fn, subs, options) {
-  if (subs.indexOf(fn) < 0) {
-    options && options.prepend ? subs.unshift(fn) : subs.push(fn);
-  }
-  return function() {
-    var i = subs.indexOf(fn);
-    if (i > -1) {
-      subs.splice(i, 1);
-    }
-  };
-}
-function resetStore(store, hot) {
-  store._actions = /* @__PURE__ */ Object.create(null);
-  store._mutations = /* @__PURE__ */ Object.create(null);
-  store._wrappedGetters = /* @__PURE__ */ Object.create(null);
-  store._modulesNamespaceMap = /* @__PURE__ */ Object.create(null);
-  var state = store.state;
-  installModule(store, state, [], store._modules.root, true);
-  resetStoreState(store, state, hot);
-}
-function resetStoreState(store, state, hot) {
-  var oldState = store._state;
-  var oldScope = store._scope;
-  store.getters = {};
-  store._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
-  var wrappedGetters = store._wrappedGetters;
-  var computedObj = {};
-  var computedCache = {};
-  var scope = effectScope(true);
-  scope.run(function() {
-    forEachValue(wrappedGetters, function(fn, key) {
-      computedObj[key] = partial(fn, store);
-      computedCache[key] = computed(function() {
-        return computedObj[key]();
-      });
-      Object.defineProperty(store.getters, key, {
-        get: function() {
-          return computedCache[key].value;
-        },
-        enumerable: true
-        // for local getters
-      });
-    });
-  });
-  store._state = reactive({
-    data: state
-  });
-  store._scope = scope;
-  if (store.strict) {
-    enableStrictMode(store);
-  }
-  if (oldState) {
-    if (hot) {
-      store._withCommit(function() {
-        oldState.data = null;
-      });
-    }
-  }
-  if (oldScope) {
-    oldScope.stop();
-  }
-}
-function installModule(store, rootState, path, module, hot) {
-  var isRoot = !path.length;
-  var namespace = store._modules.getNamespace(path);
-  if (module.namespaced) {
-    if (store._modulesNamespaceMap[namespace] && process.env.NODE_ENV !== "production") {
-      console.error("[vuex] duplicate namespace " + namespace + " for the namespaced module " + path.join("/"));
-    }
-    store._modulesNamespaceMap[namespace] = module;
-  }
-  if (!isRoot && !hot) {
-    var parentState = getNestedState(rootState, path.slice(0, -1));
-    var moduleName = path[path.length - 1];
-    store._withCommit(function() {
-      if (process.env.NODE_ENV !== "production") {
-        if (moduleName in parentState) {
-          console.warn(
-            '[vuex] state field "' + moduleName + '" was overridden by a module with the same name at "' + path.join(".") + '"'
-          );
-        }
-      }
-      parentState[moduleName] = module.state;
-    });
-  }
-  var local = module.context = makeLocalContext(store, namespace, path);
-  module.forEachMutation(function(mutation, key) {
-    var namespacedType = namespace + key;
-    registerMutation(store, namespacedType, mutation, local);
-  });
-  module.forEachAction(function(action, key) {
-    var type = action.root ? key : namespace + key;
-    var handler = action.handler || action;
-    registerAction(store, type, handler, local);
-  });
-  module.forEachGetter(function(getter, key) {
-    var namespacedType = namespace + key;
-    registerGetter(store, namespacedType, getter, local);
-  });
-  module.forEachChild(function(child, key) {
-    installModule(store, rootState, path.concat(key), child, hot);
-  });
-}
-function makeLocalContext(store, namespace, path) {
-  var noNamespace = namespace === "";
-  var local = {
-    dispatch: noNamespace ? store.dispatch : function(_type, _payload, _options) {
-      var args = unifyObjectStyle(_type, _payload, _options);
-      var payload = args.payload;
-      var options = args.options;
-      var type = args.type;
-      if (!options || !options.root) {
-        type = namespace + type;
-        if (process.env.NODE_ENV !== "production" && !store._actions[type]) {
-          console.error("[vuex] unknown local action type: " + args.type + ", global type: " + type);
-          return;
-        }
-      }
-      return store.dispatch(type, payload);
-    },
-    commit: noNamespace ? store.commit : function(_type, _payload, _options) {
-      var args = unifyObjectStyle(_type, _payload, _options);
-      var payload = args.payload;
-      var options = args.options;
-      var type = args.type;
-      if (!options || !options.root) {
-        type = namespace + type;
-        if (process.env.NODE_ENV !== "production" && !store._mutations[type]) {
-          console.error("[vuex] unknown local mutation type: " + args.type + ", global type: " + type);
-          return;
-        }
-      }
-      store.commit(type, payload, options);
-    }
-  };
-  Object.defineProperties(local, {
-    getters: {
-      get: noNamespace ? function() {
-        return store.getters;
-      } : function() {
-        return makeLocalGetters(store, namespace);
-      }
-    },
-    state: {
-      get: function() {
-        return getNestedState(store.state, path);
-      }
-    }
-  });
-  return local;
-}
-function makeLocalGetters(store, namespace) {
-  if (!store._makeLocalGettersCache[namespace]) {
-    var gettersProxy = {};
-    var splitPos = namespace.length;
-    Object.keys(store.getters).forEach(function(type) {
-      if (type.slice(0, splitPos) !== namespace) {
-        return;
-      }
-      var localType = type.slice(splitPos);
-      Object.defineProperty(gettersProxy, localType, {
-        get: function() {
-          return store.getters[type];
-        },
-        enumerable: true
-      });
-    });
-    store._makeLocalGettersCache[namespace] = gettersProxy;
-  }
-  return store._makeLocalGettersCache[namespace];
-}
-function registerMutation(store, type, handler, local) {
-  var entry = store._mutations[type] || (store._mutations[type] = []);
-  entry.push(function wrappedMutationHandler(payload) {
-    handler.call(store, local.state, payload);
-  });
-}
-function registerAction(store, type, handler, local) {
-  var entry = store._actions[type] || (store._actions[type] = []);
-  entry.push(function wrappedActionHandler(payload) {
-    var res = handler.call(store, {
-      dispatch: local.dispatch,
-      commit: local.commit,
-      getters: local.getters,
-      state: local.state,
-      rootGetters: store.getters,
-      rootState: store.state
-    }, payload);
-    if (!isPromise(res)) {
-      res = Promise.resolve(res);
-    }
-    if (store._devtoolHook) {
-      return res.catch(function(err) {
-        store._devtoolHook.emit("vuex:error", err);
-        throw err;
-      });
-    } else {
-      return res;
-    }
-  });
-}
-function registerGetter(store, type, rawGetter, local) {
-  if (store._wrappedGetters[type]) {
-    if (process.env.NODE_ENV !== "production") {
-      console.error("[vuex] duplicate getter key: " + type);
-    }
-    return;
-  }
-  store._wrappedGetters[type] = function wrappedGetter(store2) {
-    return rawGetter(
-      local.state,
-      // local state
-      local.getters,
-      // local getters
-      store2.state,
-      // root state
-      store2.getters
-      // root getters
-    );
-  };
-}
-function enableStrictMode(store) {
-  watch(function() {
-    return store._state.data;
-  }, function() {
-    if (process.env.NODE_ENV !== "production") {
-      assert(store._committing, "do not mutate vuex store state outside mutation handlers.");
-    }
-  }, { deep: true, flush: "sync" });
-}
-function getNestedState(state, path) {
-  return path.reduce(function(state2, key) {
-    return state2[key];
-  }, state);
-}
-function unifyObjectStyle(type, payload, options) {
-  if (isObject(type) && type.type) {
-    options = payload;
-    payload = type;
-    type = type.type;
-  }
-  if (process.env.NODE_ENV !== "production") {
-    assert(typeof type === "string", "expects string as the type, but found " + typeof type + ".");
-  }
-  return { type, payload, options };
-}
-var LABEL_VUEX_BINDINGS = "vuex bindings";
-var MUTATIONS_LAYER_ID = "vuex:mutations";
-var ACTIONS_LAYER_ID = "vuex:actions";
-var INSPECTOR_ID = "vuex";
-var actionId = 0;
-function addDevtools(app, store) {
-  setupDevtoolsPlugin(
-    {
-      id: "org.vuejs.vuex",
-      app,
-      label: "Vuex",
-      homepage: "https://next.vuex.vuejs.org/",
-      logo: "https://vuejs.org/images/icons/favicon-96x96.png",
-      packageName: "vuex",
-      componentStateTypes: [LABEL_VUEX_BINDINGS]
-    },
-    function(api) {
-      api.addTimelineLayer({
-        id: MUTATIONS_LAYER_ID,
-        label: "Vuex Mutations",
-        color: COLOR_LIME_500
-      });
-      api.addTimelineLayer({
-        id: ACTIONS_LAYER_ID,
-        label: "Vuex Actions",
-        color: COLOR_LIME_500
-      });
-      api.addInspector({
-        id: INSPECTOR_ID,
-        label: "Vuex",
-        icon: "storage",
-        treeFilterPlaceholder: "Filter stores..."
-      });
-      api.on.getInspectorTree(function(payload) {
-        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
-          if (payload.filter) {
-            var nodes = [];
-            flattenStoreForInspectorTree(nodes, store._modules.root, payload.filter, "");
-            payload.rootNodes = nodes;
-          } else {
-            payload.rootNodes = [
-              formatStoreForInspectorTree(store._modules.root, "")
-            ];
-          }
-        }
-      });
-      api.on.getInspectorState(function(payload) {
-        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
-          var modulePath = payload.nodeId;
-          makeLocalGetters(store, modulePath);
-          payload.state = formatStoreForInspectorState(
-            getStoreModule(store._modules, modulePath),
-            modulePath === "root" ? store.getters : store._makeLocalGettersCache,
-            modulePath
-          );
-        }
-      });
-      api.on.editInspectorState(function(payload) {
-        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
-          var modulePath = payload.nodeId;
-          var path = payload.path;
-          if (modulePath !== "root") {
-            path = modulePath.split("/").filter(Boolean).concat(path);
-          }
-          store._withCommit(function() {
-            payload.set(store._state.data, path, payload.state.value);
-          });
-        }
-      });
-      store.subscribe(function(mutation, state) {
-        var data = {};
-        if (mutation.payload) {
-          data.payload = mutation.payload;
-        }
-        data.state = state;
-        api.notifyComponentUpdate();
-        api.sendInspectorTree(INSPECTOR_ID);
-        api.sendInspectorState(INSPECTOR_ID);
-        api.addTimelineEvent({
-          layerId: MUTATIONS_LAYER_ID,
-          event: {
-            time: Date.now(),
-            title: mutation.type,
-            data
-          }
-        });
-      });
-      store.subscribeAction({
-        before: function(action, state) {
-          var data = {};
-          if (action.payload) {
-            data.payload = action.payload;
-          }
-          action._id = actionId++;
-          action._time = Date.now();
-          data.state = state;
-          api.addTimelineEvent({
-            layerId: ACTIONS_LAYER_ID,
-            event: {
-              time: action._time,
-              title: action.type,
-              groupId: action._id,
-              subtitle: "start",
-              data
-            }
-          });
-        },
-        after: function(action, state) {
-          var data = {};
-          var duration = Date.now() - action._time;
-          data.duration = {
-            _custom: {
-              type: "duration",
-              display: duration + "ms",
-              tooltip: "Action duration",
-              value: duration
-            }
-          };
-          if (action.payload) {
-            data.payload = action.payload;
-          }
-          data.state = state;
-          api.addTimelineEvent({
-            layerId: ACTIONS_LAYER_ID,
-            event: {
-              time: Date.now(),
-              title: action.type,
-              groupId: action._id,
-              subtitle: "end",
-              data
-            }
-          });
-        }
-      });
-    }
-  );
-}
-var COLOR_LIME_500 = 8702998;
-var COLOR_DARK = 6710886;
-var COLOR_WHITE = 16777215;
-var TAG_NAMESPACED = {
-  label: "namespaced",
-  textColor: COLOR_WHITE,
-  backgroundColor: COLOR_DARK
-};
-function extractNameFromPath(path) {
-  return path && path !== "root" ? path.split("/").slice(-2, -1)[0] : "Root";
-}
-function formatStoreForInspectorTree(module, path) {
-  return {
-    id: path || "root",
-    // all modules end with a `/`, we want the last segment only
-    // cart/ -> cart
-    // nested/cart/ -> cart
-    label: extractNameFromPath(path),
-    tags: module.namespaced ? [TAG_NAMESPACED] : [],
-    children: Object.keys(module._children).map(
-      function(moduleName) {
-        return formatStoreForInspectorTree(
-          module._children[moduleName],
-          path + moduleName + "/"
-        );
-      }
-    )
-  };
-}
-function flattenStoreForInspectorTree(result, module, filter, path) {
-  if (path.includes(filter)) {
-    result.push({
-      id: path || "root",
-      label: path.endsWith("/") ? path.slice(0, path.length - 1) : path || "Root",
-      tags: module.namespaced ? [TAG_NAMESPACED] : []
-    });
-  }
-  Object.keys(module._children).forEach(function(moduleName) {
-    flattenStoreForInspectorTree(result, module._children[moduleName], filter, path + moduleName + "/");
-  });
-}
-function formatStoreForInspectorState(module, getters, path) {
-  getters = path === "root" ? getters : getters[path];
-  var gettersKeys = Object.keys(getters);
-  var storeState = {
-    state: Object.keys(module.state).map(function(key) {
-      return {
-        key,
-        editable: true,
-        value: module.state[key]
-      };
-    })
-  };
-  if (gettersKeys.length) {
-    var tree = transformPathsToObjectTree(getters);
-    storeState.getters = Object.keys(tree).map(function(key) {
-      return {
-        key: key.endsWith("/") ? extractNameFromPath(key) : key,
-        editable: false,
-        value: canThrow(function() {
-          return tree[key];
-        })
-      };
-    });
-  }
-  return storeState;
-}
-function transformPathsToObjectTree(getters) {
-  var result = {};
-  Object.keys(getters).forEach(function(key) {
-    var path = key.split("/");
-    if (path.length > 1) {
-      var target = result;
-      var leafKey = path.pop();
-      path.forEach(function(p) {
-        if (!target[p]) {
-          target[p] = {
-            _custom: {
-              value: {},
-              display: p,
-              tooltip: "Module",
-              abstract: true
-            }
-          };
-        }
-        target = target[p]._custom.value;
-      });
-      target[leafKey] = canThrow(function() {
-        return getters[key];
-      });
-    } else {
-      result[key] = canThrow(function() {
-        return getters[key];
-      });
-    }
-  });
-  return result;
-}
-function getStoreModule(moduleMap, path) {
-  var names = path.split("/").filter(function(n) {
-    return n;
-  });
-  return names.reduce(
-    function(module, moduleName, i) {
-      var child = module[moduleName];
-      if (!child) {
-        throw new Error('Missing module "' + moduleName + '" for path "' + path + '".');
-      }
-      return i === names.length - 1 ? child : child._children;
-    },
-    path === "root" ? moduleMap : moduleMap.root._children
-  );
-}
-function canThrow(cb) {
-  try {
-    return cb();
-  } catch (e) {
-    return e;
-  }
-}
-var Module = function Module2(rawModule, runtime) {
-  this.runtime = runtime;
-  this._children = /* @__PURE__ */ Object.create(null);
-  this._rawModule = rawModule;
-  var rawState = rawModule.state;
-  this.state = (typeof rawState === "function" ? rawState() : rawState) || {};
-};
-var prototypeAccessors$1 = { namespaced: { configurable: true } };
-prototypeAccessors$1.namespaced.get = function() {
-  return !!this._rawModule.namespaced;
-};
-Module.prototype.addChild = function addChild(key, module) {
-  this._children[key] = module;
-};
-Module.prototype.removeChild = function removeChild(key) {
-  delete this._children[key];
-};
-Module.prototype.getChild = function getChild(key) {
-  return this._children[key];
-};
-Module.prototype.hasChild = function hasChild(key) {
-  return key in this._children;
-};
-Module.prototype.update = function update(rawModule) {
-  this._rawModule.namespaced = rawModule.namespaced;
-  if (rawModule.actions) {
-    this._rawModule.actions = rawModule.actions;
-  }
-  if (rawModule.mutations) {
-    this._rawModule.mutations = rawModule.mutations;
-  }
-  if (rawModule.getters) {
-    this._rawModule.getters = rawModule.getters;
-  }
-};
-Module.prototype.forEachChild = function forEachChild(fn) {
-  forEachValue(this._children, fn);
-};
-Module.prototype.forEachGetter = function forEachGetter(fn) {
-  if (this._rawModule.getters) {
-    forEachValue(this._rawModule.getters, fn);
-  }
-};
-Module.prototype.forEachAction = function forEachAction(fn) {
-  if (this._rawModule.actions) {
-    forEachValue(this._rawModule.actions, fn);
-  }
-};
-Module.prototype.forEachMutation = function forEachMutation(fn) {
-  if (this._rawModule.mutations) {
-    forEachValue(this._rawModule.mutations, fn);
-  }
-};
-Object.defineProperties(Module.prototype, prototypeAccessors$1);
-var ModuleCollection = function ModuleCollection2(rawRootModule) {
-  this.register([], rawRootModule, false);
-};
-ModuleCollection.prototype.get = function get(path) {
-  return path.reduce(function(module, key) {
-    return module.getChild(key);
-  }, this.root);
-};
-ModuleCollection.prototype.getNamespace = function getNamespace(path) {
-  var module = this.root;
-  return path.reduce(function(namespace, key) {
-    module = module.getChild(key);
-    return namespace + (module.namespaced ? key + "/" : "");
-  }, "");
-};
-ModuleCollection.prototype.update = function update$1(rawRootModule) {
-  update2([], this.root, rawRootModule);
-};
-ModuleCollection.prototype.register = function register(path, rawModule, runtime) {
-  var this$1$1 = this;
-  if (runtime === void 0) runtime = true;
-  if (process.env.NODE_ENV !== "production") {
-    assertRawModule(path, rawModule);
-  }
-  var newModule = new Module(rawModule, runtime);
-  if (path.length === 0) {
-    this.root = newModule;
-  } else {
-    var parent = this.get(path.slice(0, -1));
-    parent.addChild(path[path.length - 1], newModule);
-  }
-  if (rawModule.modules) {
-    forEachValue(rawModule.modules, function(rawChildModule, key) {
-      this$1$1.register(path.concat(key), rawChildModule, runtime);
-    });
-  }
-};
-ModuleCollection.prototype.unregister = function unregister(path) {
-  var parent = this.get(path.slice(0, -1));
-  var key = path[path.length - 1];
-  var child = parent.getChild(key);
-  if (!child) {
-    if (process.env.NODE_ENV !== "production") {
-      console.warn(
-        "[vuex] trying to unregister module '" + key + "', which is not registered"
-      );
-    }
-    return;
-  }
-  if (!child.runtime) {
-    return;
-  }
-  parent.removeChild(key);
-};
-ModuleCollection.prototype.isRegistered = function isRegistered(path) {
-  var parent = this.get(path.slice(0, -1));
-  var key = path[path.length - 1];
-  if (parent) {
-    return parent.hasChild(key);
-  }
-  return false;
-};
-function update2(path, targetModule, newModule) {
-  if (process.env.NODE_ENV !== "production") {
-    assertRawModule(path, newModule);
-  }
-  targetModule.update(newModule);
-  if (newModule.modules) {
-    for (var key in newModule.modules) {
-      if (!targetModule.getChild(key)) {
-        if (process.env.NODE_ENV !== "production") {
-          console.warn(
-            "[vuex] trying to add a new module '" + key + "' on hot reloading, manual reload is needed"
-          );
-        }
-        return;
-      }
-      update2(
-        path.concat(key),
-        targetModule.getChild(key),
-        newModule.modules[key]
-      );
-    }
-  }
-}
-var functionAssert = {
-  assert: function(value) {
-    return typeof value === "function";
-  },
-  expected: "function"
-};
-var objectAssert = {
-  assert: function(value) {
-    return typeof value === "function" || typeof value === "object" && typeof value.handler === "function";
-  },
-  expected: 'function or object with "handler" function'
-};
-var assertTypes = {
-  getters: functionAssert,
-  mutations: functionAssert,
-  actions: objectAssert
-};
-function assertRawModule(path, rawModule) {
-  Object.keys(assertTypes).forEach(function(key) {
-    if (!rawModule[key]) {
-      return;
-    }
-    var assertOptions = assertTypes[key];
-    forEachValue(rawModule[key], function(value, type) {
-      assert(
-        assertOptions.assert(value),
-        makeAssertionMessage(path, key, type, value, assertOptions.expected)
-      );
-    });
-  });
-}
-function makeAssertionMessage(path, key, type, value, expected) {
-  var buf = key + " should be " + expected + ' but "' + key + "." + type + '"';
-  if (path.length > 0) {
-    buf += ' in module "' + path.join(".") + '"';
-  }
-  buf += " is " + JSON.stringify(value) + ".";
-  return buf;
-}
-function createStore(options) {
-  return new Store(options);
-}
-var Store = function Store2(options) {
-  var this$1$1 = this;
-  if (options === void 0) options = {};
-  if (process.env.NODE_ENV !== "production") {
-    assert(typeof Promise !== "undefined", "vuex requires a Promise polyfill in this browser.");
-    assert(this instanceof Store2, "store must be called with the new operator.");
-  }
-  var plugins = options.plugins;
-  if (plugins === void 0) plugins = [];
-  var strict = options.strict;
-  if (strict === void 0) strict = false;
-  var devtools = options.devtools;
-  this._committing = false;
-  this._actions = /* @__PURE__ */ Object.create(null);
-  this._actionSubscribers = [];
-  this._mutations = /* @__PURE__ */ Object.create(null);
-  this._wrappedGetters = /* @__PURE__ */ Object.create(null);
-  this._modules = new ModuleCollection(options);
-  this._modulesNamespaceMap = /* @__PURE__ */ Object.create(null);
-  this._subscribers = [];
-  this._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
-  this._scope = null;
-  this._devtools = devtools;
-  var store = this;
-  var ref = this;
-  var dispatch2 = ref.dispatch;
-  var commit2 = ref.commit;
-  this.dispatch = function boundDispatch(type, payload) {
-    return dispatch2.call(store, type, payload);
-  };
-  this.commit = function boundCommit(type, payload, options2) {
-    return commit2.call(store, type, payload, options2);
-  };
-  this.strict = strict;
-  var state = this._modules.root.state;
-  installModule(this, state, [], this._modules.root);
-  resetStoreState(this, state);
-  plugins.forEach(function(plugin) {
-    return plugin(this$1$1);
-  });
-};
-var prototypeAccessors = { state: { configurable: true } };
-Store.prototype.install = function install(app, injectKey) {
-  app.provide(injectKey || storeKey, this);
-  app.config.globalProperties.$store = this;
-  var useDevtools = this._devtools !== void 0 ? this._devtools : process.env.NODE_ENV !== "production" || false;
-  if (useDevtools) {
-    addDevtools(app, this);
-  }
-};
-prototypeAccessors.state.get = function() {
-  return this._state.data;
-};
-prototypeAccessors.state.set = function(v) {
-  if (process.env.NODE_ENV !== "production") {
-    assert(false, "use store.replaceState() to explicit replace store state.");
-  }
-};
-Store.prototype.commit = function commit(_type, _payload, _options) {
-  var this$1$1 = this;
-  var ref = unifyObjectStyle(_type, _payload, _options);
-  var type = ref.type;
-  var payload = ref.payload;
-  var options = ref.options;
-  var mutation = { type, payload };
-  var entry = this._mutations[type];
-  if (!entry) {
-    if (process.env.NODE_ENV !== "production") {
-      console.error("[vuex] unknown mutation type: " + type);
-    }
-    return;
-  }
-  this._withCommit(function() {
-    entry.forEach(function commitIterator(handler) {
-      handler(payload);
-    });
-  });
-  this._subscribers.slice().forEach(function(sub) {
-    return sub(mutation, this$1$1.state);
-  });
-  if (process.env.NODE_ENV !== "production" && options && options.silent) {
-    console.warn(
-      "[vuex] mutation type: " + type + ". Silent option has been removed. Use the filter functionality in the vue-devtools"
-    );
-  }
-};
-Store.prototype.dispatch = function dispatch(_type, _payload) {
-  var this$1$1 = this;
-  var ref = unifyObjectStyle(_type, _payload);
-  var type = ref.type;
-  var payload = ref.payload;
-  var action = { type, payload };
-  var entry = this._actions[type];
-  if (!entry) {
-    if (process.env.NODE_ENV !== "production") {
-      console.error("[vuex] unknown action type: " + type);
-    }
-    return;
-  }
-  try {
-    this._actionSubscribers.slice().filter(function(sub) {
-      return sub.before;
-    }).forEach(function(sub) {
-      return sub.before(action, this$1$1.state);
-    });
-  } catch (e) {
-    if (process.env.NODE_ENV !== "production") {
-      console.warn("[vuex] error in before action subscribers: ");
-      console.error(e);
-    }
-  }
-  var result = entry.length > 1 ? Promise.all(entry.map(function(handler) {
-    return handler(payload);
-  })) : entry[0](payload);
-  return new Promise(function(resolve, reject) {
-    result.then(function(res) {
-      try {
-        this$1$1._actionSubscribers.filter(function(sub) {
-          return sub.after;
-        }).forEach(function(sub) {
-          return sub.after(action, this$1$1.state);
-        });
-      } catch (e) {
-        if (process.env.NODE_ENV !== "production") {
-          console.warn("[vuex] error in after action subscribers: ");
-          console.error(e);
-        }
-      }
-      resolve(res);
-    }, function(error) {
-      try {
-        this$1$1._actionSubscribers.filter(function(sub) {
-          return sub.error;
-        }).forEach(function(sub) {
-          return sub.error(action, this$1$1.state, error);
-        });
-      } catch (e) {
-        if (process.env.NODE_ENV !== "production") {
-          console.warn("[vuex] error in error action subscribers: ");
-          console.error(e);
-        }
-      }
-      reject(error);
-    });
-  });
-};
-Store.prototype.subscribe = function subscribe(fn, options) {
-  return genericSubscribe(fn, this._subscribers, options);
-};
-Store.prototype.subscribeAction = function subscribeAction(fn, options) {
-  var subs = typeof fn === "function" ? { before: fn } : fn;
-  return genericSubscribe(subs, this._actionSubscribers, options);
-};
-Store.prototype.watch = function watch$1(getter, cb, options) {
-  var this$1$1 = this;
-  if (process.env.NODE_ENV !== "production") {
-    assert(typeof getter === "function", "store.watch only accepts a function.");
-  }
-  return watch(function() {
-    return getter(this$1$1.state, this$1$1.getters);
-  }, cb, Object.assign({}, options));
-};
-Store.prototype.replaceState = function replaceState(state) {
-  var this$1$1 = this;
-  this._withCommit(function() {
-    this$1$1._state.data = state;
-  });
-};
-Store.prototype.registerModule = function registerModule(path, rawModule, options) {
-  if (options === void 0) options = {};
-  if (typeof path === "string") {
-    path = [path];
-  }
-  if (process.env.NODE_ENV !== "production") {
-    assert(Array.isArray(path), "module path must be a string or an Array.");
-    assert(path.length > 0, "cannot register the root module by using registerModule.");
-  }
-  this._modules.register(path, rawModule);
-  installModule(this, this.state, path, this._modules.get(path), options.preserveState);
-  resetStoreState(this, this.state);
-};
-Store.prototype.unregisterModule = function unregisterModule(path) {
-  var this$1$1 = this;
-  if (typeof path === "string") {
-    path = [path];
-  }
-  if (process.env.NODE_ENV !== "production") {
-    assert(Array.isArray(path), "module path must be a string or an Array.");
-  }
-  this._modules.unregister(path);
-  this._withCommit(function() {
-    var parentState = getNestedState(this$1$1.state, path.slice(0, -1));
-    delete parentState[path[path.length - 1]];
-  });
-  resetStore(this);
-};
-Store.prototype.hasModule = function hasModule(path) {
-  if (typeof path === "string") {
-    path = [path];
-  }
-  if (process.env.NODE_ENV !== "production") {
-    assert(Array.isArray(path), "module path must be a string or an Array.");
-  }
-  return this._modules.isRegistered(path);
-};
-Store.prototype.hotUpdate = function hotUpdate(newOptions) {
-  this._modules.update(newOptions);
-  resetStore(this, true);
-};
-Store.prototype._withCommit = function _withCommit(fn) {
-  var committing = this._committing;
-  this._committing = true;
-  fn();
-  this._committing = committing;
-};
-Object.defineProperties(Store.prototype, prototypeAccessors);
-var mapGetters = normalizeNamespace(function(namespace, getters) {
-  var res = {};
-  if (process.env.NODE_ENV !== "production" && !isValidMap(getters)) {
-    console.error("[vuex] mapGetters: mapper parameter must be either an Array or an Object");
-  }
-  normalizeMap(getters).forEach(function(ref) {
-    var key = ref.key;
-    var val = ref.val;
-    val = namespace + val;
-    res[key] = function mappedGetter() {
-      if (namespace && !getModuleByNamespace(this.$store, "mapGetters", namespace)) {
-        return;
-      }
-      if (process.env.NODE_ENV !== "production" && !(val in this.$store.getters)) {
-        console.error("[vuex] unknown getter: " + val);
-        return;
-      }
-      return this.$store.getters[val];
-    };
-    res[key].vuex = true;
-  });
-  return res;
-});
-function normalizeMap(map) {
-  if (!isValidMap(map)) {
-    return [];
-  }
-  return Array.isArray(map) ? map.map(function(key) {
-    return { key, val: key };
-  }) : Object.keys(map).map(function(key) {
-    return { key, val: map[key] };
-  });
-}
-function isValidMap(map) {
-  return Array.isArray(map) || isObject(map);
-}
-function normalizeNamespace(fn) {
-  return function(namespace, map) {
-    if (typeof namespace !== "string") {
-      map = namespace;
-      namespace = "";
-    } else if (namespace.charAt(namespace.length - 1) !== "/") {
-      namespace += "/";
-    }
-    return fn(namespace, map);
-  };
-}
-function getModuleByNamespace(store, helper, namespace) {
-  var module = store._modulesNamespaceMap[namespace];
-  if (process.env.NODE_ENV !== "production" && !module) {
-    console.error("[vuex] module namespace not found in " + helper + "(): " + namespace);
-  }
-  return module;
-}
-export {
-  Store,
-  createStore,
-  mapGetters,
-  storeKey
-};