First commit

node_modules/.vite/deps/@fortawesome_fontawesome-svg-core.js

@@ -0,0 +1,26 @@
+import {
+  config,
+  counter,
+  dom,
+  findIconDefinition,
+  icon,
+  layer,
+  library,
+  noAuto,
+  parse,
+  text,
+  toHtml
+} from "./chunk-363EPHLC.js";
+export {
+  config,
+  counter,
+  dom,
+  findIconDefinition,
+  icon,
+  layer,
+  library,
+  noAuto,
+  parse,
+  text,
+  toHtml
+};

node_modules/.vite/deps/@fortawesome_fontawesome-svg-core.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/@fortawesome_vue-fontawesome.js

@@ -0,0 +1,536 @@
+import {
+  config,
+  icon,
+  parse,
+  text
+} from "./chunk-363EPHLC.js";
+
+// node_modules/@fortawesome/vue-fontawesome/index.es.js
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var humps$1 = { exports: {} };
+(function(module) {
+  (function(global2) {
+    var _processKeys = function(convert2, obj, options) {
+      if (!_isObject(obj) || _isDate(obj) || _isRegExp(obj) || _isBoolean(obj) || _isFunction(obj)) {
+        return obj;
+      }
+      var output, i = 0, l = 0;
+      if (_isArray(obj)) {
+        output = [];
+        for (l = obj.length; i < l; i++) {
+          output.push(_processKeys(convert2, obj[i], options));
+        }
+      } else {
+        output = {};
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            output[convert2(key, options)] = _processKeys(convert2, obj[key], options);
+          }
+        }
+      }
+      return output;
+    };
+    var separateWords = function(string, options) {
+      options = options || {};
+      var separator = options.separator || "_";
+      var split = options.split || /(?=[A-Z])/;
+      return string.split(split).join(separator);
+    };
+    var camelize = function(string) {
+      if (_isNumerical(string)) {
+        return string;
+      }
+      string = string.replace(/[\-_\s]+(.)?/g, function(match, chr) {
+        return chr ? chr.toUpperCase() : "";
+      });
+      return string.substr(0, 1).toLowerCase() + string.substr(1);
+    };
+    var pascalize = function(string) {
+      var camelized = camelize(string);
+      return camelized.substr(0, 1).toUpperCase() + camelized.substr(1);
+    };
+    var decamelize = function(string, options) {
+      return separateWords(string, options).toLowerCase();
+    };
+    var toString = Object.prototype.toString;
+    var _isFunction = function(obj) {
+      return typeof obj === "function";
+    };
+    var _isObject = function(obj) {
+      return obj === Object(obj);
+    };
+    var _isArray = function(obj) {
+      return toString.call(obj) == "[object Array]";
+    };
+    var _isDate = function(obj) {
+      return toString.call(obj) == "[object Date]";
+    };
+    var _isRegExp = function(obj) {
+      return toString.call(obj) == "[object RegExp]";
+    };
+    var _isBoolean = function(obj) {
+      return toString.call(obj) == "[object Boolean]";
+    };
+    var _isNumerical = function(obj) {
+      obj = obj - 0;
+      return obj === obj;
+    };
+    var _processor = function(convert2, options) {
+      var callback = options && "process" in options ? options.process : options;
+      if (typeof callback !== "function") {
+        return convert2;
+      }
+      return function(string, options2) {
+        return callback(string, convert2, options2);
+      };
+    };
+    var humps2 = {
+      camelize,
+      decamelize,
+      pascalize,
+      depascalize: decamelize,
+      camelizeKeys: function(object, options) {
+        return _processKeys(_processor(camelize, options), object);
+      },
+      decamelizeKeys: function(object, options) {
+        return _processKeys(_processor(decamelize, options), object, options);
+      },
+      pascalizeKeys: function(object, options) {
+        return _processKeys(_processor(pascalize, options), object);
+      },
+      depascalizeKeys: function() {
+        return this.decamelizeKeys.apply(this, arguments);
+      }
+    };
+    if (module.exports) {
+      module.exports = humps2;
+    } else {
+      global2.humps = humps2;
+    }
+  })(commonjsGlobal);
+})(humps$1);
+var humps = humps$1.exports;
+var _excluded = ["class", "style", "attrs"];
+function styleToObject(style) {
+  return style.split(";").map(function(s) {
+    return s.trim();
+  }).filter(function(s) {
+    return s;
+  }).reduce(function(acc, pair) {
+    var i = pair.indexOf(":");
+    var prop = humps.camelize(pair.slice(0, i));
+    var value = pair.slice(i + 1).trim();
+    acc[prop] = value;
+    return acc;
+  }, {});
+}
+function classToObject(cls) {
+  return cls.split(/\s+/).reduce(function(acc, c) {
+    acc[c] = true;
+    return acc;
+  }, {});
+}
+function combineClassObjects() {
+  for (var _len = arguments.length, objs = new Array(_len), _key = 0; _key < _len; _key++) {
+    objs[_key] = arguments[_key];
+  }
+  return objs.reduce(function(acc, obj) {
+    if (Array.isArray(obj)) {
+      acc = acc.concat(obj);
+    } else {
+      acc.push(obj);
+    }
+    return acc;
+  }, []);
+}
+function convert(h, element) {
+  var props = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var data = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+  var children = (element.children || []).map(convert.bind(null, h));
+  var mixins = Object.keys(element.attributes || {}).reduce(function(acc, key) {
+    var val = element.attributes[key];
+    switch (key) {
+      case "class":
+        acc["class"] = classToObject(val);
+        break;
+      case "style":
+        acc["style"] = styleToObject(val);
+        break;
+      default:
+        acc.attrs[key] = val;
+    }
+    return acc;
+  }, {
+    "class": {},
+    style: {},
+    attrs: {}
+  });
+  var _data$class = data.class, dClass = _data$class === void 0 ? {} : _data$class, _data$style = data.style, dStyle = _data$style === void 0 ? {} : _data$style, _data$attrs = data.attrs, dAttrs = _data$attrs === void 0 ? {} : _data$attrs, remainingData = _objectWithoutProperties(data, _excluded);
+  if (typeof element === "string") {
+    return element;
+  } else {
+    return h(element.tag, _objectSpread2(_objectSpread2({
+      class: combineClassObjects(mixins.class, dClass),
+      style: _objectSpread2(_objectSpread2({}, mixins.style), dStyle),
+      attrs: _objectSpread2(_objectSpread2({}, mixins.attrs), dAttrs)
+    }, remainingData), {}, {
+      props
+    }), children);
+  }
+}
+var PRODUCTION = false;
+try {
+  PRODUCTION = false;
+} catch (e) {
+}
+function log() {
+  if (!PRODUCTION && console && typeof console.error === "function") {
+    var _console;
+    (_console = console).error.apply(_console, arguments);
+  }
+}
+function objectWithKey(key, value) {
+  return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? _defineProperty({}, key, value) : {};
+}
+function classList(props) {
+  var _classes;
+  var classes = (_classes = {
+    "fa-spin": props.spin,
+    "fa-spin-pulse": props.spinPulse,
+    "fa-spin-reverse": props.spinReverse,
+    "fa-pulse": props.pulse,
+    "fa-beat": props.beat,
+    "fa-fade": props.fade,
+    "fa-flash": props.flash,
+    "fa-fw": props.fixedWidth,
+    "fa-border": props.border,
+    "fa-li": props.listItem,
+    "fa-inverse": props.inverse,
+    "fa-flip": props.flip === true,
+    "fa-flip-horizontal": props.flip === "horizontal" || props.flip === "both",
+    "fa-flip-vertical": props.flip === "vertical" || props.flip === "both"
+  }, _defineProperty(_classes, "fa-".concat(props.size), props.size !== null), _defineProperty(_classes, "fa-rotate-".concat(props.rotation), props.rotation !== null), _defineProperty(_classes, "fa-pull-".concat(props.pull), props.pull !== null), _defineProperty(_classes, "fa-swap-opacity", props.swapOpacity), _defineProperty(_classes, "fa-bounce", props.bounce), _defineProperty(_classes, "fa-shake", props.shake), _defineProperty(_classes, "fa-beat-fade", props.beatFade), _classes);
+  return Object.keys(classes).map(function(key) {
+    return classes[key] ? key : null;
+  }).filter(function(key) {
+    return key;
+  });
+}
+function addStaticClass(to, what) {
+  var val = (to || "").length === 0 ? [] : [to];
+  return val.concat(what).join(" ");
+}
+function normalizeIconArgs(icon2) {
+  if (icon2 && _typeof(icon2) === "object" && icon2.prefix && icon2.iconName && icon2.icon) {
+    return icon2;
+  }
+  if (parse.icon) {
+    return parse.icon(icon2);
+  }
+  if (icon2 === null) {
+    return null;
+  }
+  if (_typeof(icon2) === "object" && icon2.prefix && icon2.iconName) {
+    return icon2;
+  }
+  if (Array.isArray(icon2) && icon2.length === 2) {
+    return {
+      prefix: icon2[0],
+      iconName: icon2[1]
+    };
+  }
+  if (typeof icon2 === "string") {
+    return {
+      prefix: "fas",
+      iconName: icon2
+    };
+  }
+}
+var FontAwesomeIcon = {
+  name: "FontAwesomeIcon",
+  functional: true,
+  props: {
+    beat: {
+      type: Boolean,
+      default: false
+    },
+    border: {
+      type: Boolean,
+      default: false
+    },
+    fade: {
+      type: Boolean,
+      default: false
+    },
+    fixedWidth: {
+      type: Boolean,
+      default: false
+    },
+    flash: {
+      type: Boolean,
+      default: false
+    },
+    flip: {
+      type: [Boolean, String],
+      default: false,
+      validator: function validator(value) {
+        return [true, false, "horizontal", "vertical", "both"].indexOf(value) > -1;
+      }
+    },
+    icon: {
+      type: [Object, Array, String],
+      required: true
+    },
+    mask: {
+      type: [Object, Array, String],
+      default: null
+    },
+    listItem: {
+      type: Boolean,
+      default: false
+    },
+    pull: {
+      type: String,
+      default: null,
+      validator: function validator2(value) {
+        return ["right", "left"].indexOf(value) > -1;
+      }
+    },
+    pulse: {
+      type: Boolean,
+      default: false
+    },
+    rotation: {
+      type: [String, Number],
+      default: null,
+      validator: function validator3(value) {
+        return [90, 180, 270].indexOf(parseInt(value, 10)) > -1;
+      }
+    },
+    swapOpacity: {
+      type: Boolean,
+      default: false
+    },
+    size: {
+      type: String,
+      default: null,
+      validator: function validator4(value) {
+        return ["2xs", "xs", "sm", "lg", "xl", "2xl", "1x", "2x", "3x", "4x", "5x", "6x", "7x", "8x", "9x", "10x"].indexOf(value) > -1;
+      }
+    },
+    spin: {
+      type: Boolean,
+      default: false
+    },
+    spinPulse: {
+      type: Boolean,
+      default: false
+    },
+    spinReverse: {
+      type: Boolean,
+      default: false
+    },
+    transform: {
+      type: [String, Object],
+      default: null
+    },
+    symbol: {
+      type: [Boolean, String],
+      default: false
+    },
+    title: {
+      type: String,
+      default: null
+    },
+    inverse: {
+      type: Boolean,
+      default: false
+    },
+    bounce: {
+      type: Boolean,
+      default: false
+    },
+    shake: {
+      type: Boolean,
+      default: false
+    },
+    beatFade: {
+      type: Boolean,
+      default: false
+    }
+  },
+  render: function render(createElement, context) {
+    var props = context.props;
+    var iconArgs = props.icon, maskArgs = props.mask, symbol = props.symbol, title = props.title;
+    var icon$1 = normalizeIconArgs(iconArgs);
+    var classes = objectWithKey("classes", classList(props));
+    var transform = objectWithKey("transform", typeof props.transform === "string" ? parse.transform(props.transform) : props.transform);
+    var mask = objectWithKey("mask", normalizeIconArgs(maskArgs));
+    var renderedIcon = icon(icon$1, _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, classes), transform), mask), {}, {
+      symbol,
+      title
+    }));
+    if (!renderedIcon) {
+      return log("Could not find one or more icon(s)", icon$1, mask);
+    }
+    var abstract = renderedIcon.abstract;
+    var convertCurry = convert.bind(null, createElement);
+    return convertCurry(abstract[0], {}, context.data);
+  }
+};
+var FontAwesomeLayers = {
+  name: "FontAwesomeLayers",
+  functional: true,
+  props: {
+    fixedWidth: {
+      type: Boolean,
+      default: false
+    }
+  },
+  render: function render2(createElement, context) {
+    var familyPrefix = config.familyPrefix;
+    var staticClass = context.data.staticClass;
+    var classes = ["".concat(familyPrefix, "-layers")].concat(_toConsumableArray(context.props.fixedWidth ? ["".concat(familyPrefix, "-fw")] : []));
+    return createElement("div", _objectSpread2(_objectSpread2({}, context.data), {}, {
+      staticClass: addStaticClass(staticClass, classes)
+    }), context.children);
+  }
+};
+var FontAwesomeLayersText = {
+  name: "FontAwesomeLayersText",
+  functional: true,
+  props: {
+    value: {
+      type: [String, Number],
+      default: ""
+    },
+    transform: {
+      type: [String, Object],
+      default: null
+    },
+    counter: {
+      type: Boolean,
+      default: false
+    },
+    position: {
+      type: String,
+      default: null,
+      validator: function validator5(value) {
+        return ["bottom-left", "bottom-right", "top-left", "top-right"].indexOf(value) > -1;
+      }
+    }
+  },
+  render: function render3(createElement, context) {
+    var familyPrefix = config.familyPrefix;
+    var props = context.props;
+    var classes = objectWithKey("classes", [].concat(_toConsumableArray(props.counter ? ["".concat(familyPrefix, "-layers-counter")] : []), _toConsumableArray(props.position ? ["".concat(familyPrefix, "-layers-").concat(props.position)] : [])));
+    var transform = objectWithKey("transform", typeof props.transform === "string" ? parse.transform(props.transform) : props.transform);
+    var renderedText = text(props.value.toString(), _objectSpread2(_objectSpread2({}, transform), classes));
+    var abstract = renderedText.abstract;
+    if (props.counter) {
+      abstract[0].attributes.class = abstract[0].attributes.class.replace("fa-layers-text", "");
+    }
+    var convertCurry = convert.bind(null, createElement);
+    return convertCurry(abstract[0], {}, context.data);
+  }
+};
+export {
+  FontAwesomeIcon,
+  FontAwesomeLayers,
+  FontAwesomeLayersText
+};
+//# sourceMappingURL=@fortawesome_vue-fontawesome.js.map

