(window["webpackjsonp"] = window["webpackjsonp"] || []).push([[7],{

/***/ 112:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var middleware = {};
middleware['route'] = __webpack_require__(226);
middleware['route'] = middleware['route'].default || middleware['route'];
/* harmony default export */ __webpack_exports__["a"] = (middleware);

/***/ }),

/***/ 158:
/***/ (function(module, exports, __webpack_require__) {

// extracted by extract-css-chunks-webpack-plugin

/***/ }),

/***/ 159:
/***/ (function(module, exports, __webpack_require__) {

// extracted by extract-css-chunks-webpack-plugin

/***/ }),

/***/ 198:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var _babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_0__ = __webpack_require__(9);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_1__ = __webpack_require__(44);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_1___default = /*#__pure__*/__webpack_require__.n(regenerator_runtime_runtime_js__webpack_imported_module_1__);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_2__ = __webpack_require__(19);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_2___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_to_string_js__webpack_imported_module_2__);
/* harmony import */ var vue__webpack_imported_module_3__ = __webpack_require__(5);
/* harmony import */ var _utils__webpack_imported_module_4__ = __webpack_require__(2);






var isssrhydration = function isssrhydration(vm) {
  return vm.$vnode && vm.$vnode.elm && vm.$vnode.elm.dataset && vm.$vnode.elm.dataset.fetchkey;
};

var nuxtstate = window.__nuxt__;
/* harmony default export */ __webpack_exports__["a"] = ({
  beforecreate: function beforecreate() {
    if (!object(_utils__webpack_imported_module_4__[/* hasfetch */ "l"])(this)) {
      return;
    }

    this._fetchdelay = typeof this.$options.fetchdelay === 'number' ? this.$options.fetchdelay : 200;
    vue__webpack_imported_module_3__["default"].util.definereactive(this, '$fetchstate', {
      pending: false,
      error: null,
      timestamp: date.now()
    });
    this.$fetch = $fetch.bind(this);
    object(_utils__webpack_imported_module_4__[/* addlifecyclehook */ "a"])(this, 'created', created);
    object(_utils__webpack_imported_module_4__[/* addlifecyclehook */ "a"])(this, 'beforemount', beforemount);
  }
});

function beforemount() {
  if (!this._hydrated) {
    return this.$fetch();
  }
}

function created() {
  if (!isssrhydration(this)) {
    return;
  } // hydrate component


  this._hydrated = true;
  this._fetchkey = this.$vnode.elm.dataset.fetchkey;
  var data = nuxtstate.fetch[this._fetchkey]; // if fetch error

  if (data && data._error) {
    this.$fetchstate.error = data._error;
    return;
  } // merge data


  for (var key in data) {
    vue__webpack_imported_module_3__["default"].set(this.$data, key, data[key]);
  }
}

function $fetch() {
  var _this = this;

  if (!this._fetchpromise) {
    this._fetchpromise = $_fetch.call(this).then(function () {
      delete _this._fetchpromise;
    });
  }

  return this._fetchpromise;
}

function $_fetch() {
  return _$_fetch.apply(this, arguments);
}

function _$_fetch() {
  _$_fetch = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_0__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee() {
    var _this2 = this;

    var error, starttime, delayleft;
    return regeneratorruntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            this.$nuxt.nbfetching++;
            this.$fetchstate.pending = true;
            this.$fetchstate.error = null;
            this._hydrated = false;
            error = null;
            starttime = date.now();
            _context.prev = 6;
            _context.next = 9;
            return this.$options.fetch.call(this);

          case 9:
            _context.next = 15;
            break;

          case 11:
            _context.prev = 11;
            _context.t0 = _context["catch"](6);

            if (false) {}

            error = object(_utils__webpack_imported_module_4__[/* normalizeerror */ "p"])(_context.t0);

          case 15:
            delayleft = this._fetchdelay - (date.now() - starttime);

            if (!(delayleft > 0)) {
              _context.next = 19;
              break;
            }

            _context.next = 19;
            return new promise(function (resolve) {
              return settimeout(resolve, delayleft);
            });

          case 19:
            this.$fetchstate.error = error;
            this.$fetchstate.pending = false;
            this.$fetchstate.timestamp = date.now();
            this.$nexttick(function () {
              return _this2.$nuxt.nbfetching--;
            });

          case 23:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, this, [[6, 11]]);
  }));
  return _$_fetch.apply(this, arguments);
}

/***/ }),

/***/ 2:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export creategetcounter */
/* unused harmony export empty */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return globalhandleerror; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return interopdefault; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return hasfetch; });
/* unused harmony export purifydata */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getchildrencomponentinstancesusingfetch; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return applyasyncdata; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return sanitizecomponent; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return getmatchedcomponents; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return getmatchedcomponentsinstances; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return flatmapcomponents; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return resolveroutecomponents; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return getroutedata; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return setcontext; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return middlewareseries; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return promisify; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return getlocation; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return compile; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return getquerydiff; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return normalizeerror; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return addlifecyclehook; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "v", function() { return urljoin; });
/* unused harmony export striptrailingslash */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return issamepath; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "u", function() { return setscrollrestoration; });
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_0__ = __webpack_require__(29);
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_symbol_js__webpack_imported_module_0__);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_1__ = __webpack_require__(47);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_1___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_from_js__webpack_imported_module_1__);
/* harmony import */ var core_js_modules_es6_object_get_own_property_descriptor_js__webpack_imported_module_2__ = __webpack_require__(51);
/* harmony import */ var core_js_modules_es6_object_get_own_property_descriptor_js__webpack_imported_module_2___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_get_own_property_descriptor_js__webpack_imported_module_2__);
/* harmony import */ var core_js_modules_es7_object_get_own_property_descriptors_js__webpack_imported_module_3__ = __webpack_require__(52);
/* harmony import */ var core_js_modules_es7_object_get_own_property_descriptors_js__webpack_imported_module_3___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_object_get_own_property_descriptors_js__webpack_imported_module_3__);
/* harmony import */ var _babel_runtime_helpers_esm_typeof__webpack_imported_module_4__ = __webpack_require__(28);
/* harmony import */ var _babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_5__ = __webpack_require__(9);
/* harmony import */ var _babel_runtime_helpers_esm_defineproperty__webpack_imported_module_6__ = __webpack_require__(20);
/* harmony import */ var _babel_runtime_helpers_esm_slicedtoarray__webpack_imported_module_7__ = __webpack_require__(22);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_8__ = __webpack_require__(44);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_8___default = /*#__pure__*/__webpack_require__.n(regenerator_runtime_runtime_js__webpack_imported_module_8__);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_9__ = __webpack_require__(31);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_9___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_filter_js__webpack_imported_module_9__);
/* harmony import */ var core_js_modules_es7_object_entries_js__webpack_imported_module_10__ = __webpack_require__(228);
/* harmony import */ var core_js_modules_es7_object_entries_js__webpack_imported_module_10___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_object_entries_js__webpack_imported_module_10__);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_11__ = __webpack_require__(19);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_11___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_to_string_js__webpack_imported_module_11__);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_12__ = __webpack_require__(25);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_12___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_function_name_js__webpack_imported_module_12__);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_13__ = __webpack_require__(50);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_13___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_map_js__webpack_imported_module_13__);
/* harmony import */ var core_js_modules_es6_object_keys_js__webpack_imported_module_14__ = __webpack_require__(34);
/* harmony import */ var core_js_modules_es6_object_keys_js__webpack_imported_module_14___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_keys_js__webpack_imported_module_14__);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_15__ = __webpack_require__(45);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_15___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_iterator_js__webpack_imported_module_15__);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_16__ = __webpack_require__(46);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_16___default = /*#__pure__*/__webpack_require__.n(core_js_modules_web_dom_iterable_js__webpack_imported_module_16__);
/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_17__ = __webpack_require__(49);
/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_17___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_slice_js__webpack_imported_module_17__);
/* harmony import */ var core_js_modules_es6_regexp_replace_js__webpack_imported_module_18__ = __webpack_require__(61);
/* harmony import */ var core_js_modules_es6_regexp_replace_js__webpack_imported_module_18___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_regexp_replace_js__webpack_imported_module_18__);
/* harmony import */ var core_js_modules_es6_string_starts_with_js__webpack_imported_module_19__ = __webpack_require__(154);
/* harmony import */ var core_js_modules_es6_string_starts_with_js__webpack_imported_module_19___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_starts_with_js__webpack_imported_module_19__);
/* harmony import */ var core_js_modules_es6_regexp_search_js__webpack_imported_module_20__ = __webpack_require__(155);
/* harmony import */ var core_js_modules_es6_regexp_search_js__webpack_imported_module_20___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_regexp_search_js__webpack_imported_module_20__);
/* harmony import */ var core_js_modules_es6_regexp_constructor_js__webpack_imported_module_21__ = __webpack_require__(136);
/* harmony import */ var core_js_modules_es6_regexp_constructor_js__webpack_imported_module_21___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_regexp_constructor_js__webpack_imported_module_21__);
/* harmony import */ var core_js_modules_es6_date_to_string_js__webpack_imported_module_22__ = __webpack_require__(80);
/* harmony import */ var core_js_modules_es6_date_to_string_js__webpack_imported_module_22___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_date_to_string_js__webpack_imported_module_22__);
/* harmony import */ var core_js_modules_es6_regexp_to_string_js__webpack_imported_module_23__ = __webpack_require__(81);
/* harmony import */ var core_js_modules_es6_regexp_to_string_js__webpack_imported_module_23___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string_js__webpack_imported_module_23__);
/* harmony import */ var core_js_modules_es6_string_repeat_js__webpack_imported_module_24__ = __webpack_require__(234);
/* harmony import */ var core_js_modules_es6_string_repeat_js__webpack_imported_module_24___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_repeat_js__webpack_imported_module_24__);
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_25__ = __webpack_require__(75);
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_25___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_includes_js__webpack_imported_module_25__);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_26__ = __webpack_require__(76);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_26___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_array_includes_js__webpack_imported_module_26__);
/* harmony import */ var vue__webpack_imported_module_27__ = __webpack_require__(5);
/* harmony import */ var ufo__webpack_imported_module_28__ = __webpack_require__(32);










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 _objectspread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownkeys(object(source), !0).foreach(function (key) { object(_babel_runtime_helpers_esm_defineproperty__webpack_imported_module_6__[/* default */ "a"])(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 _createforofiteratorhelper(o, allowarraylike) { var it = typeof symbol !== "undefined" && o[symbol.iterator] || o["@@iterator"]; if (!it) { if (array.isarray(o) || (it = _unsupportediterabletoarray(o)) || allowarraylike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var f = function f() {}; return { s: f, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: f }; } throw new typeerror("invalid attempt to iterate non-iterable instance.\nin order to be iterable, non-array objects must have a [symbol.iterator]() method."); } var normalcompletion = true, diderr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalcompletion = step.done; return step; }, e: function e(_e2) { diderr = true; err = _e2; }, f: function f() { try { if (!normalcompletion && it.return != null) it.return(); } finally { if (diderr) throw err; } } }; }

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; }




















 // window.{{globals.loadedcallback}} hook
// useful for jsdom testing or plugins (https://github.com/tmpvar/jsdom#dealing-with-asynchronous-script-loading)

if (true) {
  window.onnuxtreadycbs = [];

  window.onnuxtready = function (cb) {
    window.onnuxtreadycbs.push(cb);
  };
}

function creategetcounter(counterobject) {
  var defaultkey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  return function getcounter() {
    var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultkey;

    if (counterobject[id] === undefined) {
      counterobject[id] = 0;
    }

    return counterobject[id]++;
  };
}
function empty() {}
function globalhandleerror(error) {
  if (vue__webpack_imported_module_27__["default"].config.errorhandler) {
    vue__webpack_imported_module_27__["default"].config.errorhandler(error);
  }
}
function interopdefault(promise) {
  return promise.then(function (m) {
    return m.default || m;
  });
}
function hasfetch(vm) {
  return vm.$options && typeof vm.$options.fetch === 'function' && !vm.$options.fetch.length;
}
function purifydata(data) {
  if (true) {
    return data;
  }

  return object.entries(data).filter(function (_ref) {
    var _ref2 = object(_babel_runtime_helpers_esm_slicedtoarray__webpack_imported_module_7__[/* default */ "a"])(_ref, 2),
        key = _ref2[0],
        value = _ref2[1];

    var valid = !(value instanceof function) && !(value instanceof promise);

    if (!valid) {
      console.warn("".concat(key, " is not able to be stringified. this will break in a production environment."));
    }

    return valid;
  }).reduce(function (obj, _ref3) {
    var _ref4 = object(_babel_runtime_helpers_esm_slicedtoarray__webpack_imported_module_7__[/* default */ "a"])(_ref3, 2),
        key = _ref4[0],
        value = _ref4[1];

    obj[key] = value;
    return obj;
  }, {});
}
function getchildrencomponentinstancesusingfetch(vm) {
  var instances = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  var children = vm.$children || [];

  var _iterator = _createforofiteratorhelper(children),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var child = _step.value;

      if (child.$fetch) {
        instances.push(child);
        continue; // don't get the children since it will reload the template
      }

      if (child.$children) {
        getchildrencomponentinstancesusingfetch(child, instances);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return instances;
}
function applyasyncdata(component, asyncdata) {
  if ( // for ssr, we once all this function without second param to just apply asyncdata
  // prevent doing this for each ssr request
  !asyncdata && component.options.__hasnuxtdata) {
    return;
  }

  var componentdata = component.options._origindatafn || component.options.data || function () {
    return {};
  };

  component.options._origindatafn = componentdata;

  component.options.data = function () {
    var data = componentdata.call(this, this);

    if (this.$ssrcontext) {
      asyncdata = this.$ssrcontext.asyncdata[component.cid];
    }

    return _objectspread(_objectspread({}, data), asyncdata);
  };

  component.options.__hasnuxtdata = true;

  if (component._ctor && component._ctor.options) {
    component._ctor.options.data = component.options.data;
  }
}
function sanitizecomponent(component) {
  // if component already sanitized
  if (component.options && component._ctor === component) {
    return component;
  }

  if (!component.options) {
    component = vue__webpack_imported_module_27__["default"].extend(component); // fix issue #6

    component._ctor = component;
  } else {
    component._ctor = component;
    component.extendoptions = component.options;
  } // if no component name defined, set file path as name, (also fixes #5703)


  if (!component.options.name && component.options.__file) {
    component.options.name = component.options.__file;
  }

  return component;
}
function getmatchedcomponents(route) {
  var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var prop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'components';
  return array.prototype.concat.apply([], route.matched.map(function (m, index) {
    return object.keys(m[prop]).map(function (key) {
      matches && matches.push(index);
      return m[prop][key];
    });
  }));
}
function getmatchedcomponentsinstances(route) {
  var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return getmatchedcomponents(route, matches, 'instances');
}
function flatmapcomponents(route, fn) {
  return array.prototype.concat.apply([], route.matched.map(function (m, index) {
    return object.keys(m.components).reduce(function (promises, key) {
      if (m.components[key]) {
        promises.push(fn(m.components[key], m.instances[key], m, key, index));
      } else {
        delete m.components[key];
      }

      return promises;
    }, []);
  }));
}
function resolveroutecomponents(route, fn) {
  return promise.all(flatmapcomponents(route, /*#__pure__*/function () {
    var _ref5 = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_5__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee(component, instance, match, key) {
      var timenow, previousreloadtime;
      return regeneratorruntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (!(typeof component === 'function' && !component.options)) {
                _context.next = 11;
                break;
              }

              _context.prev = 1;
              _context.next = 4;
              return component();

            case 4:
              component = _context.sent;
              _context.next = 11;
              break;

            case 7:
              _context.prev = 7;
              _context.t0 = _context["catch"](1);

              // handle webpack chunk loading errors
              // this may be due to a new deployment or a network problem
              if (_context.t0 && _context.t0.name === 'chunkloaderror' && typeof window !== 'undefined' && window.sessionstorage) {
                timenow = date.now();
                previousreloadtime = parseint(window.sessionstorage.getitem('nuxt-reload')); // check for previous reload time not to reload infinitely

                if (!previousreloadtime || previousreloadtime + 60000 < timenow) {
                  window.sessionstorage.setitem('nuxt-reload', timenow);
                  window.location.reload(true
                  /* skip cache */
                  );
                }
              }

              throw _context.t0;

            case 11:
              match.components[key] = component = sanitizecomponent(component);
              return _context.abrupt("return", typeof fn === 'function' ? fn(component, instance, match, key) : component);

            case 13:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, null, [[1, 7]]);
    }));

    return function (_x, _x2, _x3, _x4) {
      return _ref5.apply(this, arguments);
    };
  }()));
}
function getroutedata(_x5) {
  return _getroutedata.apply(this, arguments);
}