node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,55 @@
+{
+  "hash": "cd3decae",
+  "configHash": "b21f88d8",
+  "lockfileHash": "25c10b32",
+  "browserHash": "37204f5e",
+  "optimized": {
+    "@fortawesome/fontawesome-svg-core": {
+      "src": "../../@fortawesome/fontawesome-svg-core/index.es.js",
+      "file": "@fortawesome_fontawesome-svg-core.js",
+      "fileHash": "edd5645b",
+      "needsInterop": false
+    },
+    "@fortawesome/free-brands-svg-icons": {
+      "src": "../../@fortawesome/free-brands-svg-icons/index.mjs",
+      "file": "@fortawesome_free-brands-svg-icons.js",
+      "fileHash": "b61541e1",
+      "needsInterop": false
+    },
+    "@fortawesome/free-solid-svg-icons": {
+      "src": "../../@fortawesome/free-solid-svg-icons/index.mjs",
+      "file": "@fortawesome_free-solid-svg-icons.js",
+      "fileHash": "53bdb2e3",
+      "needsInterop": false
+    },
+    "@fortawesome/vue-fontawesome": {
+      "src": "../../@fortawesome/vue-fontawesome/index.es.js",
+      "file": "@fortawesome_vue-fontawesome.js",
+      "fileHash": "d68cd9bf",
+      "needsInterop": false
+    },
+    "vue": {
+      "src": "../../vue/dist/vue.runtime.esm.js",
+      "file": "vue.js",
+      "fileHash": "422d179c",
+      "needsInterop": false
+    },
+    "vue-router": {
+      "src": "../../vue-router/dist/vue-router.esm.js",
+      "file": "vue-router.js",
+      "fileHash": "314ec933",
+      "needsInterop": false
+    },
+    "vuex": {
+      "src": "../../vuex/dist/vuex.esm.js",
+      "file": "vuex.js",
+      "fileHash": "3f17a003",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-363EPHLC": {
+      "file": "chunk-363EPHLC.js"
+    }
+  }
+}

node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

node_modules/.vite/deps/vuex.js

@@ -0,0 +1,982 @@
+// node_modules/vuex/dist/vuex.esm.js
+function applyMixin(Vue2) {
+  var version = Number(Vue2.version.split(".")[0]);
+  if (version >= 2) {
+    Vue2.mixin({ beforeCreate: vuexInit });
+  } else {
+    var _init = Vue2.prototype._init;
+    Vue2.prototype._init = function(options) {
+      if (options === void 0) options = {};
+      options.init = options.init ? [vuexInit].concat(options.init) : vuexInit;
+      _init.call(this, options);
+    };
+  }
+  function vuexInit() {
+    var options = this.$options;
+    if (options.store) {
+      this.$store = typeof options.store === "function" ? options.store() : options.store;
+    } else if (options.parent && options.parent.$store) {
+      this.$store = options.parent.$store;
+    }
+  }
+}
+var target = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+var devtoolHook = target.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+function devtoolPlugin(store) {
+  if (!devtoolHook) {
+    return;
+  }
+  store._devtoolHook = devtoolHook;
+  devtoolHook.emit("vuex:init", store);
+  devtoolHook.on("vuex:travel-to-state", function(targetState) {
+    store.replaceState(targetState);
+  });
+  store.subscribe(function(mutation, state) {
+    devtoolHook.emit("vuex:mutation", mutation, state);
+  }, { prepend: true });
+  store.subscribeAction(function(action, state) {
+    devtoolHook.emit("vuex:action", action, state);
+  }, { prepend: true });
+}
+function find(list, f) {
+  return list.filter(f)[0];
+}
+function deepCopy(obj, cache) {
+  if (cache === void 0) cache = [];
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  var hit = find(cache, function(c) {
+    return c.original === obj;
+  });
+  if (hit) {
+    return hit.copy;
+  }
+  var copy = Array.isArray(obj) ? [] : {};
+  cache.push({
+    original: obj,
+    copy
+  });
+  Object.keys(obj).forEach(function(key) {
+    copy[key] = deepCopy(obj[key], cache);
+  });
+  return copy;
+}
+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);
+  };
+}
+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 = { namespaced: { configurable: true } };
+prototypeAccessors.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);
+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 = this;
+  if (runtime === void 0) runtime = true;
+  if (true) {
+    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.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 (true) {
+      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 (true) {
+    assertRawModule(path, newModule);
+  }
+  targetModule.update(newModule);
+  if (newModule.modules) {
+    for (var key in newModule.modules) {
+      if (!targetModule.getChild(key)) {
+        if (true) {
+          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;
+}
+var Vue;
+var Store = function Store2(options) {
+  var this$1 = this;
+  if (options === void 0) options = {};
+  if (!Vue && typeof window !== "undefined" && window.Vue) {
+    install(window.Vue);
+  }
+  if (true) {
+    assert(Vue, "must call Vue.use(Vuex) before creating a store instance.");
+    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;
+  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._watcherVM = new Vue();
+  this._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
+  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);
+  resetStoreVM(this, state);
+  plugins.forEach(function(plugin) {
+    return plugin(this$1);
+  });
+  var useDevtools = options.devtools !== void 0 ? options.devtools : Vue.config.devtools;
+  if (useDevtools) {
+    devtoolPlugin(this);
+  }
+};
+var prototypeAccessors$1 = { state: { configurable: true } };
+prototypeAccessors$1.state.get = function() {
+  return this._vm._data.$$state;
+};
+prototypeAccessors$1.state.set = function(v) {
+  if (true) {
+    assert(false, "use store.replaceState() to explicit replace store state.");
+  }
+};
+Store.prototype.commit = function commit(_type, _payload, _options) {
+  var this$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 (true) {
+      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.state);
+  });
+  if (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 = 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 (true) {
+      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.state);
+    });
+  } catch (e) {
+    if (true) {
+      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._actionSubscribers.filter(function(sub) {
+          return sub.after;
+        }).forEach(function(sub) {
+          return sub.after(action, this$1.state);
+        });
+      } catch (e) {
+        if (true) {
+          console.warn("[vuex] error in after action subscribers: ");
+          console.error(e);
+        }
+      }
+      resolve(res);
+    }, function(error) {
+      try {
+        this$1._actionSubscribers.filter(function(sub) {
+          return sub.error;
+        }).forEach(function(sub) {
+          return sub.error(action, this$1.state, error);
+        });
+      } catch (e) {
+        if (true) {
+          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(getter, cb, options) {
+  var this$1 = this;
+  if (true) {
+    assert(typeof getter === "function", "store.watch only accepts a function.");
+  }
+  return this._watcherVM.$watch(function() {
+    return getter(this$1.state, this$1.getters);
+  }, cb, options);
+};
+Store.prototype.replaceState = function replaceState(state) {
+  var this$1 = this;
+  this._withCommit(function() {
+    this$1._vm._data.$$state = state;
+  });
+};
+Store.prototype.registerModule = function registerModule(path, rawModule, options) {
+  if (options === void 0) options = {};
+  if (typeof path === "string") {
+    path = [path];
+  }
+  if (true) {
+    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);
+  resetStoreVM(this, this.state);
+};
+Store.prototype.unregisterModule = function unregisterModule(path) {
+  var this$1 = this;
+  if (typeof path === "string") {
+    path = [path];
+  }
+  if (true) {
+    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.state, path.slice(0, -1));
+    Vue.delete(parentState, path[path.length - 1]);
+  });
+  resetStore(this);
+};
+Store.prototype.hasModule = function hasModule(path) {
+  if (typeof path === "string") {
+    path = [path];
+  }
+  if (true) {
+    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$1);
+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);
+  resetStoreVM(store, state, hot);
+}
+function resetStoreVM(store, state, hot) {
+  var oldVm = store._vm;
+  store.getters = {};
+  store._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
+  var wrappedGetters = store._wrappedGetters;
+  var computed = {};
+  forEachValue(wrappedGetters, function(fn, key) {
+    computed[key] = partial(fn, store);
+    Object.defineProperty(store.getters, key, {
+      get: function() {
+        return store._vm[key];
+      },
+      enumerable: true
+      // for local getters
+    });
+  });
+  var silent = Vue.config.silent;
+  Vue.config.silent = true;
+  store._vm = new Vue({
+    data: {
+      $$state: state
+    },
+    computed
+  });
+  Vue.config.silent = silent;
+  if (store.strict) {
+    enableStrictMode(store);
+  }
+  if (oldVm) {
+    if (hot) {
+      store._withCommit(function() {
+        oldVm._data.$$state = null;
+      });
+    }
+    Vue.nextTick(function() {
+      return oldVm.$destroy();
+    });
+  }
+}
+function installModule(store, rootState, path, module, hot) {
+  var isRoot = !path.length;
+  var namespace = store._modules.getNamespace(path);
+  if (module.namespaced) {
+    if (store._modulesNamespaceMap[namespace] && true) {
+      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 (true) {
+        if (moduleName in parentState) {
+          console.warn(
+            '[vuex] state field "' + moduleName + '" was overridden by a module with the same name at "' + path.join(".") + '"'
+          );
+        }
+      }
+      Vue.set(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 (!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 (!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 (true) {
+      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) {
+  store._vm.$watch(function() {
+    return this._data.$$state;
+  }, function() {
+    if (true) {
+      assert(store._committing, "do not mutate vuex store state outside mutation handlers.");
+    }
+  }, { deep: true, sync: true });
+}
+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 (true) {
+    assert(typeof type === "string", "expects string as the type, but found " + typeof type + ".");
+  }
+  return { type, payload, options };
+}
+function install(_Vue) {
+  if (Vue && _Vue === Vue) {
+    if (true) {
+      console.error(
+        "[vuex] already installed. Vue.use(Vuex) should be called only once."
+      );
+    }
+    return;
+  }
+  Vue = _Vue;
+  applyMixin(Vue);
+}
+var mapState = normalizeNamespace(function(namespace, states) {
+  var res = {};
+  if (!isValidMap(states)) {
+    console.error("[vuex] mapState: mapper parameter must be either an Array or an Object");
+  }
+  normalizeMap(states).forEach(function(ref) {
+    var key = ref.key;
+    var val = ref.val;
+    res[key] = function mappedState() {
+      var state = this.$store.state;
+      var getters = this.$store.getters;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, "mapState", namespace);
+        if (!module) {
+          return;
+        }
+        state = module.context.state;
+        getters = module.context.getters;
+      }
+      return typeof val === "function" ? val.call(this, state, getters) : state[val];
+    };
+    res[key].vuex = true;
+  });
+  return res;
+});
+var mapMutations = normalizeNamespace(function(namespace, mutations) {
+  var res = {};
+  if (!isValidMap(mutations)) {
+    console.error("[vuex] mapMutations: mapper parameter must be either an Array or an Object");
+  }
+  normalizeMap(mutations).forEach(function(ref) {
+    var key = ref.key;
+    var val = ref.val;
+    res[key] = function mappedMutation() {
+      var args = [], len = arguments.length;
+      while (len--) args[len] = arguments[len];
+      var commit2 = this.$store.commit;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, "mapMutations", namespace);
+        if (!module) {
+          return;
+        }
+        commit2 = module.context.commit;
+      }
+      return typeof val === "function" ? val.apply(this, [commit2].concat(args)) : commit2.apply(this.$store, [val].concat(args));
+    };
+  });
+  return res;
+});
+var mapGetters = normalizeNamespace(function(namespace, getters) {
+  var res = {};
+  if (!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 (!(val in this.$store.getters)) {
+        console.error("[vuex] unknown getter: " + val);
+        return;
+      }
+      return this.$store.getters[val];
+    };
+    res[key].vuex = true;
+  });
+  return res;
+});
+var mapActions = normalizeNamespace(function(namespace, actions) {
+  var res = {};
+  if (!isValidMap(actions)) {
+    console.error("[vuex] mapActions: mapper parameter must be either an Array or an Object");
+  }
+  normalizeMap(actions).forEach(function(ref) {
+    var key = ref.key;
+    var val = ref.val;
+    res[key] = function mappedAction() {
+      var args = [], len = arguments.length;
+      while (len--) args[len] = arguments[len];
+      var dispatch2 = this.$store.dispatch;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, "mapActions", namespace);
+        if (!module) {
+          return;
+        }
+        dispatch2 = module.context.dispatch;
+      }
+      return typeof val === "function" ? val.apply(this, [dispatch2].concat(args)) : dispatch2.apply(this.$store, [val].concat(args));
+    };
+  });
+  return res;
+});
+var createNamespacedHelpers = function(namespace) {
+  return {
+    mapState: mapState.bind(null, namespace),
+    mapGetters: mapGetters.bind(null, namespace),
+    mapMutations: mapMutations.bind(null, namespace),
+    mapActions: mapActions.bind(null, namespace)
+  };
+};
+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 (!module) {
+    console.error("[vuex] module namespace not found in " + helper + "(): " + namespace);
+  }
+  return module;
+}
+function createLogger(ref) {
+  if (ref === void 0) ref = {};
+  var collapsed = ref.collapsed;
+  if (collapsed === void 0) collapsed = true;
+  var filter = ref.filter;
+  if (filter === void 0) filter = function(mutation, stateBefore, stateAfter) {
+    return true;
+  };
+  var transformer = ref.transformer;
+  if (transformer === void 0) transformer = function(state) {
+    return state;
+  };
+  var mutationTransformer = ref.mutationTransformer;
+  if (mutationTransformer === void 0) mutationTransformer = function(mut) {
+    return mut;
+  };
+  var actionFilter = ref.actionFilter;
+  if (actionFilter === void 0) actionFilter = function(action, state) {
+    return true;
+  };
+  var actionTransformer = ref.actionTransformer;
+  if (actionTransformer === void 0) actionTransformer = function(act) {
+    return act;
+  };
+  var logMutations = ref.logMutations;
+  if (logMutations === void 0) logMutations = true;
+  var logActions = ref.logActions;
+  if (logActions === void 0) logActions = true;
+  var logger = ref.logger;
+  if (logger === void 0) logger = console;
+  return function(store) {
+    var prevState = deepCopy(store.state);
+    if (typeof logger === "undefined") {
+      return;
+    }
+    if (logMutations) {
+      store.subscribe(function(mutation, state) {
+        var nextState = deepCopy(state);
+        if (filter(mutation, prevState, nextState)) {
+          var formattedTime = getFormattedTime();
+          var formattedMutation = mutationTransformer(mutation);
+          var message = "mutation " + mutation.type + formattedTime;
+          startMessage(logger, message, collapsed);
+          logger.log("%c prev state", "color: #9E9E9E; font-weight: bold", transformer(prevState));
+          logger.log("%c mutation", "color: #03A9F4; font-weight: bold", formattedMutation);
+          logger.log("%c next state", "color: #4CAF50; font-weight: bold", transformer(nextState));
+          endMessage(logger);
+        }
+        prevState = nextState;
+      });
+    }
+    if (logActions) {
+      store.subscribeAction(function(action, state) {
+        if (actionFilter(action, state)) {
+          var formattedTime = getFormattedTime();
+          var formattedAction = actionTransformer(action);
+          var message = "action " + action.type + formattedTime;
+          startMessage(logger, message, collapsed);
+          logger.log("%c action", "color: #03A9F4; font-weight: bold", formattedAction);
+          endMessage(logger);
+        }
+      });
+    }
+  };
+}
+function startMessage(logger, message, collapsed) {
+  var startMessage2 = collapsed ? logger.groupCollapsed : logger.group;
+  try {
+    startMessage2.call(logger, message);
+  } catch (e) {
+    logger.log(message);
+  }
+}
+function endMessage(logger) {
+  try {
+    logger.groupEnd();
+  } catch (e) {
+    logger.log("—— log end ——");
+  }
+}
+function getFormattedTime() {
+  var time = /* @__PURE__ */ new Date();
+  return " @ " + pad(time.getHours(), 2) + ":" + pad(time.getMinutes(), 2) + ":" + pad(time.getSeconds(), 2) + "." + pad(time.getMilliseconds(), 3);
+}
+function repeat(str, times) {
+  return new Array(times + 1).join(str);
+}
+function pad(num, maxLength) {
+  return repeat("0", maxLength - num.toString().length) + num;
+}
+var index = {
+  Store,
+  install,
+  version: "3.6.2",
+  mapState,
+  mapMutations,
+  mapGetters,
+  mapActions,
+  createNamespacedHelpers,
+  createLogger
+};
+var vuex_esm_default = index;
+export {
+  Store,
+  createLogger,
+  createNamespacedHelpers,
+  vuex_esm_default as default,
+  install,
+  mapActions,
+  mapGetters,
+  mapMutations,
+  mapState
+};
+//# sourceMappingURL=vuex.js.map