function _getroutedata() {
  _getroutedata = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_5__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee2(route) {
    return regeneratorruntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (route) {
              _context2.next = 2;
              break;
            }

            return _context2.abrupt("return");

          case 2:
            _context2.next = 4;
            return resolveroutecomponents(route);

          case 4:
            return _context2.abrupt("return", _objectspread(_objectspread({}, route), {}, {
              meta: getmatchedcomponents(route).map(function (component, index) {
                return _objectspread(_objectspread({}, component.options.meta), (route.matched[index] || {}).meta);
              })
            }));

          case 5:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _getroutedata.apply(this, arguments);
}

function setcontext(_x6, _x7) {
  return _setcontext.apply(this, arguments);
}

function _setcontext() {
  _setcontext = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_5__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee3(app, context) {
    var _yield$promise$all, _yield$promise$all2, currentroutedata, fromroutedata;

    return regeneratorruntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            // if context not defined, create it
            if (!app.context) {
              app.context = {
                isstatic: false,
                isdev: false,
                ishmr: false,
                app: app,
                store: app.store,
                payload: context.payload,
                error: context.error,
                base: app.router.options.base,
                env: {}
              }; // only set once

              if (context.req) {
                app.context.req = context.req;
              }

              if (context.res) {
                app.context.res = context.res;
              }

              if (context.ssrcontext) {
                app.context.ssrcontext = context.ssrcontext;
              }

              app.context.redirect = function (status, path, query) {
                if (!status) {
                  return;
                }

                app.context._redirected = true; // if only 1 or 2 arguments: redirect('/') or redirect('/', { foo: 'bar' })

                var pathtype = object(_babel_runtime_helpers_esm_typeof__webpack_imported_module_4__[/* default */ "a"])(path);

                if (typeof status !== 'number' && (pathtype === 'undefined' || pathtype === 'object')) {
                  query = path || {};
                  path = status;
                  pathtype = object(_babel_runtime_helpers_esm_typeof__webpack_imported_module_4__[/* default */ "a"])(path);
                  status = 302;
                }

                if (pathtype === 'object') {
                  path = app.router.resolve(path).route.fullpath;
                } // "/absolute/route", "./relative/route" or "../relative/route"


                if (/(^[.]{1,2}\/)|(^\/(?!\/))/.test(path)) {
                  app.context.next({
                    path: path,
                    query: query,
                    status: status
                  });
                } else {
                  path = object(ufo__webpack_imported_module_28__[/* withquery */ "d"])(path, query);

                  if (false) {}

                  if (true) {
                    // https://developer.mozilla.org/en-us/docs/web/api/location/replace
                    window.location.replace(path); // throw a redirect error

                    throw new error('err_redirect');
                  }
                }
              };

              if (false) {}

              if (true) {
                app.context.nuxtstate = window.__nuxt__;
              }
            } // dynamic keys


            _context3.next = 3;
            return promise.all([getroutedata(context.route), getroutedata(context.from)]);

          case 3:
            _yield$promise$all = _context3.sent;
            _yield$promise$all2 = object(_babel_runtime_helpers_esm_slicedtoarray__webpack_imported_module_7__[/* default */ "a"])(_yield$promise$all, 2);
            currentroutedata = _yield$promise$all2[0];
            fromroutedata = _yield$promise$all2[1];

            if (context.route) {
              app.context.route = currentroutedata;
            }

            if (context.from) {
              app.context.from = fromroutedata;
            }

            app.context.next = context.next;
            app.context._redirected = false;
            app.context._errored = false;
            app.context.ishmr = false;
            app.context.params = app.context.route.params || {};
            app.context.query = app.context.route.query || {};

          case 15:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));
  return _setcontext.apply(this, arguments);
}

function middlewareseries(promises, appcontext) {
  if (!promises.length || appcontext._redirected || appcontext._errored) {
    return promise.resolve();
  }

  return promisify(promises[0], appcontext).then(function () {
    return middlewareseries(promises.slice(1), appcontext);
  });
}
function promisify(fn, context) {
  var promise;

  if (fn.length === 2) {
    // fn(context, callback)
    promise = new promise(function (resolve) {
      fn(context, function (err, data) {
        if (err) {
          context.error(err);
        }

        data = data || {};
        resolve(data);
      });
    });
  } else {
    promise = fn(context);
  }

  if (promise && promise instanceof promise && typeof promise.then === 'function') {
    return promise;
  }

  return promise.resolve(promise);
} // imported from vue-router

function getlocation(base, mode) {
  if (mode === 'hash') {
    return window.location.hash.replace(/^#\//, '');
  }

  base = decodeuri(base).slice(0, -1); // consideration is base is normalized with trailing slash

  var path = decodeuri(window.location.pathname);

  if (base && path.startswith(base)) {
    path = path.slice(base.length);
  }

  var fullpath = (path || '/') + window.location.search + window.location.hash;
  return object(ufo__webpack_imported_module_28__[/* normalizeurl */ "c"])(fullpath);
} // imported from path-to-regexp

/**
 * compile a string to a template function for the path.
 *
 * @param  {string}             str
 * @param  {object=}            options
 * @return {!function(object=, object=)}
 */

function compile(str, options) {
  return tokenstofunction(parse(str, options), options);
}
function getquerydiff(toquery, fromquery) {
  var diff = {};

  var queries = _objectspread(_objectspread({}, toquery), fromquery);

  for (var k in queries) {
    if (string(toquery[k]) !== string(fromquery[k])) {
      diff[k] = true;
    }
  }

  return diff;
}
function normalizeerror(err) {
  var message;

  if (!(err.message || typeof err === 'string')) {
    try {
      message = json.stringify(err, null, 2);
    } catch (e) {
      message = "[".concat(err.constructor.name, "]");
    }
  } else {
    message = err.message || err;
  }

  return _objectspread(_objectspread({}, err), {}, {
    message: message,
    statuscode: err.statuscode || err.status || err.response && err.response.status || 500
  });
}
/**
 * the main path matching regexp utility.
 *
 * @type {regexp}
 */

var path_regexp = new regexp([// match escaped characters that would otherwise appear in future matches.
// this allows the user to escape special characters that won't transform.
'(\\\\.)', // match express-style parameters and un-named parameters with a prefix
// and optional suffixes. matches appear as:
//
// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
// "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
// "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
'([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'].join('|'), 'g');
/**
 * parse a string for the raw tokens.
 *
 * @param  {string}  str
 * @param  {object=} options
 * @return {!array}
 */

function parse(str, options) {
  var tokens = [];
  var key = 0;
  var index = 0;
  var path = '';
  var defaultdelimiter = options && options.delimiter || '/';
  var res;

  while ((res = path_regexp.exec(str)) != null) {
    var m = res[0];
    var escaped = res[1];
    var offset = res.index;
    path += str.slice(index, offset);
    index = offset + m.length; // ignore already escaped sequences.

    if (escaped) {
      path += escaped[1];
      continue;
    }

    var next = str[index];
    var prefix = res[2];
    var name = res[3];
    var capture = res[4];
    var group = res[5];
    var modifier = res[6];
    var asterisk = res[7]; // push the current path onto the tokens.

    if (path) {
      tokens.push(path);
      path = '';
    }

    var partial = prefix != null && next != null && next !== prefix;
    var repeat = modifier === '+' || modifier === '*';
    var optional = modifier === '?' || modifier === '*';
    var delimiter = res[2] || defaultdelimiter;
    var pattern = capture || group;
    tokens.push({
      name: name || key++,
      prefix: prefix || '',
      delimiter: delimiter,
      optional: optional,
      repeat: repeat,
      partial: partial,
      asterisk: boolean(asterisk),
      pattern: pattern ? escapegroup(pattern) : asterisk ? '.*' : '[^' + escapestring(delimiter) + ']+?'
    });
  } // match any characters still remaining.


  if (index < str.length) {
    path += str.substr(index);
  } // if the path exists, push it onto the end.


  if (path) {
    tokens.push(path);
  }

  return tokens;
}
/**
 * prettier encoding of uri path segments.
 *
 * @param  {string}
 * @return {string}
 */


function encodeuricomponentpretty(str, slashallowed) {
  var re = slashallowed ? /[?#]/g : /[/?#]/g;
  return encodeuri(str).replace(re, function (c) {
    return '%' + c.charcodeat(0).tostring(16).touppercase();
  });
}
/**
 * encode the asterisk parameter. similar to `pretty`, but allows slashes.
 *
 * @param  {string}
 * @return {string}
 */


function encodeasterisk(str) {
  return encodeuricomponentpretty(str, true);
}
/**
 * escape a regular expression string.
 *
 * @param  {string} str
 * @return {string}
 */


function escapestring(str) {
  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
}
/**
 * escape the capturing group by escaping special characters and meaning.
 *
 * @param  {string} group
 * @return {string}
 */


function escapegroup(group) {
  return group.replace(/([=!:$/()])/g, '\\$1');
}
/**
 * expose a method for transforming tokens into the path function.
 */


function tokenstofunction(tokens, options) {
  // compile all the tokens into regexps.
  var matches = new array(tokens.length); // compile all the patterns before compilation.

  for (var i = 0; i < tokens.length; i++) {
    if (object(_babel_runtime_helpers_esm_typeof__webpack_imported_module_4__[/* default */ "a"])(tokens[i]) === 'object') {
      matches[i] = new regexp('^(?:' + tokens[i].pattern + ')$', flags(options));
    }
  }

  return function (obj, opts) {
    var path = '';
    var data = obj || {};
    var options = opts || {};
    var encode = options.pretty ? encodeuricomponentpretty : encodeuricomponent;

    for (var _i = 0; _i < tokens.length; _i++) {
      var token = tokens[_i];

      if (typeof token === 'string') {
        path += token;
        continue;
      }

      var value = data[token.name || 'pathmatch'];
      var segment = void 0;

      if (value == null) {
        if (token.optional) {
          // prepend partial segment prefixes.
          if (token.partial) {
            path += token.prefix;
          }

          continue;
        } else {
          throw new typeerror('expected "' + token.name + '" to be defined');
        }
      }

      if (array.isarray(value)) {
        if (!token.repeat) {
          throw new typeerror('expected "' + token.name + '" to not repeat, but received `' + json.stringify(value) + '`');
        }

        if (value.length === 0) {
          if (token.optional) {
            continue;
          } else {
            throw new typeerror('expected "' + token.name + '" to not be empty');
          }
        }

        for (var j = 0; j < value.length; j++) {
          segment = encode(value[j]);

          if (!matches[_i].test(segment)) {
            throw new typeerror('expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + json.stringify(segment) + '`');
          }

          path += (j === 0 ? token.prefix : token.delimiter) + segment;
        }

        continue;
      }

      segment = token.asterisk ? encodeasterisk(value) : encode(value);

      if (!matches[_i].test(segment)) {
        throw new typeerror('expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"');
      }

      path += token.prefix + segment;
    }

    return path;
  };
}
/**
 * get the flags for a regexp from the options.
 *
 * @param  {object} options
 * @return {string}
 */


function flags(options) {
  return options && options.sensitive ? '' : 'i';
}

function addlifecyclehook(vm, hook, fn) {
  if (!vm.$options[hook]) {
    vm.$options[hook] = [];
  }

  if (!vm.$options[hook].includes(fn)) {
    vm.$options[hook].push(fn);
  }
}
var urljoin = ufo__webpack_imported_module_28__[/* joinurl */ "b"];
var striptrailingslash = ufo__webpack_imported_module_28__[/* withouttrailingslash */ "e"];
var issamepath = ufo__webpack_imported_module_28__[/* issamepath */ "a"];
function setscrollrestoration(newval) {
  try {
    window.history.scrollrestoration = newval;
  } catch (e) {}
}

/***/ }),

/***/ 208:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* webpack var injection */(function(global) {/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_0__ = __webpack_require__(49);
/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_slice_js__webpack_imported_module_0__);
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_1__ = __webpack_require__(29);
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_1___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_symbol_js__webpack_imported_module_1__);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_2__ = __webpack_require__(47);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_2___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_from_js__webpack_imported_module_2__);
/* harmony import */ var _babel_runtime_helpers_esm_typeof__webpack_imported_module_3__ = __webpack_require__(28);
/* harmony import */ var _babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__ = __webpack_require__(9);
/* harmony import */ var core_js_modules_es6_array_iterator_js__webpack_imported_module_5__ = __webpack_require__(147);
/* harmony import */ var core_js_modules_es6_array_iterator_js__webpack_imported_module_5___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_iterator_js__webpack_imported_module_5__);
/* harmony import */ var core_js_modules_es6_promise_js__webpack_imported_module_6__ = __webpack_require__(216);
/* harmony import */ var core_js_modules_es6_promise_js__webpack_imported_module_6___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_promise_js__webpack_imported_module_6__);
/* harmony import */ var core_js_modules_es6_object_assign_js__webpack_imported_module_7__ = __webpack_require__(221);
/* harmony import */ var core_js_modules_es6_object_assign_js__webpack_imported_module_7___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_assign_js__webpack_imported_module_7__);
/* harmony import */ var core_js_modules_es7_promise_finally_js__webpack_imported_module_8__ = __webpack_require__(223);
/* harmony import */ var core_js_modules_es7_promise_finally_js__webpack_imported_module_8___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_promise_finally_js__webpack_imported_module_8__);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_9__ = __webpack_require__(44);
/* harmony import */ var regenerator_runtime_runtime_js__webpack_imported_module_9___default = /*#__pure__*/__webpack_require__.n(regenerator_runtime_runtime_js__webpack_imported_module_9__);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_10__ = __webpack_require__(25);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_10___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_function_name_js__webpack_imported_module_10__);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_11__ = __webpack_require__(31);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_11___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_filter_js__webpack_imported_module_11__);
/* harmony import */ var core_js_modules_es6_object_keys_js__webpack_imported_module_12__ = __webpack_require__(34);
/* harmony import */ var core_js_modules_es6_object_keys_js__webpack_imported_module_12___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_keys_js__webpack_imported_module_12__);
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_13__ = __webpack_require__(75);
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_13___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_includes_js__webpack_imported_module_13__);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_14__ = __webpack_require__(76);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_14___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_array_includes_js__webpack_imported_module_14__);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_15__ = __webpack_require__(50);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_15___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_map_js__webpack_imported_module_15__);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_16__ = __webpack_require__(45);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_16___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_iterator_js__webpack_imported_module_16__);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_17__ = __webpack_require__(19);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_17___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_to_string_js__webpack_imported_module_17__);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_18__ = __webpack_require__(46);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_18___default = /*#__pure__*/__webpack_require__.n(core_js_modules_web_dom_iterable_js__webpack_imported_module_18__);
/* harmony import */ var vue__webpack_imported_module_19__ = __webpack_require__(5);
/* harmony import */ var unfetch__webpack_imported_module_20__ = __webpack_require__(179);
/* harmony import */ var _middleware_js__webpack_imported_module_21__ = __webpack_require__(112);
/* harmony import */ var _utils_js__webpack_imported_module_22__ = __webpack_require__(2);
/* harmony import */ var _index_js__webpack_imported_module_23__ = __webpack_require__(33);
/* harmony import */ var _mixins_fetch_client__webpack_imported_module_24__ = __webpack_require__(198);
/* harmony import */ var _components_nuxt_link_client_js__webpack_imported_module_25__ = __webpack_require__(91);










function _createforofiteratorhelper(o, allowarraylike) { var it = typeof symbol !== "undefined" && o[symbol.iterator] || o["@@iterator"]; if (!it) { if (array.isarray(o) || (it = _unsupportediterabletoarray(o)) || allowarraylike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var f = function f() {}; return { s: f, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: f }; } throw new typeerror("invalid attempt to iterate non-iterable instance.\nin order to be iterable, non-array objects must have a [symbol.iterator]() method."); } var normalcompletion = true, diderr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalcompletion = step.done; return step; }, e: function e(_e2) { diderr = true; err = _e2; }, f: function f() { try { if (!normalcompletion && it.return != null) it.return(); } finally { if (diderr) throw err; } } }; }

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; }

















 // should be included after ./index.js
// fetch mixin

if (!vue__webpack_imported_module_19__["default"].__nuxt__fetch__mixin__) {
  vue__webpack_imported_module_19__["default"].mixin(_mixins_fetch_client__webpack_imported_module_24__[/* default */ "a"]);
  vue__webpack_imported_module_19__["default"].__nuxt__fetch__mixin__ = true;
} // component: <nuxtlink>


vue__webpack_imported_module_19__["default"].component(_components_nuxt_link_client_js__webpack_imported_module_25__[/* default */ "a"].name, _components_nuxt_link_client_js__webpack_imported_module_25__[/* default */ "a"]);
vue__webpack_imported_module_19__["default"].component('nlink', _components_nuxt_link_client_js__webpack_imported_module_25__[/* default */ "a"]);

if (!global.fetch) {
  global.fetch = unfetch__webpack_imported_module_20__[/* default */ "a"];
} // global shared references


var _lastpaths = [];
var app;
var router;
var store; // try to rehydrate ssr data from window

var nuxt = window.__nuxt__ || {};
var $config = nuxt.config || {};

if ($config._app) {
  __webpack_require__.p = object(_utils_js__webpack_imported_module_22__[/* urljoin */ "v"])($config._app.cdnurl, $config._app.assetspath);
}

object.assign(vue__webpack_imported_module_19__["default"].config, {
  "silent": true,
  "performance": false
});
var errorhandler = vue__webpack_imported_module_19__["default"].config.errorhandler || console.error; // create and mount app

object(_index_js__webpack_imported_module_23__[/* createapp */ "b"])(null, nuxt.config).then(mountapp).catch(errorhandler);

function componentoption(component, key) {
  if (!component || !component.options || !component.options[key]) {
    return {};
  }

  var option = component.options[key];

  if (typeof option === 'function') {
    for (var _len = arguments.length, args = new array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    return option.apply(void 0, args);
  }

  return option;
}

function maptransitions(tocomponents, to, from) {
  var componenttransitions = function componenttransitions(component) {
    var transition = componentoption(component, 'transition', to, from) || {};
    return typeof transition === 'string' ? {
      name: transition
    } : transition;
  };

  var fromcomponents = from ? object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponents */ "g"])(from) : [];
  var maxdepth = math.max(tocomponents.length, fromcomponents.length);
  var mergedtransitions = [];

  var _loop = function _loop(i) {
    // clone original objects to prevent overrides
    var totransitions = object.assign({}, componenttransitions(tocomponents[i]));
    var transitions = object.assign({}, componenttransitions(fromcomponents[i])); // combine transitions & prefer `leave` properties of "from" route

    object.keys(totransitions).filter(function (key) {
      return typeof totransitions[key] !== 'undefined' && !key.tolowercase().includes('leave');
    }).foreach(function (key) {
      transitions[key] = totransitions[key];
    });
    mergedtransitions.push(transitions);
  };

  for (var i = 0; i < maxdepth; i++) {
    _loop(i);
  }

  return mergedtransitions;
}

function loadasynccomponents(_x, _x2, _x3) {
  return _loadasynccomponents.apply(this, arguments);
}

function _loadasynccomponents() {
  _loadasynccomponents = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee2(to, from, next) {
    var _this3 = this;

    var components, startloader, err, statuscode, message;
    return regeneratorruntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            // check if route changed (this._routechanged), only if the page is not an error (for validate())
            this._routechanged = boolean(app.nuxt.err) || from.name !== to.name;
            this._paramchanged = !this._routechanged && from.path !== to.path;
            this._querychanged = !this._paramchanged && from.fullpath !== to.fullpath;
            this._diffquery = this._querychanged ? object(_utils_js__webpack_imported_module_22__[/* getquerydiff */ "i"])(to.query, from.query) : [];

            if ((this._routechanged || this._paramchanged) && this.$loading.start && !this.$loading.manual) {
              this.$loading.start();
            }

            _context2.prev = 5;

            if (!this._querychanged) {
              _context2.next = 12;
              break;
            }

            _context2.next = 9;
            return object(_utils_js__webpack_imported_module_22__[/* resolveroutecomponents */ "r"])(to, function (component, instance) {
              return {
                component: component,
                instance: instance
              };
            });

          case 9:
            components = _context2.sent;
            // add a marker on each component that it needs to refresh or not
            startloader = components.some(function (_ref2) {
              var component = _ref2.component,
                  instance = _ref2.instance;
              var watchquery = component.options.watchquery;

              if (watchquery === true) {
                return true;
              }

              if (array.isarray(watchquery)) {
                return watchquery.some(function (key) {
                  return _this3._diffquery[key];
                });
              }

              if (typeof watchquery === 'function') {
                return watchquery.apply(instance, [to.query, from.query]);
              }

              return false;
            });

            if (startloader && this.$loading.start && !this.$loading.manual) {
              this.$loading.start();
            }

          case 12:
            // call next()
            next();
            _context2.next = 26;
            break;

          case 15:
            _context2.prev = 15;
            _context2.t0 = _context2["catch"](5);
            err = _context2.t0 || {};
            statuscode = err.statuscode || err.status || err.response && err.response.status || 500;
            message = err.message || ''; // handle chunk loading errors
            // this may be due to a new deployment or a network problem

            if (!/^loading( css)? chunk (\d)+ failed\./.test(message)) {
              _context2.next = 23;
              break;
            }

            window.location.reload(true
            /* skip cache */
            );
            return _context2.abrupt("return");

          case 23:
            this.error({
              statuscode: statuscode,
              message: message
            });
            this.$nuxt.$emit('routechanged', to, from, err);
            next();

          case 26:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, this, [[5, 15]]);
  }));
  return _loadasynccomponents.apply(this, arguments);
}

function applyssrdata(component, ssrdata) {
  if (nuxt.serverrendered && ssrdata) {
    object(_utils_js__webpack_imported_module_22__[/* applyasyncdata */ "b"])(component, ssrdata);
  }

  component._ctor = component;
  return component;
} // get matched components


function resolvecomponents(route) {
  return object(_utils_js__webpack_imported_module_22__[/* flatmapcomponents */ "d"])(route, /*#__pure__*/function () {
    var _ref = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee(component, _, match, key, index) {
      var _component;

      return regeneratorruntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (!(typeof component === 'function' && !component.options)) {
                _context.next = 4;
                break;
              }

              _context.next = 3;
              return component();

            case 3:
              component = _context.sent;

            case 4:
              // sanitize it and save it
              _component = applyssrdata(object(_utils_js__webpack_imported_module_22__[/* sanitizecomponent */ "s"])(component), nuxt.data ? nuxt.data[index] : null);
              match.components[key] = _component;
              return _context.abrupt("return", _component);

            case 7:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

    return function (_x4, _x5, _x6, _x7, _x8) {
      return _ref.apply(this, arguments);
    };
  }());
}

function callmiddleware(components, context, layout) {
  var _this = this;

  var midd = ["route"];
  var unknownmiddleware = false; // if layout is undefined, only call global middleware

  if (typeof layout !== 'undefined') {
    midd = []; // exclude global middleware if layout defined (already called before)

    layout = object(_utils_js__webpack_imported_module_22__[/* sanitizecomponent */ "s"])(layout);

    if (layout.options.middleware) {
      midd = midd.concat(layout.options.middleware);
    }

    components.foreach(function (component) {
      if (component.options.middleware) {
        midd = midd.concat(component.options.middleware);
      }
    });
  }

  midd = midd.map(function (name) {
    if (typeof name === 'function') {
      return name;
    }

    if (typeof _middleware_js__webpack_imported_module_21__[/* default */ "a"][name] !== 'function') {
      unknownmiddleware = true;

      _this.error({
        statuscode: 500,
        message: 'unknown middleware ' + name
      });
    }

    return _middleware_js__webpack_imported_module_21__[/* default */ "a"][name];
  });

  if (unknownmiddleware) {
    return;
  }

  return object(_utils_js__webpack_imported_module_22__[/* middlewareseries */ "o"])(midd, context);
}

function render(_x9, _x10, _x11) {
  return _render.apply(this, arguments);
} // fix components format in matched, it's due to code-splitting of vue-router


function _render() {
  _render = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee4(to, from, next) {
    var _this4 = this;

    var spafallback, frommatches, nextcalled, _next, matches, components, errorlayout, layout, _layout, isvalid, _iterator, _step, component, instances, error, _layout2;

    return regeneratorruntime.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            if (!(this._routechanged === false && this._paramchanged === false && this._querychanged === false)) {
              _context4.next = 2;
              break;
            }

            return _context4.abrupt("return", next());

          case 2:
            // handle first render on spa mode
            spafallback = false;

            if (to === from) {
              _lastpaths = [];
              spafallback = true;
            } else {
              frommatches = [];
              _lastpaths = object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponents */ "g"])(from, frommatches).map(function (component, i) {
                return object(_utils_js__webpack_imported_module_22__[/* compile */ "c"])(from.matched[frommatches[i]].path)(from.params);
              });
            } // nextcalled is true when redirected


            nextcalled = false;

            _next = function _next(path) {
              if (from.path === path.path && _this4.$loading.finish) {
                _this4.$loading.finish();
              }

              if (from.path !== path.path && _this4.$loading.pause) {
                _this4.$loading.pause();
              }

              if (nextcalled) {
                return;
              }

              nextcalled = true;
              next(path);
            }; // update context


            _context4.next = 8;
            return object(_utils_js__webpack_imported_module_22__[/* setcontext */ "t"])(app, {
              route: to,
              from: from,
              next: _next.bind(this)
            });

          case 8:
            this._datelasterror = app.nuxt.dateerr;
            this._haderror = boolean(app.nuxt.err); // get route's matched components

            matches = [];
            components = object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponents */ "g"])(to, matches); // if no components matched, generate 404

            if (components.length) {
              _context4.next = 27;
              break;
            }

            _context4.next = 15;
            return callmiddleware.call(this, components, app.context);

          case 15:
            if (!nextcalled) {
              _context4.next = 17;
              break;
            }

            return _context4.abrupt("return");

          case 17:
            // load layout for error page
            errorlayout = (_index_js__webpack_imported_module_23__[/* nuxterror */ "a"].options || _index_js__webpack_imported_module_23__[/* nuxterror */ "a"]).layout;
            _context4.next = 20;
            return this.loadlayout(typeof errorlayout === 'function' ? errorlayout.call(_index_js__webpack_imported_module_23__[/* nuxterror */ "a"], app.context) : errorlayout);

          case 20:
            layout = _context4.sent;
            _context4.next = 23;
            return callmiddleware.call(this, components, app.context, layout);

          case 23:
            if (!nextcalled) {
              _context4.next = 25;
              break;
            }

            return _context4.abrupt("return");

          case 25:
            // show error page
            app.context.error({
              statuscode: 404,
              message: 'this page could not be found'
            });
            return _context4.abrupt("return", next());

          case 27:
            // update ._data and other properties if hot reloaded
            components.foreach(function (component) {
              if (component._ctor && component._ctor.options) {
                component.options.asyncdata = component._ctor.options.asyncdata;
                component.options.fetch = component._ctor.options.fetch;
              }
            }); // apply transitions

            this.settransitions(maptransitions(components, to, from));
            _context4.prev = 29;
            _context4.next = 32;
            return callmiddleware.call(this, components, app.context);

          case 32:
            if (!nextcalled) {
              _context4.next = 34;
              break;
            }

            return _context4.abrupt("return");

          case 34:
            if (!app.context._errored) {
              _context4.next = 36;
              break;
            }

            return _context4.abrupt("return", next());

          case 36:
            // set layout
            _layout = components[0].options.layout;

            if (typeof _layout === 'function') {
              _layout = _layout(app.context);
            }

            _context4.next = 40;
            return this.loadlayout(_layout);

          case 40:
            _layout = _context4.sent;
            _context4.next = 43;
            return callmiddleware.call(this, components, app.context, _layout);

          case 43:
            if (!nextcalled) {
              _context4.next = 45;
              break;
            }

            return _context4.abrupt("return");

          case 45:
            if (!app.context._errored) {
              _context4.next = 47;
              break;
            }

            return _context4.abrupt("return", next());

          case 47:
            // call .validate()
            isvalid = true;
            _context4.prev = 48;
            _iterator = _createforofiteratorhelper(components);
            _context4.prev = 50;

            _iterator.s();

          case 52:
            if ((_step = _iterator.n()).done) {
              _context4.next = 63;
              break;
            }

            component = _step.value;

            if (!(typeof component.options.validate !== 'function')) {
              _context4.next = 56;
              break;
            }

            return _context4.abrupt("continue", 61);

          case 56:
            _context4.next = 58;
            return component.options.validate(app.context);

          case 58:
            isvalid = _context4.sent;

            if (isvalid) {
              _context4.next = 61;
              break;
            }

            return _context4.abrupt("break", 63);

          case 61:
            _context4.next = 52;
            break;

          case 63:
            _context4.next = 68;
            break;

          case 65:
            _context4.prev = 65;
            _context4.t0 = _context4["catch"](50);

            _iterator.e(_context4.t0);

          case 68:
            _context4.prev = 68;

            _iterator.f();

            return _context4.finish(68);

          case 71:
            _context4.next = 77;
            break;

          case 73:
            _context4.prev = 73;
            _context4.t1 = _context4["catch"](48);
            // ...if .validate() threw an error
            this.error({
              statuscode: _context4.t1.statuscode || '500',
              message: _context4.t1.message
            });
            return _context4.abrupt("return", next());

          case 77:
            if (isvalid) {
              _context4.next = 80;
              break;
            }

            this.error({
              statuscode: 404,
              message: 'this page could not be found'
            });
            return _context4.abrupt("return", next());

          case 80:
            _context4.next = 82;
            return promise.all(components.map( /*#__pure__*/function () {
              var _ref3 = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee3(component, i) {
                var childpathchanged, watchparam, watchquery, promises, hasasyncdata, hasfetch, loadingincrease, promise, p;
                return regeneratorruntime.wrap(function _callee3$(_context3) {
                  while (1) {
                    switch (_context3.prev = _context3.next) {
                      case 0:
                        // check if only children route changed
                        component._path = object(_utils_js__webpack_imported_module_22__[/* compile */ "c"])(to.matched[matches[i]].path)(to.params);
                        component._datarefresh = false;
                        childpathchanged = component._path !== _lastpaths[i]; // refresh component (call asyncdata & fetch) when:
                        // route path changed part includes current component
                        // or route param changed part includes current component and watchparam is not `false`
                        // or route query is changed and watchquery returns `true`

                        // refresh component (call asyncdata & fetch) when:
                        // route path changed part includes current component
                        // or route param changed part includes current component and watchparam is not `false`
                        // or route query is changed and watchquery returns `true`
                        if (_this4._routechanged && childpathchanged) {
                          component._datarefresh = true;
                        } else if (_this4._paramchanged && childpathchanged) {
                          watchparam = component.options.watchparam;
                          component._datarefresh = watchparam !== false;
                        } else if (_this4._querychanged) {
                          watchquery = component.options.watchquery;

                          if (watchquery === true) {
                            component._datarefresh = true;
                          } else if (array.isarray(watchquery)) {
                            component._datarefresh = watchquery.some(function (key) {
                              return _this4._diffquery[key];
                            });
                          } else if (typeof watchquery === 'function') {
                            if (!instances) {
                              instances = object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponentsinstances */ "h"])(to);
                            }

                            component._datarefresh = watchquery.apply(instances[i], [to.query, from.query]);
                          }
                        }

                        if (!(!_this4._haderror && _this4._ismounted && !component._datarefresh)) {
                          _context3.next = 6;
                          break;
                        }

                        return _context3.abrupt("return");

                      case 6:
                        promises = [];
                        hasasyncdata = component.options.asyncdata && typeof component.options.asyncdata === 'function';
                        hasfetch = boolean(component.options.fetch) && component.options.fetch.length;
                        loadingincrease = hasasyncdata && hasfetch ? 30 : 45; // call asyncdata(context)

                        // call asyncdata(context)
                        if (hasasyncdata) {
                          promise = object(_utils_js__webpack_imported_module_22__[/* promisify */ "q"])(component.options.asyncdata, app.context);
                          promise.then(function (asyncdataresult) {
                            object(_utils_js__webpack_imported_module_22__[/* applyasyncdata */ "b"])(component, asyncdataresult);

                            if (_this4.$loading.increase) {
                              _this4.$loading.increase(loadingincrease);
                            }
                          });
                          promises.push(promise);
                        } // check disabled page loading


                        // check disabled page loading
                        _this4.$loading.manual = component.options.loading === false; // call fetch(context)

                        // call fetch(context)
                        if (hasfetch) {
                          p = component.options.fetch(app.context);

                          if (!p || !(p instanceof promise) && typeof p.then !== 'function') {
                            p = promise.resolve(p);
                          }

                          p.then(function (fetchresult) {
                            if (_this4.$loading.increase) {
                              _this4.$loading.increase(loadingincrease);
                            }
                          });
                          promises.push(p);
                        }

                        return _context3.abrupt("return", promise.all(promises));

                      case 14:
                      case "end":
                        return _context3.stop();
                    }
                  }
                }, _callee3);
              }));

              return function (_x13, _x14) {
                return _ref3.apply(this, arguments);
              };
            }()));

          case 82:
            // if not redirected
            if (!nextcalled) {
              if (this.$loading.finish && !this.$loading.manual) {
                this.$loading.finish();
              }

              next();
            }

            _context4.next = 99;
            break;

          case 85:
            _context4.prev = 85;
            _context4.t2 = _context4["catch"](29);
            error = _context4.t2 || {};

            if (!(error.message === 'err_redirect')) {
              _context4.next = 90;
              break;
            }

            return _context4.abrupt("return", this.$nuxt.$emit('routechanged', to, from, error));

          case 90:
            _lastpaths = [];
            object(_utils_js__webpack_imported_module_22__[/* globalhandleerror */ "k"])(error); // load error layout

            _layout2 = (_index_js__webpack_imported_module_23__[/* nuxterror */ "a"].options || _index_js__webpack_imported_module_23__[/* nuxterror */ "a"]).layout;

            if (typeof _layout2 === 'function') {
              _layout2 = _layout2(app.context);
            }

            _context4.next = 96;
            return this.loadlayout(_layout2);

          case 96:
            this.error(error);
            this.$nuxt.$emit('routechanged', to, from, error);
            next();

          case 99:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4, this, [[29, 85], [48, 73], [50, 65, 68, 71]]);
  }));
  return _render.apply(this, arguments);
}

function normalizecomponents(to, ___) {
  object(_utils_js__webpack_imported_module_22__[/* flatmapcomponents */ "d"])(to, function (component, _, match, key) {
    if (object(_babel_runtime_helpers_esm_typeof__webpack_imported_module_3__[/* default */ "a"])(component) === 'object' && !component.options) {
      // updated via vue-router resolveasynccomponents()
      component = vue__webpack_imported_module_19__["default"].extend(component);
      component._ctor = component;
      match.components[key] = component;
    }

    return component;
  });
}

function setlayoutfornextpage(to) {
  // set layout
  var haserror = boolean(this.$options.nuxt.err);

  if (this._haderror && this._datelasterror === this.$options.nuxt.dateerr) {
    haserror = false;
  }

  var layout = haserror ? (_index_js__webpack_imported_module_23__[/* nuxterror */ "a"].options || _index_js__webpack_imported_module_23__[/* nuxterror */ "a"]).layout : to.matched[0].components.default.options.layout;

  if (typeof layout === 'function') {
    layout = layout(app.context);
  }

  this.setlayout(layout);
}

function checkforerrors(app) {
  // hide error component if no error
  if (app._haderror && app._datelasterror === app.$options.nuxt.dateerr) {
    app.error();
  }
} // when navigating on a different route but the same component is used, vue.js
// will not update the instance data, so we have to update $data ourselves


function fixprepatch(to, ___) {
  var _this2 = this;

  if (this._routechanged === false && this._paramchanged === false && this._querychanged === false) {
    return;
  }

  var instances = object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponentsinstances */ "h"])(to);
  var components = object(_utils_js__webpack_imported_module_22__[/* getmatchedcomponents */ "g"])(to);
  var triggerscroll = false;
  vue__webpack_imported_module_19__["default"].nexttick(function () {
    instances.foreach(function (instance, i) {
      if (!instance || instance._isdestroyed) {
        return;
      }

      if (instance.constructor._datarefresh && components[i] === instance.constructor && instance.$vnode.data.keepalive !== true && typeof instance.constructor.options.data === 'function') {
        var newdata = instance.constructor.options.data.call(instance);

        for (var key in newdata) {
          vue__webpack_imported_module_19__["default"].set(instance.$data, key, newdata[key]);
        }

        triggerscroll = true;
      }
    });

    if (triggerscroll) {
      // ensure to trigger scroll event after calling scrollbehavior
      window.$nuxt.$nexttick(function () {
        window.$nuxt.$emit('triggerscroll');
      });
    }

    checkforerrors(_this2);
  });
}

function nuxtready(_app) {
  window.onnuxtreadycbs.foreach(function (cb) {
    if (typeof cb === 'function') {
      cb(_app);
    }
  }); // special jsdom

  if (typeof window._onnuxtloaded === 'function') {
    window._onnuxtloaded(_app);
  } // add router hooks


  router.aftereach(function (to, from) {
    // wait for fixprepatch + $data updates
    vue__webpack_imported_module_19__["default"].nexttick(function () {
      return _app.$nuxt.$emit('routechanged', to, from);
    });
  });
}

function mountapp(_x12) {
  return _mountapp.apply(this, arguments);
}

function _mountapp() {
  _mountapp = object(_babel_runtime_helpers_esm_asynctogenerator__webpack_imported_module_4__[/* default */ "a"])( /*#__pure__*/regeneratorruntime.mark(function _callee5(__app) {
    var _app, layout, mount, components, clientfirstmount;

    return regeneratorruntime.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            // set global variables
            app = __app.app;
            router = __app.router;
            store = __app.store; // create vue instance

            _app = new vue__webpack_imported_module_19__["default"](app); // load layout

            layout = nuxt.layout || 'default';
            _context5.next = 7;
            return _app.loadlayout(layout);

          case 7:
            _app.setlayout(layout); // mounts vue app to dom element


            mount = function mount() {
              _app.$mount('#__nuxt'); // add aftereach router hooks


              router.aftereach(normalizecomponents);
              router.aftereach(setlayoutfornextpage.bind(_app));
              router.aftereach(fixprepatch.bind(_app)); // listen for first vue update

              vue__webpack_imported_module_19__["default"].nexttick(function () {
                // call window.{{globals.readycallback}} callbacks
                nuxtready(_app);
              });
            }; // resolve route components


            _context5.next = 11;
            return promise.all(resolvecomponents(app.context.route));

          case 11:
            components = _context5.sent;
            // enable transitions
            _app.settransitions = _app.$options.nuxt.settransitions.bind(_app);

            if (components.length) {
              _app.settransitions(maptransitions(components, router.currentroute));

              _lastpaths = router.currentroute.matched.map(function (route) {
                return object(_utils_js__webpack_imported_module_22__[/* compile */ "c"])(route.path)(router.currentroute.params);
              });
            } // initialize error handler


            _app.$loading = {}; // to avoid error while _app.$nuxt does not exist

            if (nuxt.error) {
              _app.error(nuxt.error);
            } // add beforeeach router hooks


            router.beforeeach(loadasynccomponents.bind(_app));
            router.beforeeach(render.bind(_app)); // fix in static: remove trailing slash to force hydration
            // full static, if server-rendered: hydrate, to allow custom redirect to generated page
            // fix in static: remove trailing slash to force hydration

            if (!(nuxt.serverrendered && object(_utils_js__webpack_imported_module_22__[/* issamepath */ "n"])(nuxt.routepath, _app.context.route.path))) {
              _context5.next = 20;
              break;
            }

            return _context5.abrupt("return", mount());

          case 20:
            // first render on client-side
            clientfirstmount = function clientfirstmount() {
              normalizecomponents(router.currentroute, router.currentroute);
              setlayoutfornextpage.call(_app, router.currentroute);
              checkforerrors(_app); // don't call fixprepatch.call(_app, router.currentroute, router.currentroute) since it's first render

              mount();
            }; // fix: force next tick to avoid having same timestamp when an error happen on spa fallback


            _context5.next = 23;
            return new promise(function (resolve) {
              return settimeout(resolve, 0);
            });

          case 23:
            render.call(_app, router.currentroute, router.currentroute, function (path) {
              // if not redirected
              if (!path) {
                clientfirstmount();
                return;
              } // add a one-time aftereach hook to
              // mount the app wait for redirect and route gets resolved


              var unregisterhook = router.aftereach(function (to, from) {
                unregisterhook();
                clientfirstmount();
              }); // push the path and let route to be resolved

              router.push(path, undefined, function (err) {
                if (err) {
                  errorhandler(err);
                }
              });
            });

          case 24:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee5);
  }));
  return _mountapp.apply(this, arguments);
}
/* webpack var injection */}.call(this, __webpack_require__(15)))

/***/ }),

/***/ 240:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var _node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_error_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0__ = __webpack_require__(158);
/* harmony import */ var _node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_error_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(_node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_error_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0__);
/* unused harmony reexport * */


/***/ }),

/***/ 241:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var _node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_loading_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0__ = __webpack_require__(159);
/* harmony import */ var _node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_loading_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(_node_modules_extract_css_chunks_webpack_plugin_dist_loader_js_ref_3_oneof_1_0_node_modules_css_loader_dist_cjs_js_ref_3_oneof_1_1_node_modules_vue_loader_lib_loaders_stylepostloader_js_node_modules_postcss_loader_lib_index_js_ref_3_oneof_1_2_node_modules_vue_loader_lib_index_js_vue_loader_options_nuxt_loading_vue_vue_type_style_index_0_lang_css___webpack_imported_module_0__);
/* unused harmony reexport * */


/***/ }),

/***/ 33:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// exports
__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ createapp; });
__webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ nuxt_error; });

// external module: ./node_modules/core-js/modules/es6.object.keys.js
var es6_object_keys = __webpack_require__(34);

// external module: ./node_modules/core-js/modules/es6.symbol.js
var es6_symbol = __webpack_require__(29);

// external module: ./node_modules/core-js/modules/es6.array.filter.js
var es6_array_filter = __webpack_require__(31);

// external module: ./node_modules/core-js/modules/es6.object.get-own-property-descriptor.js
var es6_object_get_own_property_descriptor = __webpack_require__(51);

// external module: ./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js
var es7_object_get_own_property_descriptors = __webpack_require__(52);

// external module: ./node_modules/@babel/runtime/helpers/esm/asynctogenerator.js
var asynctogenerator = __webpack_require__(9);

// external module: ./node_modules/@babel/runtime/helpers/esm/defineproperty.js
var defineproperty = __webpack_require__(20);

// external module: ./node_modules/regenerator-runtime/runtime.js
var runtime = __webpack_require__(44);

// external module: ./node_modules/core-js/modules/es6.function.name.js
var es6_function_name = __webpack_require__(25);

// external module: ./node_modules/core-js/modules/es6.array.map.js
var es6_array_map = __webpack_require__(50);

// external module: ./node_modules/core-js/modules/es6.object.to-string.js
var es6_object_to_string = __webpack_require__(19);

// external module: ./node_modules/core-js/modules/es6.regexp.replace.js
var es6_regexp_replace = __webpack_require__(61);

// external module: ./node_modules/vue/dist/vue.runtime.esm.js
var vue_runtime_esm = __webpack_require__(5);

// external module: ./node_modules/vuex/dist/vuex.esm.js
var vuex_esm = __webpack_require__(62);

// external module: ./node_modules/vue-meta/dist/vue-meta.esm.browser.js
var vue_meta_esm_browser = __webpack_require__(182);

// external module: ./node_modules/vue-client-only/dist/vue-client-only.common.js
var vue_client_only_common = __webpack_require__(114);
var vue_client_only_common_default = /*#__pure__*/__webpack_require__.n(vue_client_only_common);

// external module: ./node_modules/vue-no-ssr/dist/vue-no-ssr.common.js
var vue_no_ssr_common = __webpack_require__(54);
var vue_no_ssr_common_default = /*#__pure__*/__webpack_require__.n(vue_no_ssr_common);

// external module: ./node_modules/vue-router/dist/vue-router.esm.js
var vue_router_esm = __webpack_require__(115);

// external module: ./node_modules/ufo/dist/index.mjs
var dist = __webpack_require__(32);

// external module: ./nuxt/utils.js
var utils = __webpack_require__(2);

// concatenated module: ./nuxt/router.scrollbehavior.js



if (true) {
  if ('scrollrestoration' in window.history) {
    object(utils["u" /* setscrollrestoration */])('manual'); // reset scrollrestoration to auto when leaving page, allowing page reload
    // and back-navigation from other pages to use the browser to restore the
    // scrolling position.

    window.addeventlistener('beforeunload', function () {
      object(utils["u" /* setscrollrestoration */])('auto');
    }); // setting scrollrestoration to manual again when returning to this page.

    window.addeventlistener('load', function () {
      object(utils["u" /* setscrollrestoration */])('manual');
    });
  }
}

function shouldscrolltotop(route) {
  var pages = object(utils["g" /* getmatchedcomponents */])(route);

  if (pages.length === 1) {
    var _pages$0$options = pages[0].options,
        options = _pages$0$options === void 0 ? {} : _pages$0$options;
    return options.scrolltotop !== false;
  }

  return pages.some(function (_ref) {
    var options = _ref.options;
    return options && options.scrolltotop;
  });
}

/* harmony default export */ var router_scrollbehavior = (function (to, from, savedposition) {
  // if the returned position is falsy or an empty object, will retain current scroll position
  var position = false;
  var isroutechanged = to !== from; // savedposition is only available for popstate navigations (back button)

  if (savedposition) {
    position = savedposition;
  } else if (isroutechanged && shouldscrolltotop(to)) {
    position = {
      x: 0,
      y: 0
    };
  }

  var nuxt = window.$nuxt;

  if ( // initial load (vuejs/vue-router#3199)
  !isroutechanged || // route hash changes
  to.path === from.path && to.hash !== from.hash) {
    nuxt.$nexttick(function () {
      return nuxt.$emit('triggerscroll');
    });
  }

  return new promise(function (resolve) {
    // wait for the out transition to complete (if necessary)
    nuxt.$once('triggerscroll', function () {
      // coords will be used if no selector is provided,
      // or if the selector didn't match any element.
      if (to.hash) {
        var hash = to.hash; // css.escape() is not supported with ie and edge.

        if (typeof window.css !== 'undefined' && typeof window.css.escape !== 'undefined') {
          hash = '#' + window.css.escape(hash.substr(1));
        }

        try {
          if (document.queryselector(hash)) {
            // scroll to anchor by returning the selector
            position = {
              selector: hash
            };
          }
        } catch (e) {
          console.warn('failed to save scroll position. please add css.escape() polyfill (https://github.com/mathiasbynens/css.escape).');
        }
      }

      resolve(position);
    });
  });
});
// concatenated module: ./nuxt/router.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 _objectspread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownkeys(object(source), !0).foreach(function (key) { object(defineproperty["a" /* default */])(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; }







var router_48c46bbe = function _48c46bbe() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/aboutus */ 15).then(__webpack_require__.bind(null, 829)));
};

var router_fe291e50 = function _fe291e50() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/case/index */ 17).then(__webpack_require__.bind(null, 828)));
};

var router_fbe87e18 = function _fbe87e18() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/contactus */ 18).then(__webpack_require__.bind(null, 830)));
};

var router_5fae23ee = function _5fae23ee() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/dacaigou/index */ 21).then(__webpack_require__.bind(null, 831)));
};

var router_0ff890b9 = function _0ff890b9() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/datacenter */ 22).then(__webpack_require__.bind(null, 832)));
};

var router_3aec38c2 = function _3aec38c2() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/download */ 23).then(__webpack_require__.bind(null, 826)));
};

var router_7eda5a02 = function _7eda5a02() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/joinus */ 27).then(__webpack_require__.bind(null, 833)));
};

var router_0a934d55 = function _0a934d55() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/news/index */ 28).then(__webpack_require__.bind(null, 834)));
};

var router_03836365 = function _03836365() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/partners */ 30).then(__webpack_require__.bind(null, 835)));
};

var router_367f3324 = function _367f3324() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/products/index */ 48).then(__webpack_require__.bind(null, 836)));
};

var router_d0858f4e = function _d0858f4e() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/required */ 58).then(__webpack_require__.bind(null, 837)));
};

var router_710575c6 = function _710575c6() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/serve/index */ 59).then(__webpack_require__.bind(null, 838)));
};

var router_573e022a = function _573e022a() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/sitemap */ 60).then(__webpack_require__.bind(null, 497)));
};

var router_b910b502 = function _b910b502() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/study */ 61).then(__webpack_require__.bind(null, 839)));
};

var router_124f7c6a = function _124f7c6a() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/error/404 */ 24).then(__webpack_require__.bind(null, 840)));
};

var router_46fd59a7 = function _46fd59a7() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/error/500 */ 25).then(__webpack_require__.bind(null, 841)));
};

var router_bc33da08 = function _bc33da08() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/dacaigou/components/header */ 19).then(__webpack_require__.bind(null, 498)));
};

var router_6a254da2 = function _6a254da2() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/dacaigou/components/submitdialog */ 20).then(__webpack_require__.bind(null, 499)));
};

var router_cca1dba6 = function _cca1dba6() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/bidding/bigdata */[__webpack_require__.e(0), __webpack_require__.e(2), __webpack_require__.e(31)]).then(__webpack_require__.bind(null, 842)));
};

var router_533fdbda = function _533fdbda() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/bidding/cost */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(32)]).then(__webpack_require__.bind(null, 843)));
};

var router_d696a756 = function _d696a756() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/bidding/dzztb */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(33)]).then(__webpack_require__.bind(null, 844)));
};

var router_6413cce6 = function _6413cce6() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/bidding/saas */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(34)]).then(__webpack_require__.bind(null, 845)));
};

var router_4289e84e = function _4289e84e() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/bidding/supplier */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(35)]).then(__webpack_require__.bind(null, 846)));
};

var router_1462643d = function _1462643d() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/biddingassist/bst */[__webpack_require__.e(0), __webpack_require__.e(36)]).then(__webpack_require__.bind(null, 847)));
};

var router_16c7eee7 = function _16c7eee7() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/gczjgl/projectcost */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(37)]).then(__webpack_require__.bind(null, 848)));
};

var router_1c07bf55 = function _1c07bf55() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/gczjgl/qingbiao */[__webpack_require__.e(0), __webpack_require__.e(2), __webpack_require__.e(38)]).then(__webpack_require__.bind(null, 849)));
};

var router_3b94beb0 = function _3b94beb0() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/gczjgl/zujia */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(39)]).then(__webpack_require__.bind(null, 850)));
};

var router_7d403187 = function _7d403187() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/bidopening */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(40)]).then(__webpack_require__.bind(null, 851)));
};

var router_440f340e = function _440f340e() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/bigdata */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(41)]).then(__webpack_require__.bind(null, 852)));
};

var router_75f67d38 = function _75f67d38() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/databackup */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(42)]).then(__webpack_require__.bind(null, 853)));
};

var router_4f79de88 = function _4f79de88() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/evaluation */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(43)]).then(__webpack_require__.bind(null, 854)));
};

var router_5834a68b = function _5834a68b() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/filemanagement */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(44)]).then(__webpack_require__.bind(null, 855)));
};

var router_33ea9c13 = function _33ea9c13() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/jianguan */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(45)]).then(__webpack_require__.bind(null, 856)));
};

var router_6714db45 = function _6714db45() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/solution */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(46)]).then(__webpack_require__.bind(null, 857)));
};

var router_4c120f56 = function _4c120f56() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/ggzyjy/ycfspb */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(47)]).then(__webpack_require__.bind(null, 858)));
};

var router_208fef9e = function _208fef9e() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligence/blockchain */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(49)]).then(__webpack_require__.bind(null, 859)));
};

var router_011787ec = function _011787ec() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligence/certificate */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(50)]).then(__webpack_require__.bind(null, 860)));
};

var router_028d922d = function _028d922d() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligence/field */[__webpack_require__.e(1), __webpack_require__.e(51)]).then(__webpack_require__.bind(null, 861)));
};

var router_37c328bc = function _37c328bc() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligence/financial */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(52)]).then(__webpack_require__.bind(null, 862)));
};

var router_0ac7fa42 = function _0ac7fa42() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligence/materials */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(53)]).then(__webpack_require__.bind(null, 863)));
};

var router_6a40ff5a = function _6a40ff5a() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligencetbws/examination */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(54)]).then(__webpack_require__.bind(null, 864)));
};

var router_ea043e64 = function _ea043e64() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligencetbws/guard */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(3), __webpack_require__.e(55)]).then(__webpack_require__.bind(null, 865)));
};

var router_028fe9d6 = function _028fe9d6() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligencetbws/information */[__webpack_require__.e(0), __webpack_require__.e(56)]).then(__webpack_require__.bind(null, 866)));
};

var router_3d1a7db4 = function _3d1a7db4() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/products/intelligencetbws/rechecking */[__webpack_require__.e(0), __webpack_require__.e(1), __webpack_require__.e(2), __webpack_require__.e(57)]).then(__webpack_require__.bind(null, 867)));
};

var router_f4606d80 = function _f4606d80() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/case/_id */ 16).then(__webpack_require__.bind(null, 868)));
};

var router_cb2ef0e8 = function _cb2ef0e8() {
  return object(utils["m" /* interopdefault */])(__webpack_require__.e(/* import() | pages/newsdetail/_id */ 29).then(__webpack_require__.bind(null, 869)));
};

var router_303dd7f0 = function _303dd7f0() {
  return object(utils["m" /* interopdefault */])(promise.all(/* import() | pages/index */[__webpack_require__.e(71), __webpack_require__.e(26)]).then(__webpack_require__.bind(null, 827)));
};

var emptyfn = function emptyfn() {};

vue_runtime_esm["default"].use(vue_router_esm["a" /* default */]);
var routeroptions = {
  mode: 'history',
  base: '/',
  linkactiveclass: 'nuxt-link-active',
  linkexactactiveclass: 'nuxt-link-exact-active',
  scrollbehavior: router_scrollbehavior,
  routes: [{
    path: "/aboutus",
    component: router_48c46bbe,
    name: "aboutus"
  }, {
    path: "/case",
    component: router_fe291e50,
    name: "case"
  }, {
    path: "/contactus",
    component: router_fbe87e18,
    name: "contactus"
  }, {
    path: "/dacaigou",
    component: router_5fae23ee,
    name: "dacaigou"
  }, {
    path: "/datacenter",
    component: router_0ff890b9,
    name: "datacenter"
  }, {
    path: "/download",
    component: router_3aec38c2,
    name: "download"
  }, {
    path: "/joinus",
    component: router_7eda5a02,
    name: "joinus"
  }, {
    path: "/news",
    component: router_0a934d55,
    name: "news"
  }, {
    path: "/partners",
    component: router_03836365,
    name: "partners"
  }, {
    path: "/products",
    component: router_367f3324,
    name: "products"
  }, {
    path: "/required",
    component: router_d0858f4e,
    name: "required"
  }, {
    path: "/serve",
    component: router_710575c6,
    name: "serve"
  }, {
    path: "/sitemap",
    component: router_573e022a,
    name: "sitemap"
  }, {
    path: "/study",
    component: router_b910b502,
    name: "study"
  }, {
    path: "/error/404",
    component: router_124f7c6a,
    name: "error-404"
  }, {
    path: "/error/500",
    component: router_46fd59a7,
    name: "error-500"
  }, {
    path: "/dacaigou/components/header",
    component: router_bc33da08,
    name: "dacaigou-components-header"
  }, {
    path: "/dacaigou/components/submitdialog",
    component: router_6a254da2,
    name: "dacaigou-components-submitdialog"
  }, {
    path: "/products/bidding/bigdata",
    component: router_cca1dba6,
    name: "products-bidding-bigdata"
  }, {
    path: "/products/bidding/cost",
    component: router_533fdbda,
    name: "products-bidding-cost"
  }, {
    path: "/products/bidding/dzztb",
    component: router_d696a756,
    name: "products-bidding-dzztb"
  }, {
    path: "/products/bidding/saas",
    component: router_6413cce6,
    name: "products-bidding-saas"
  }, {
    path: "/products/bidding/supplier",
    component: router_4289e84e,
    name: "products-bidding-supplier"
  }, {
    path: "/products/biddingassist/bst",
    component: router_1462643d,
    name: "products-biddingassist-bst"
  }, {
    path: "/products/gczjgl/projectcost",
    component: router_16c7eee7,
    name: "products-gczjgl-projectcost"
  }, {
    path: "/products/gczjgl/qingbiao",
    component: router_1c07bf55,
    name: "products-gczjgl-qingbiao"
  }, {
    path: "/products/gczjgl/zujia",
    component: router_3b94beb0,
    name: "products-gczjgl-zujia"
  }, {
    path: "/products/ggzyjy/bidopening",
    component: router_7d403187,
    name: "products-ggzyjy-bidopening"
  }, {
    path: "/products/ggzyjy/bigdata",
    component: router_440f340e,
    name: "products-ggzyjy-bigdata"
  }, {
    path: "/products/ggzyjy/databackup",
    component: router_75f67d38,
    name: "products-ggzyjy-databackup"
  }, {
    path: "/products/ggzyjy/evaluation",
    component: router_4f79de88,
    name: "products-ggzyjy-evaluation"
  }, {
    path: "/products/ggzyjy/filemanagement",
    component: router_5834a68b,
    name: "products-ggzyjy-filemanagement"
  }, {
    path: "/products/ggzyjy/jianguan",
    component: router_33ea9c13,
    name: "products-ggzyjy-jianguan"
  }, {
    path: "/products/ggzyjy/solution",
    component: router_6714db45,
    name: "products-ggzyjy-solution"
  }, {
    path: "/products/ggzyjy/ycfspb",
    component: router_4c120f56,
    name: "products-ggzyjy-ycfspb"
  }, {
    path: "/products/intelligence/blockchain",
    component: router_208fef9e,
    name: "products-intelligence-blockchain"
  }, {
    path: "/products/intelligence/certificate",
    component: router_011787ec,
    name: "products-intelligence-certificate"
  }, {
    path: "/products/intelligence/field",
    component: router_028d922d,
    name: "products-intelligence-field"
  }, {
    path: "/products/intelligence/financial",
    component: router_37c328bc,
    name: "products-intelligence-financial"
  }, {
    path: "/products/intelligence/materials",
    component: router_0ac7fa42,
    name: "products-intelligence-materials"
  }, {
    path: "/products/intelligencetbws/examination",
    component: router_6a40ff5a,
    name: "products-intelligencetbws-examination"
  }, {
    path: "/products/intelligencetbws/guard",
    component: router_ea043e64,
    name: "products-intelligencetbws-guard"
  }, {
    path: "/products/intelligencetbws/information",
    component: router_028fe9d6,
    name: "products-intelligencetbws-information"
  }, {
    path: "/products/intelligencetbws/rechecking",
    component: router_3d1a7db4,
    name: "products-intelligencetbws-rechecking"
  }, {
    path: "/case/:id",
    component: router_f4606d80,
    name: "case-id"
  }, {
    path: "/newsdetail/:id?",
    component: router_cb2ef0e8,
    name: "newsdetail-id"
  }, {
    path: "/",
    component: router_303dd7f0,
    name: "index"
  }],
  fallback: false
};
function createrouter(ssrcontext, config) {
  var base = config._app && config._app.basepath || routeroptions.base;
  var router = new vue_router_esm["a" /* default */](_objectspread(_objectspread({}, routeroptions), {}, {
    base: base
  })); // todo: remove in nuxt 3

  var originalpush = router.push;

  router.push = function push(location) {
    var oncomplete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : emptyfn;
    var onabort = arguments.length > 2 ? arguments[2] : undefined;
    return originalpush.call(this, location, oncomplete, onabort);
  };

  var resolve = router.resolve.bind(router);

  router.resolve = function (to, current, append) {
    if (typeof to === 'string') {
      to = object(dist["c" /* normalizeurl */])(to);
    }

    return resolve(to, current, append);
  };

  return router;
}
// concatenated module: ./nuxt/components/nuxt-child.js
/* harmony default export */ var nuxt_child = ({
  name: 'nuxtchild',
  functional: true,
  props: {
    nuxtchildkey: {
      type: string,
      default: ''
    },
    keepalive: boolean,
    keepaliveprops: {
      type: object,
      default: undefined
    }
  },
  render: function render(_, _ref) {
    var parent = _ref.parent,
        data = _ref.data,
        props = _ref.props;
    var h = parent.$createelement;
    data.nuxtchild = true;
    var _parent = parent;
    var transitions = parent.$nuxt.nuxt.transitions;
    var defaulttransition = parent.$nuxt.nuxt.defaulttransition;
    var depth = 0;

    while (parent) {
      if (parent.$vnode && parent.$vnode.data.nuxtchild) {
        depth++;
      }

      parent = parent.$parent;
    }

    data.nuxtchilddepth = depth;
    var transition = transitions[depth] || defaulttransition;
    var transitionprops = {};
    transitionskeys.foreach(function (key) {
      if (typeof transition[key] !== 'undefined') {
        transitionprops[key] = transition[key];
      }
    });
    var listeners = {};
    listenerskeys.foreach(function (key) {
      if (typeof transition[key] === 'function') {
        listeners[key] = transition[key].bind(_parent);
      }
    });

    if (true) {
      // add triggerscroll event on beforeenter (fix #1376)
      var beforeenter = listeners.beforeenter;

      listeners.beforeenter = function (el) {
        // ensure to trigger scroll event after calling scrollbehavior
        window.$nuxt.$nexttick(function () {
          window.$nuxt.$emit('triggerscroll');
        });

        if (beforeenter) {
          return beforeenter.call(_parent, el);
        }
      };
    } // make sure that leave is called asynchronous (fix #5703)


    if (transition.css === false) {
      var leave = listeners.leave; // only add leave listener when user didnt provide one
      // or when it misses the done argument

      if (!leave || leave.length < 2) {
        listeners.leave = function (el, done) {
          if (leave) {
            leave.call(_parent, el);
          }

          _parent.$nexttick(done);
        };
      }
    }

    var routerview = h('routerview', data);

    if (props.keepalive) {
      routerview = h('keep-alive', {
        props: props.keepaliveprops
      }, [routerview]);
    }

    return h('transition', {
      props: transitionprops,
      on: listeners
    }, [routerview]);
  }
});
var transitionskeys = ['name', 'mode', 'appear', 'css', 'type', 'duration', 'enterclass', 'leaveclass', 'appearclass', 'enteractiveclass', 'enteractiveclass', 'leaveactiveclass', 'appearactiveclass', 'entertoclass', 'leavetoclass', 'appeartoclass'];
var listenerskeys = ['beforeenter', 'enter', 'afterenter', 'entercancelled', 'beforeleave', 'leave', 'afterleave', 'leavecancelled', 'beforeappear', 'appear', 'afterappear', 'appearcancelled'];
// concatenated module: ./node_modules/vue-loader/lib/loaders/templateloader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./nuxt/components/nuxt-error.vue?vue&type=template&id=53b1a99a&
var nuxt_errorvue_type_template_id_53b1a99a_render = function () {var _vm=this;var _h=_vm.$createelement;var _c=_vm._self._c||_h;return _c('div',{staticclass:"__nuxt-error-page"},[_c('div',{staticclass:"error"},[_c('svg',{attrs:{"xmlns":"http://www.w3.org/2000/svg","width":"90","height":"90","fill":"#dbe1ec","viewbox":"0 0 48 48"}},[_c('path',{attrs:{"d":"m22 30h4v4h-4zm0-16h4v12h-4zm1.99-10c12.94 4 4 12.95 4 24s8.94 20 19.99 20s44 35.05 44 24 35.04 4 23.99 4zm24 40c-8.84 0-16-7.16-16-16s15.16 8 24 8s16 7.16 16 16-7.16 16-16 16z"}})]),_vm._v(" "),_c('div',{staticclass:"title"},[_vm._v(_vm._s(_vm.message))]),_vm._v(" "),(_vm.statuscode === 404)?_c('p',{staticclass:"description"},[(typeof _vm.$route === 'undefined')?_c('a',{staticclass:"error-link",attrs:{"href":"/"}}):_c('nuxtlink',{staticclass:"error-link",attrs:{"to":"/"}},[_vm._v("back to the home page")])],1):_vm._e(),_vm._v(" "),_vm._m(0)])])}
var staticrenderfns = [function () {var _vm=this;var _h=_vm.$createelement;var _c=_vm._self._c||_h;return _c('div',{staticclass:"logo"},[_c('a',{attrs:{"href":"https://nuxtjs.org","target":"_blank","rel":"noopener"}},[_vm._v("nuxt")])])}]


// concatenated module: ./nuxt/components/nuxt-error.vue?vue&type=template&id=53b1a99a&

// concatenated module: ./node_modules/babel-loader/lib??ref--2-0!./node_modules/vue-loader/lib??vue-loader-options!./nuxt/components/nuxt-error.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
/* harmony default export */ var nuxt_errorvue_type_script_lang_js_ = ({
  name: 'nuxterror',
  props: {
    error: {
      type: object,
      default: null
    }
  },
  computed: {
    statuscode: function statuscode() {
      return this.error && this.error.statuscode || 500;
    },
    message: function message() {
      return this.error.message || 'error';
    }
  },
  head: function head() {
    return {
      title: this.message,
      meta: [{
        name: 'viewport',
        content: 'width=device-width,initial-scale=1.0,minimum-scale=1.0'
      }]
    };
  }
});
// concatenated module: ./nuxt/components/nuxt-error.vue?vue&type=script&lang=js&
 /* harmony default export */ var components_nuxt_errorvue_type_script_lang_js_ = (nuxt_errorvue_type_script_lang_js_); 
// external module: ./nuxt/components/nuxt-error.vue?vue&type=style&index=0&lang=css&
var nuxt_errorvue_type_style_index_0_lang_css_ = __webpack_require__(240);

// external module: ./node_modules/vue-loader/lib/runtime/componentnormalizer.js
var componentnormalizer = __webpack_require__(17);

// concatenated module: ./nuxt/components/nuxt-error.vue






/* normalize component */

var nuxt_error_component = object(componentnormalizer["a" /* default */])(
  components_nuxt_errorvue_type_script_lang_js_,
  nuxt_errorvue_type_template_id_53b1a99a_render,
  staticrenderfns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var nuxt_error = (nuxt_error_component.exports);
// external module: ./node_modules/@babel/runtime/helpers/esm/slicedtoarray.js + 1 modules
var slicedtoarray = __webpack_require__(22);

// external module: ./node_modules/core-js/modules/es6.date.to-string.js
var es6_date_to_string = __webpack_require__(80);

// external module: ./node_modules/core-js/modules/es6.regexp.to-string.js
var es6_regexp_to_string = __webpack_require__(81);

// concatenated module: ./nuxt/components/nuxt.js









/* harmony default export */ var components_nuxt = ({
  name: 'nuxt',
  components: {
    nuxtchild: nuxt_child,
    nuxterror: nuxt_error
  },
  props: {
    nuxtchildkey: {
      type: string,
      default: undefined
    },
    keepalive: boolean,
    keepaliveprops: {
      type: object,
      default: undefined
    },
    name: {
      type: string,
      default: 'default'
    }
  },
  errorcaptured: function errorcaptured(error) {
    // if we receive and error while showing the nuxterror component
    // capture the error and force an immediate update so we re-render
    // without the nuxterror component
    if (this.displayingnuxterror) {
      this.errorfromnuxterror = error;
      this.$forceupdate();
    }
  },
  computed: {
    routerviewkey: function routerviewkey() {
      // if nuxtchildkey prop is given or current route has children
      if (typeof this.nuxtchildkey !== 'undefined' || this.$route.matched.length > 1) {
        return this.nuxtchildkey || object(utils["c" /* compile */])(this.$route.matched[0].path)(this.$route.params);
      }

      var _this$$route$matched = object(slicedtoarray["a" /* default */])(this.$route.matched, 1),
          matchedroute = _this$$route$matched[0];

      if (!matchedroute) {
        return this.$route.path;
      }

      var component = matchedroute.components.default;

      if (component && component.options) {
        var options = component.options;

        if (options.key) {
          return typeof options.key === 'function' ? options.key(this.$route) : options.key;
        }
      }

      var strict = /\/$/.test(matchedroute.path);
      return strict ? this.$route.path : this.$route.path.replace(/\/$/, '');
    }
  },
  beforecreate: function beforecreate() {
    vue_runtime_esm["default"].util.definereactive(this, 'nuxt', this.$root.$options.nuxt);
  },
  render: function render(h) {
    var _this = this;

    // if there is no error
    if (!this.nuxt.err) {
      // directly return nuxt child
      return h('nuxtchild', {
        key: this.routerviewkey,
        props: this.$props
      });
    } // if an error occurred within nuxterror show a simple
    // error message instead to prevent looping


    if (this.errorfromnuxterror) {
      this.$nexttick(function () {
        return _this.errorfromnuxterror = false;
      });
      return h('div', {}, [h('h2', 'an error occurred while showing the error page'), h('p', 'unfortunately an error occurred and while showing the error page another error occurred'), h('p', "error details: ".concat(this.errorfromnuxterror.tostring())), h('nuxt-link', {
        props: {
          to: '/'
        }
      }, 'go back to home')]);
    } // track if we are showing the nuxterror component


    this.displayingnuxterror = true;
    this.$nexttick(function () {
      return _this.displayingnuxterror = false;
    });
    return h(nuxt_error, {
      props: {
        error: this.nuxt.err
      }
    });
  }
});
// external module: ./node_modules/core-js/modules/es6.array.slice.js
var es6_array_slice = __webpack_require__(49);

// external module: ./node_modules/core-js/modules/es6.array.from.js
var es6_array_from = __webpack_require__(47);

// external module: ./node_modules/core-js/modules/es6.string.iterator.js
var es6_string_iterator = __webpack_require__(45);

// external module: ./node_modules/core-js/modules/web.dom.iterable.js
var web_dom_iterable = __webpack_require__(46);

// concatenated module: ./node_modules/babel-loader/lib??ref--2-0!./node_modules/vue-loader/lib??vue-loader-options!./nuxt/components/nuxt-loading.vue?vue&type=script&lang=js&
/* harmony default export */ var nuxt_loadingvue_type_script_lang_js_ = ({
  name: 'nuxtloading',
  data: function data() {
    return {
      percent: 0,
      show: false,
      cansucceed: true,
      reversed: false,
      skiptimercount: 0,
      rtl: false,
      throttle: 200,
      duration: 5000,
      continuous: false
    };
  },
  computed: {
    left: function left() {
      if (!this.continuous && !this.rtl) {
        return false;
      }

      return this.rtl ? this.reversed ? '0px' : 'auto' : !this.reversed ? '0px' : 'auto';
    }
  },
  beforedestroy: function beforedestroy() {
    this.clear();
  },
  methods: {
    clear: function clear() {
      clearinterval(this._timer);
      cleartimeout(this._throttle);
      this._timer = null;
    },
    start: function start() {
      var _this = this;

      this.clear();
      this.percent = 0;
      this.reversed = false;
      this.skiptimercount = 0;
      this.cansucceed = true;

      if (this.throttle) {
        this._throttle = settimeout(function () {
          return _this.starttimer();
        }, this.throttle);
      } else {
        this.starttimer();
      }

      return this;
    },
    set: function set(num) {
      this.show = true;
      this.cansucceed = true;
      this.percent = math.min(100, math.max(0, math.floor(num)));
      return this;
    },
    get: function get() {
      return this.percent;
    },
    increase: function increase(num) {
      this.percent = math.min(100, math.floor(this.percent + num));
      return this;
    },
    decrease: function decrease(num) {
      this.percent = math.max(0, math.floor(this.percent - num));
      return this;
    },
    pause: function pause() {
      clearinterval(this._timer);
      return this;
    },
    resume: function resume() {
      this.starttimer();
      return this;
    },
    finish: function finish() {
      this.percent = this.reversed ? 0 : 100;
      this.hide();
      return this;
    },
    hide: function hide() {
      var _this2 = this;

      this.clear();
      settimeout(function () {
        _this2.show = false;

        _this2.$nexttick(function () {
          _this2.percent = 0;
          _this2.reversed = false;
        });
      }, 500);
      return this;
    },
    fail: function fail(error) {
      this.cansucceed = false;
      return this;
    },
    starttimer: function starttimer() {
      var _this3 = this;

      if (!this.show) {
        this.show = true;
      }

      if (typeof this._cut === 'undefined') {
        this._cut = 10000 / math.floor(this.duration);
      }

      this._timer = setinterval(function () {
        /**
         * when reversing direction skip one timers
         * so 0, 100 are displayed for two iterations
         * also disable css width transitioning
         * which otherwise interferes and shows
         * a jojo effect
         */
        if (_this3.skiptimercount > 0) {
          _this3.skiptimercount--;
          return;
        }

        if (_this3.reversed) {
          _this3.decrease(_this3._cut);
        } else {
          _this3.increase(_this3._cut);
        }

        if (_this3.continuous) {
          if (_this3.percent >= 100) {
            _this3.skiptimercount = 1;
            _this3.reversed = !_this3.reversed;
          } else if (_this3.percent <= 0) {
            _this3.skiptimercount = 1;
            _this3.reversed = !_this3.reversed;
          }
        }
      }, 100);
    }
  },
  render: function render(h) {
    var el = h(false);

    if (this.show) {
      el = h('div', {
        staticclass: 'nuxt-progress',
        class: {
          'nuxt-progress-notransition': this.skiptimercount > 0,
          'nuxt-progress-failed': !this.cansucceed
        },
        style: {
          width: this.percent + '%',
          left: this.left
        }
      });
    }

    return el;
  }
});
// concatenated module: ./nuxt/components/nuxt-loading.vue?vue&type=script&lang=js&
 /* harmony default export */ var components_nuxt_loadingvue_type_script_lang_js_ = (nuxt_loadingvue_type_script_lang_js_); 
// external module: ./nuxt/components/nuxt-loading.vue?vue&type=style&index=0&lang=css&
var nuxt_loadingvue_type_style_index_0_lang_css_ = __webpack_require__(241);

// concatenated module: ./nuxt/components/nuxt-loading.vue
var nuxt_loading_render, nuxt_loading_staticrenderfns





/* normalize component */

var nuxt_loading_component = object(componentnormalizer["a" /* default */])(
  components_nuxt_loadingvue_type_script_lang_js_,
  nuxt_loading_render,
  nuxt_loading_staticrenderfns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var nuxt_loading = (nuxt_loading_component.exports);
// external module: ./static/css/common.css
var common = __webpack_require__(242);

// external module: ./static/css/main.css
var main = __webpack_require__(243);

// external module: ./static/css/animate.css
var animate = __webpack_require__(244);

// external module: ./static/css/loading.css
var loading = __webpack_require__(245);

// external module: ./static/css/font_1930963_3rhi2vyu33q.css
var font_1930963_3rhi2vyu33q = __webpack_require__(246);

// external module: ./layouts/default.vue + 19 modules
var layouts_default = __webpack_require__(199);

// concatenated module: ./nuxt/app.js






function _createforofiteratorhelper(o, allowarraylike) { var it = typeof symbol !== "undefined" && o[symbol.iterator] || o["@@iterator"]; if (!it) { if (array.isarray(o) || (it = _unsupportediterabletoarray(o)) || allowarraylike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var f = function f() {}; return { s: f, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: f }; } throw new typeerror("invalid attempt to iterate non-iterable instance.\nin order to be iterable, non-array objects must have a [symbol.iterator]() method."); } var normalcompletion = true, diderr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalcompletion = step.done; return step; }, e: function e(_e2) { diderr = true; err = _e2; }, f: function f() { try { if (!normalcompletion && it.return != null) it.return(); } finally { if (diderr) throw err; } } }; }

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; }

















var layouts = {
  "_default": object(utils["s" /* sanitizecomponent */])(layouts_default["a" /* default */])
};
/* harmony default export */ var app = ({
  render: function render(h, props) {
    var loadingel = h('nuxtloading', {
      ref: 'loading'
    });
    var layoutel = h(this.layout || 'nuxt');
    var templateel = h('div', {
      domprops: {
        id: '__layout'
      },
      key: this.layoutname
    }, [layoutel]);
    var transitionel = h('transition', {
      props: {
        name: 'layout',
        mode: 'out-in'
      },
      on: {
        beforeenter: function beforeenter(el) {
          // ensure to trigger scroll event after calling scrollbehavior
          window.$nuxt.$nexttick(function () {
            window.$nuxt.$emit('triggerscroll');
          });
        }
      }
    }, [templateel]);
    return h('div', {
      domprops: {
        id: '__nuxt'
      }
    }, [loadingel, transitionel]);
  },
  data: function data() {
    return {
      isonline: true,
      layout: null,
      layoutname: '',
      nbfetching: 0
    };
  },
  beforecreate: function beforecreate() {
    vue_runtime_esm["default"].util.definereactive(this, 'nuxt', this.$options.nuxt);
  },
  created: function created() {
    // add this.$nuxt in child instances
    this.$root.$options.$nuxt = this;

    if (true) {
      // add to window so we can listen when ready
      window.$nuxt = this;
      this.refreshonlinestatus(); // setup the listeners

      window.addeventlistener('online', this.refreshonlinestatus);
      window.addeventlistener('offline', this.refreshonlinestatus);
    } // add $nuxt.error()


    this.error = this.nuxt.error; // add $nuxt.context

    this.context = this.$options.context;
  },
  mounted: function mounted() {
    var _this = this;

    return object(asynctogenerator["a" /* default */])( /*#__pure__*/regeneratorruntime.mark(function _callee() {
      return regeneratorruntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _this.$loading = _this.$refs.loading;

            case 1:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }))();
  },
  watch: {
    'nuxt.err': 'errorchanged'
  },
  computed: {
    isoffline: function isoffline() {
      return !this.isonline;
    },
    isfetching: function isfetching() {
      return this.nbfetching > 0;
    }
  },
  methods: {
    refreshonlinestatus: function refreshonlinestatus() {
      if (true) {
        if (typeof window.navigator.online === 'undefined') {
          // if the browser doesn't support connection status reports
          // assume that we are online because most apps' only react
          // when they now that the connection has been interrupted
          this.isonline = true;
        } else {
          this.isonline = window.navigator.online;
        }
      }
    },
    refresh: function refresh() {
      var _this2 = this;

      return object(asynctogenerator["a" /* default */])( /*#__pure__*/regeneratorruntime.mark(function _callee2() {
        var pages, promises;
        return regeneratorruntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                pages = object(utils["h" /* getmatchedcomponentsinstances */])(_this2.$route);

                if (pages.length) {
                  _context2.next = 3;
                  break;
                }

                return _context2.abrupt("return");

              case 3:
                _this2.$loading.start();

                promises = pages.map(function (page) {
                  var p = []; // old fetch

                  if (page.$options.fetch && page.$options.fetch.length) {
                    p.push(object(utils["q" /* promisify */])(page.$options.fetch, _this2.context));
                  }

                  if (page.$fetch) {
                    p.push(page.$fetch());
                  } else {
                    // get all component instance to call $fetch
                    var _iterator = _createforofiteratorhelper(object(utils["e" /* getchildrencomponentinstancesusingfetch */])(page.$vnode.componentinstance)),
                        _step;

                    try {
                      for (_iterator.s(); !(_step = _iterator.n()).done;) {
                        var component = _step.value;
                        p.push(component.$fetch());
                      }
                    } catch (err) {
                      _iterator.e(err);
                    } finally {
                      _iterator.f();
                    }
                  }

                  if (page.$options.asyncdata) {
                    p.push(object(utils["q" /* promisify */])(page.$options.asyncdata, _this2.context).then(function (newdata) {
                      for (var key in newdata) {
                        vue_runtime_esm["default"].set(page.$data, key, newdata[key]);
                      }
                    }));
                  }

                  return promise.all(p);
                });
                _context2.prev = 5;
                _context2.next = 8;
                return promise.all(promises);

              case 8:
                _context2.next = 15;
                break;

              case 10:
                _context2.prev = 10;
                _context2.t0 = _context2["catch"](5);

                _this2.$loading.fail(_context2.t0);

                object(utils["k" /* globalhandleerror */])(_context2.t0);

                _this2.error(_context2.t0);

              case 15:
                _this2.$loading.finish();

              case 16:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, null, [[5, 10]]);
      }))();
    },
    errorchanged: function errorchanged() {
      if (this.nuxt.err) {
        if (this.$loading) {
          if (this.$loading.fail) {
            this.$loading.fail(this.nuxt.err);
          }

          if (this.$loading.finish) {
            this.$loading.finish();
          }
        }

        var errorlayout = (nuxt_error.options || nuxt_error).layout;

        if (typeof errorlayout === 'function') {
          errorlayout = errorlayout(this.context);
        }

        this.setlayout(errorlayout);
      }
    },
    setlayout: function setlayout(layout) {
      if (!layout || !layouts['_' + layout]) {
        layout = 'default';
      }

      this.layoutname = layout;
      this.layout = layouts['_' + layout];
      return this.layout;
    },
    loadlayout: function loadlayout(layout) {
      if (!layout || !layouts['_' + layout]) {
        layout = 'default';
      }

      return promise.resolve(layouts['_' + layout]);
    }
  },
  components: {
    nuxtloading: nuxt_loading
  }
});
// concatenated module: ./nuxt/store.js


vue_runtime_esm["default"].use(vuex_esm["a" /* default */]);
var store_store = {};

(function updatemodules() {
  store_store = normalizeroot(__webpack_require__(255), 'store/index.js'); // if store is an exported method = classic mode (deprecated)
  // enforce store modules

  store_store.modules = store_store.modules || {}; // if the environment supports hot reloading...
})(); // createstore


var createstore = store_store instanceof function ? store_store : function () {
  return new vuex_esm["a" /* default */].store(object.assign({
    strict: "production" !== 'production'
  }, store_store));
};

function normalizeroot(moduledata, filepath) {
  moduledata = moduledata.default || moduledata;

  if (moduledata.commit) {
    throw new error("[nuxt] ".concat(filepath, " should export a method that returns a vuex instance."));
  }

  if (typeof moduledata !== 'function') {
    // avoid typeerror: setting a property that has only a getter when overwriting top level keys
    moduledata = object.assign({}, moduledata);
  }

  return normalizemodule(moduledata, filepath);
}

function normalizemodule(moduledata, filepath) {
  if (moduledata.state && typeof moduledata.state !== 'function') {
    console.warn("'state' should be a method that returns an object in ".concat(filepath));

    var _state = object.assign({}, moduledata.state); // avoid typeerror: setting a property that has only a getter when overwriting top level keys


    moduledata = object.assign({}, moduledata, {
      state: function state() {
        return _state;
      }
    });
  }

  return moduledata;
}
// external module: ./node_modules/axios/index.js
var node_modules_axios = __webpack_require__(63);
var axios_default = /*#__pure__*/__webpack_require__.n(node_modules_axios);

// external module: ./node_modules/defu/dist/defu.mjs
var defu = __webpack_require__(184);

// external module: ./node_modules/axios-retry/lib/esm/index.js
var esm = __webpack_require__(185);

// concatenated module: ./nuxt/axios.js












function axios_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 axios_objectspread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? axios_ownkeys(object(source), !0).foreach(function (key) { object(defineproperty["a" /* default */])(target, key, source[key]); }) : object.getownpropertydescriptors ? object.defineproperties(target, object.getownpropertydescriptors(source)) : axios_ownkeys(object(source)).foreach(function (key) { object.defineproperty(target, key, object.getownpropertydescriptor(source, key)); }); } return target; }



function axios_createforofiteratorhelper(o, allowarraylike) { var it = typeof symbol !== "undefined" && o[symbol.iterator] || o["@@iterator"]; if (!it) { if (array.isarray(o) || (it = axios_unsupportediterabletoarray(o)) || allowarraylike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var f = function f() {}; return { s: f, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: f }; } throw new typeerror("invalid attempt to iterate non-iterable instance.\nin order to be iterable, non-array objects must have a [symbol.iterator]() method."); } var normalcompletion = true, diderr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalcompletion = step.done; return step; }, e: function e(_e2) { diderr = true; err = _e2; }, f: function f() { try { if (!normalcompletion && it.return != null) it.return(); } finally { if (diderr) throw err; } } }; }

function axios_unsupportediterabletoarray(o, minlen) { if (!o) return; if (typeof o === "string") return axios_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 axios_arrayliketoarray(o, minlen); }

function axios_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; }



 // axios.prototype cannot be modified

var axiosextra = {
  setbaseurl: function setbaseurl(baseurl) {
    this.defaults.baseurl = baseurl;
  },
  setheader: function setheader(name, value) {
    var scopes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'common';

    var _iterator = axios_createforofiteratorhelper(array.isarray(scopes) ? scopes : [scopes]),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var scope = _step.value;

        if (!value) {
          delete this.defaults.headers[scope][name];
          continue;
        }

        this.defaults.headers[scope][name] = value;
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  },
  settoken: function settoken(token, type) {
    var scopes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'common';
    var value = !token ? null : (type ? type + ' ' : '') + token;
    this.setheader('authorization', value, scopes);
  },
  onrequest: function onrequest(fn) {
    this.interceptors.request.use(function (config) {
      return fn(config) || config;
    });
  },
  onresponse: function onresponse(fn) {
    this.interceptors.response.use(function (response) {
      return fn(response) || response;
    });
  },
  onrequesterror: function onrequesterror(fn) {
    this.interceptors.request.use(undefined, function (error) {
      return fn(error) || promise.reject(error);
    });
  },
  onresponseerror: function onresponseerror(fn) {
    this.interceptors.response.use(undefined, function (error) {
      return fn(error) || promise.reject(error);
    });
  },
  onerror: function onerror(fn) {
    this.onrequesterror(fn);
    this.onresponseerror(fn);
  },
  create: function create(options) {
    return axios_createaxiosinstance(object(defu["a" /* default */])(options, this.defaults));
  }
}; // request helpers ($get, $post, ...)

var _loop = function _loop() {
  var method = _arr[_i];

  axiosextra['$' + method] = function () {
    return this[method].apply(this, arguments).then(function (res) {
      return res && res.data;
    });
  };
};

for (var _i = 0, _arr = ['request', 'delete', 'get', 'head', 'options', 'post', 'put', 'patch']; _i < _arr.length; _i++) {
  _loop();
}

var extendaxiosinstance = function extendaxiosinstance(axios) {
  for (var key in axiosextra) {
    axios[key] = axiosextra[key].bind(axios);
  }
};

var axios_createaxiosinstance = function createaxiosinstance(axiosoptions) {
  // create new axios instance
  var axios = axios_default.a.create(axiosoptions);
  axios.canceltoken = axios_default.a.canceltoken;
  axios.iscancel = axios_default.a.iscancel; // extend axios proto

  extendaxiosinstance(axios); // intercept to apply default headers

  axios.onrequest(function (config) {
    config.headers = axios_objectspread(axios_objectspread({}, axios.defaults.headers.common), config.headers);
  }); // setup interceptors

  axios_setupprogress(axios);
  object(esm["a" /* default */])(axios, {
    "retries": 6
  });
  return axios;
};

var axios_setupprogress = function setupprogress(axios) {
  if (false) {} // a noop loading inteterface for when $nuxt is not yet ready


  var nooploading = {
    finish: function finish() {},
    start: function start() {},
    fail: function fail() {},
    set: function set() {}
  };

  var $loading = function $loading() {
    var $nuxt = typeof window !== 'undefined' && window['$nuxt'];
    return $nuxt && $nuxt.$loading && $nuxt.$loading.set ? $nuxt.$loading : nooploading;
  };

  var currentrequests = 0;
  axios.onrequest(function (config) {
    if (config && config.progress === false) {
      return;
    }

    currentrequests++;
  });
  axios.onresponse(function (response) {
    if (response && response.config && response.config.progress === false) {
      return;
    }

    currentrequests--;

    if (currentrequests <= 0) {
      currentrequests = 0;
      $loading().finish();
    }
  });
  axios.onerror(function (error) {
    if (error && error.config && error.config.progress === false) {
      return;
    }

    currentrequests--;

    if (axios_default.a.iscancel(error)) {
      if (currentrequests <= 0) {
        currentrequests = 0;
        $loading().finish();
      }

      return;
    }

    $loading().fail();
    $loading().finish();
  });

  var onprogress = function onprogress(e) {
    if (!currentrequests || !e.total) {
      return;
    }

    var progress = e.loaded * 100 / (e.total * currentrequests);
    $loading().set(math.min(100, progress));
  };

  axios.defaults.onuploadprogress = onprogress;
  axios.defaults.ondownloadprogress = onprogress;
};

/* harmony default export */ var nuxt_axios = (function (ctx, inject) {
  // runtimeconfig
  var runtimeconfig = ctx.$config && ctx.$config.axios || {}; // baseurl

  var baseurl =  true ? runtimeconfig.browserbaseurl || runtimeconfig.browserbaseurl || runtimeconfig.baseurl || runtimeconfig.baseurl || '/' : undefined; // create fresh objects for all default header scopes
  // axios creates only one which is shared across ssr requests!
  // https://github.com/mzabriskie/axios/blob/master/lib/defaults.js

  var headers = {
    "common": {
      "accept": "application/json, text/plain, */*"
    },
    "delete": {},
    "get": {},
    "head": {},
    "post": {},
    "put": {},
    "patch": {}
  };
  var axiosoptions = {
    baseurl: baseurl,
    headers: headers
  }; // proxy ssr request headers headers

  if (false) { var h, _i2, _arr2, reqheaders; }

  if (false) {}

  var axios = axios_createaxiosinstance(axiosoptions); // inject axios to the context as $axios

  ctx.$axios = axios;
  inject('axios', axios);
});
// external module: ./plugins/main.js + 1 modules
var plugins_main = __webpack_require__(129);

// external module: ./plugins/elementui.js
var elementui = __webpack_require__(123);

// external module: ./plugins/axios.js + 1 modules
var plugins_axios = __webpack_require__(130);

// external module: ./router/index.js + 1 modules
var router_0 = __webpack_require__(131);

// external module: ./util/util.js
var util = __webpack_require__(125);

// external module: ./plugins/bus-inject.js
var bus_inject = __webpack_require__(126);

// external module: ./plugins/no-ssr-import.js
var no_ssr_import = __webpack_require__(127);

// external module: ./plugins/filters.js
var filters = __webpack_require__(128);

// concatenated module: ./nuxt/index.js









function nuxt_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 nuxt_objectspread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? nuxt_ownkeys(object(source), !0).foreach(function (key) { object(defineproperty["a" /* default */])(target, key, source[key]); }) : object.getownpropertydescriptors ? object.defineproperties(target, object.getownpropertydescriptors(source)) : nuxt_ownkeys(object(source)).foreach(function (key) { object.defineproperty(target, key, object.getownpropertydescriptor(source, key)); }); } return target; }

















/* plugins */

 // source: .\\axios.js (mode: 'all')

 // source: ..\\plugins\\main.js (mode: 'all')

 // source: ..\\plugins\\elementui (mode: 'all')

 // source: ..\\plugins\\axios.js (mode: 'all')

 // source: ..\\router\\index.js (mode: 'all')

 // source: ..\\util\\util.js (mode: 'all')

 // source: ..\\plugins\\bus-inject.js (mode: 'client')

 // source: ..\\plugins\\no-ssr-import (mode: 'client')

 // source: ..\\plugins\\filters.js (mode: 'all')
// component: <clientonly>

vue_runtime_esm["default"].component(vue_client_only_common_default.a.name, vue_client_only_common_default.a); // todo: remove in nuxt 3: <nossr>

vue_runtime_esm["default"].component(vue_no_ssr_common_default.a.name, nuxt_objectspread(nuxt_objectspread({}, vue_no_ssr_common_default.a), {}, {
  render: function render(h, ctx) {
    if ( true && !vue_no_ssr_common_default.a._warned) {
      vue_no_ssr_common_default.a._warned = true;
      console.warn('<no-ssr> has been deprecated and will be removed in nuxt 3, please use <client-only> instead');
    }

    return vue_no_ssr_common_default.a.render(h, ctx);
  }
})); // component: <nuxtchild>

vue_runtime_esm["default"].component(nuxt_child.name, nuxt_child);
vue_runtime_esm["default"].component('nchild', nuxt_child); // component nuxtlink is imported in server.js or client.js
// component: <nuxt>

vue_runtime_esm["default"].component(components_nuxt.name, components_nuxt);
object.defineproperty(vue_runtime_esm["default"].prototype, '$nuxt', {
  get: function get() {
    var globalnuxt = this.$root.$options.$nuxt;

    if ( true && !globalnuxt && typeof window !== 'undefined') {
      return window.$nuxt;
    }

    return globalnuxt;
  },
  configurable: true
});
vue_runtime_esm["default"].use(vue_meta_esm_browser["a" /* default */], {
  "keyname": "head",
  "attribute": "data-n-head",
  "ssrattribute": "data-n-head-ssr",
  "tagidkeyname": "hid"
});
var defaulttransition = {
  "name": "page",
  "mode": "out-in",
  "appear": false,
  "appearclass": "appear",
  "appearactiveclass": "appear-active",
  "appeartoclass": "appear-to"
};
var originalregistermodule = vuex_esm["a" /* default */].store.prototype.registermodule;

function registermodule(path, rawmodule) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  var preservestate =  true && (array.isarray(path) ? !!path.reduce(function (namespacedstate, path) {
    return namespacedstate && namespacedstate[path];
  }, this.state) : path in this.state);
  return originalregistermodule.call(this, path, rawmodule, nuxt_objectspread({
    preservestate: preservestate
  }, options));
}

function createapp(_x) {
  return _createapp.apply(this, arguments);
}

function _createapp() {
  _createapp = object(asynctogenerator["a" /* default */])( /*#__pure__*/regeneratorruntime.mark(function _callee2(ssrcontext) {
    var config,
        router,
        store,
        app,
        next,
        route,
        path,
        inject,
        _args2 = arguments;
    return regeneratorruntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            inject = function _inject(key, value) {
              if (!key) {
                throw new error('inject(key, value) has no key provided');
              }

              if (value === undefined) {
                throw new error("inject('".concat(key, "', value) has no value provided"));
              }

              key = '$' + key; // add into app

              app[key] = value; // add into context

              if (!app.context[key]) {
                app.context[key] = value;
              } // add into store


              store[key] = app[key]; // check if plugin not already installed

              var installkey = '__nuxt_' + key + '_installed__';

              if (vue_runtime_esm["default"][installkey]) {
                return;
              }

              vue_runtime_esm["default"][installkey] = true; // call vue.use() to install the plugin into vm

              vue_runtime_esm["default"].use(function () {
                if (!object.prototype.hasownproperty.call(vue_runtime_esm["default"].prototype, key)) {
                  object.defineproperty(vue_runtime_esm["default"].prototype, key, {
                    get: function get() {
                      return this.$root.$options[key];
                    }
                  });
                }
              });
            };

            config = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
            _context2.next = 4;
            return createrouter(ssrcontext, config);

          case 4:
            router = _context2.sent;
            store = createstore(ssrcontext); // add this.$router into store actions/mutations

            store.$router = router; // fix ssr caveat https://github.com/nuxt/nuxt.js/issues/3757#issuecomment-414689141

            store.registermodule = registermodule; // create root instance
            // here we inject the router and store to all child components,
            // making them available everywhere as `this.$router` and `this.$store`.

            app = nuxt_objectspread({
              head: {
                "title": "筑龙官网",
                "meta": [{
                  "charset": "utf-8"
                }, {
                  "name": "viewport",
                  "content": "width=device-width, initial-scale=1"
                }, {
                  "name": "baidu-site-verification",
                  "content": "vpzhfjbmro"
                }, {
                  "name": "renderer",
                  "content": "webkit",
                  "data-n-head": "true"
                }, {
                  "http-equiv": "x-ua-compatible",
                  "content": "chrome=1,ie=edge"
                }, {
                  "hid": "keywords",
                  "name": "keywords",
                  "content": "筑龙官网"
                }, {
                  "hid": "description",
                  "name": "description",
                  "content": "筑龙官网"
                }],
                "link": [{
                  "rel": "icon",
                  "type": "image/x-icon",
                  "href": "/favicon.ico"
                }, {
                  "rel": "stylesheet",
                  "href": "/lib/css/basic.css"
                }, {
                  "rel": "stylesheet",
                  "href": "/lib/css/noie.css",
                  "id": "isie"
                }, {
                  "rel": "stylesheet",
                  "href": "/lib/css/noie.css",
                  "id": "isie9"
                }, {
                  "rel": "stylesheet",
                  "href": "/lib/css/noie.css",
                  "id": "isie10"
                }],
                "script": [{
                  "src": "/lib/browserinfo/browserinfo.js",
                  "type": "text/javascript"
                }, {
                  "src": "/lib/jquery/jquery.min.js",
                  "type": "text/javascript"
                }],
                "style": []
              },
              store: store,
              router: router,
              nuxt: {
                defaulttransition: defaulttransition,
                transitions: [defaulttransition],
                settransitions: function settransitions(transitions) {
                  if (!array.isarray(transitions)) {
                    transitions = [transitions];
                  }

                  transitions = transitions.map(function (transition) {
                    if (!transition) {
                      transition = defaulttransition;
                    } else if (typeof transition === 'string') {
                      transition = object.assign({}, defaulttransition, {
                        name: transition
                      });
                    } else {
                      transition = object.assign({}, defaulttransition, transition);
                    }

                    return transition;
                  });
                  this.$options.nuxt.transitions = transitions;
                  return transitions;
                },
                err: null,
                dateerr: null,
                error: function error(err) {
                  err = err || null;
                  app.context._errored = boolean(err);
                  err = err ? object(utils["p" /* normalizeerror */])(err) : null;
                  var nuxt = app.nuxt; // to work with @vue/composition-api, see https://github.com/nuxt/nuxt.js/issues/6517#issuecomment-573280207

                  if (this) {
                    nuxt = this.nuxt || this.$options.nuxt;
                  }

                  nuxt.dateerr = date.now();
                  nuxt.err = err; // used in src/server.js

                  if (ssrcontext) {
                    ssrcontext.nuxt.error = err;
                  }

                  return err;
                }
              }
            }, app); // make app available into store via this.app

            store.app = app;
            next = ssrcontext ? ssrcontext.next : function (location) {
              return app.router.push(location);
            }; // resolve route

            if (ssrcontext) {
              route = router.resolve(ssrcontext.url).route;
            } else {
              path = object(utils["f" /* getlocation */])(router.options.base, router.options.mode);
              route = router.resolve(path).route;
            } // set context to app.context


            _context2.next = 14;
            return object(utils["t" /* setcontext */])(app, {
              store: store,
              route: route,
              next: next,
              error: app.nuxt.error.bind(app),
              payload: ssrcontext ? ssrcontext.payload : undefined,
              req: ssrcontext ? ssrcontext.req : undefined,
              res: ssrcontext ? ssrcontext.res : undefined,
              beforerenderfns: ssrcontext ? ssrcontext.beforerenderfns : undefined,
              ssrcontext: ssrcontext
            });

          case 14:
            // inject runtime config as $config
            inject('config', config);

            if (true) {
              // replace store state before plugins execution
              if (window.__nuxt__ && window.__nuxt__.state) {
                store.replacestate(window.__nuxt__.state);
              }
            } // add enablepreview(previewdata = {}) in context for plugins


            if (false) {} // plugin execution


            if (!(typeof nuxt_axios === 'function')) {
              _context2.next = 20;
              break;
            }

            _context2.next = 20;
            return nuxt_axios(app.context, inject);

          case 20:
            if (!(typeof plugins_main["a" /* default */] === 'function')) {
              _context2.next = 23;
              break;
            }

            _context2.next = 23;
            return object(plugins_main["a" /* default */])(app.context, inject);

          case 23:
            if (!(typeof elementui["default"] === 'function')) {
              _context2.next = 26;
              break;
            }

            _context2.next = 26;
            return object(elementui["default"])(app.context, inject);

          case 26:
            if (!(typeof plugins_axios["a" /* default */] === 'function')) {
              _context2.next = 29;
              break;
            }

            _context2.next = 29;
            return object(plugins_axios["a" /* default */])(app.context, inject);

          case 29:
            if (!(typeof router_0["a" /* default */] === 'function')) {
              _context2.next = 32;
              break;
            }

            _context2.next = 32;
            return object(router_0["a" /* default */])(app.context, inject);

          case 32:
            if (!(typeof util["default"] === 'function')) {
              _context2.next = 35;
              break;
            }

            _context2.next = 35;
            return object(util["default"])(app.context, inject);

          case 35:
            if (!( true && typeof bus_inject["default"] === 'function')) {
              _context2.next = 38;
              break;
            }

            _context2.next = 38;
            return object(bus_inject["default"])(app.context, inject);

          case 38:
            if (!( true && typeof no_ssr_import["default"] === 'function')) {
              _context2.next = 41;
              break;
            }

            _context2.next = 41;
            return object(no_ssr_import["default"])(app.context, inject);

          case 41:
            if (!(typeof filters["a" /* default */] === 'function')) {
              _context2.next = 44;
              break;
            }

            _context2.next = 44;
            return object(filters["a" /* default */])(app.context, inject);

          case 44:
            // lock enablepreview in context
            if (false) {} // wait for async component to be resolved first


            _context2.next = 47;
            return new promise(function (resolve, reject) {
              // ignore 404s rather than blindly replacing url in browser
              if (true) {
                var _router$resolve = router.resolve(app.context.route.fullpath),
                    _route = _router$resolve.route;

                if (!_route.matched.length) {
                  return resolve();
                }
              }

              router.replace(app.context.route.fullpath, resolve, function (err) {
                // https://github.com/vuejs/vue-router/blob/v3.4.3/src/util/errors.js
                if (!err._isrouter) return reject(err);
                if (err.type !== 2
                /* navigationfailuretype.redirected */
                ) return resolve(); // navigated to a different route in router guard

                // navigated to a different route in router guard
                var unregister = router.aftereach( /*#__pure__*/function () {
                  var _ref = object(asynctogenerator["a" /* default */])( /*#__pure__*/regeneratorruntime.mark(function _callee(to, from) {
                    return regeneratorruntime.wrap(function _callee$(_context) {
                      while (1) {
                        switch (_context.prev = _context.next) {
                          case 0:
                            if (false) {}

                            _context.next = 3;
                            return object(utils["j" /* getroutedata */])(to);

                          case 3:
                            app.context.route = _context.sent;
                            app.context.params = to.params || {};
                            app.context.query = to.query || {};
                            unregister();
                            resolve();

                          case 8:
                          case "end":
                            return _context.stop();
                        }
                      }
                    }, _callee);
                  }));

                  return function (_x2, _x3) {
                    return _ref.apply(this, arguments);
                  };
                }());
              });
            });

          case 47:
            return _context2.abrupt("return", {
              store: store,
              app: app,
              router: router
            });

          case 48:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _createapp.apply(this, arguments);
}



/***/ }),

/***/ 337:
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(208);


/***/ }),

/***/ 91:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_0__ = __webpack_require__(75);
/* harmony import */ var core_js_modules_es6_string_includes_js__webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_includes_js__webpack_imported_module_0__);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_1__ = __webpack_require__(76);
/* harmony import */ var core_js_modules_es7_array_includes_js__webpack_imported_module_1___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es7_array_includes_js__webpack_imported_module_1__);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_2__ = __webpack_require__(50);
/* harmony import */ var core_js_modules_es6_array_map_js__webpack_imported_module_2___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_map_js__webpack_imported_module_2__);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_3__ = __webpack_require__(31);
/* harmony import */ var core_js_modules_es6_array_filter_js__webpack_imported_module_3___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_filter_js__webpack_imported_module_3__);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_4__ = __webpack_require__(19);
/* harmony import */ var core_js_modules_es6_object_to_string_js__webpack_imported_module_4___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_object_to_string_js__webpack_imported_module_4__);
/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_5__ = __webpack_require__(49);
/* harmony import */ var core_js_modules_es6_array_slice_js__webpack_imported_module_5___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_slice_js__webpack_imported_module_5__);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_6__ = __webpack_require__(25);
/* harmony import */ var core_js_modules_es6_function_name_js__webpack_imported_module_6___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_function_name_js__webpack_imported_module_6__);
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_7__ = __webpack_require__(29);
/* harmony import */ var core_js_modules_es6_symbol_js__webpack_imported_module_7___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_symbol_js__webpack_imported_module_7__);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_8__ = __webpack_require__(47);
/* harmony import */ var core_js_modules_es6_array_from_js__webpack_imported_module_8___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_array_from_js__webpack_imported_module_8__);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_9__ = __webpack_require__(45);
/* harmony import */ var core_js_modules_es6_string_iterator_js__webpack_imported_module_9___default = /*#__pure__*/__webpack_require__.n(core_js_modules_es6_string_iterator_js__webpack_imported_module_9__);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_10__ = __webpack_require__(46);
/* harmony import */ var core_js_modules_web_dom_iterable_js__webpack_imported_module_10___default = /*#__pure__*/__webpack_require__.n(core_js_modules_web_dom_iterable_js__webpack_imported_module_10__);
/* harmony import */ var vue__webpack_imported_module_11__ = __webpack_require__(5);
function _createforofiteratorhelper(o, allowarraylike) { var it = typeof symbol !== "undefined" && o[symbol.iterator] || o["@@iterator"]; if (!it) { if (array.isarray(o) || (it = _unsupportediterabletoarray(o)) || allowarraylike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var f = function f() {}; return { s: f, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: f }; } throw new typeerror("invalid attempt to iterate non-iterable instance.\nin order to be iterable, non-array objects must have a [symbol.iterator]() method."); } var normalcompletion = true, diderr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalcompletion = step.done; return step; }, e: function e(_e2) { diderr = true; err = _e2; }, f: function f() { try { if (!normalcompletion && it.return != null) it.return(); } finally { if (diderr) throw err; } } }; }

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; }














var requestidlecallback = window.requestidlecallback || function (cb) {
  var start = date.now();
  return settimeout(function () {
    cb({
      didtimeout: false,
      timeremaining: function timeremaining() {
        return math.max(0, 50 - (date.now() - start));
      }
    });
  }, 1);
};

var cancelidlecallback = window.cancelidlecallback || function (id) {
  cleartimeout(id);
};

var observer = window.intersectionobserver && new window.intersectionobserver(function (entries) {
  entries.foreach(function (_ref) {
    var intersectionratio = _ref.intersectionratio,
        link = _ref.target;

    if (intersectionratio <= 0 || !link.__prefetch) {
      return;
    }

    link.__prefetch();
  });
});
/* harmony default export */ __webpack_exports__["a"] = ({
  name: 'nuxtlink',
  extends: vue__webpack_imported_module_11__["default"].component('routerlink'),
  props: {
    prefetch: {
      type: boolean,
      default: true
    },
    noprefetch: {
      type: boolean,
      default: false
    }
  },
  mounted: function mounted() {
    if (this.prefetch && !this.noprefetch) {
      this.handleid = requestidlecallback(this.observe, {
        timeout: 2e3
      });
    }
  },
  beforedestroy: function beforedestroy() {
    cancelidlecallback(this.handleid);

    if (this.__observed) {
      observer.unobserve(this.$el);
      delete this.$el.__prefetch;
    }
  },
  methods: {
    observe: function observe() {
      // if no intersectionobserver, avoid prefetching
      if (!observer) {
        return;
      } // add to observer


      if (this.shouldprefetch()) {
        this.$el.__prefetch = this.prefetchlink.bind(this);
        observer.observe(this.$el);
        this.__observed = true;
      }
    },
    shouldprefetch: function shouldprefetch() {
      return this.getprefetchcomponents().length > 0;
    },
    canprefetch: function canprefetch() {
      var conn = navigator.connection;
      var hasbadconnection = this.$nuxt.isoffline || conn && ((conn.effectivetype || '').includes('2g') || conn.savedata);
      return !hasbadconnection;
    },
    getprefetchcomponents: function getprefetchcomponents() {
      var ref = this.$router.resolve(this.to, this.$route, this.append);
      var components = ref.resolved.matched.map(function (r) {
        return r.components.default;
      });
      return components.filter(function (component) {
        return typeof component === 'function' && !component.options && !component.__prefetched;
      });
    },
    prefetchlink: function prefetchlink() {
      if (!this.canprefetch()) {
        return;
      } // stop observing this link (in case of internet connection changes)


      observer.unobserve(this.$el);
      var components = this.getprefetchcomponents();

      var _iterator = _createforofiteratorhelper(components),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var component = _step.value;
          var componentorpromise = component();

          if (componentorpromise instanceof promise) {
            componentorpromise.catch(function () {});
          }

          component.__prefetched = true;
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
    }
  }
});

/***/ })

}]);