@faststore/core 2.0.163-alpha.0 → 2.0.164-alpha.0

package/.next/server/chunks/664.js

@@ -0,0 +1,3401 @@
+exports.id = 664;
+exports.ids = [664];
+exports.modules = {
+
+/***/ 932:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+var __webpack_unused_export__;
+
+__webpack_unused_export__ = ({
+    value: true
+});
+exports.Z = _asyncToGenerator;
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+
+
+/***/ }),
+
+/***/ 227:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.addBasePath = addBasePath;
+
+var _addPathPrefix = __webpack_require__(1751);
+
+var _normalizeTrailingSlash = __webpack_require__(4969);
+
+const basePath =  false || '';
+
+function addBasePath(path, required) {
+  if (false) {}
+
+  return (0, _normalizeTrailingSlash).normalizePathTrailingSlash((0, _addPathPrefix).addPathPrefix(path, basePath));
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 7995:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.addLocale = void 0;
+
+var _normalizeTrailingSlash = __webpack_require__(4969);
+
+const addLocale = (path, ...args) => {
+  if (true) {
+    return (0, _normalizeTrailingSlash).normalizePathTrailingSlash((__webpack_require__(3431).addLocale)(path, ...args));
+  }
+
+  return path;
+};
+
+exports.addLocale = addLocale;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 7565:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.detectDomainLocale = void 0;
+
+const detectDomainLocale = (...args) => {
+  if (true) {
+    return (__webpack_require__(3539).detectDomainLocale)(...args);
+  }
+};
+
+exports.detectDomainLocale = detectDomainLocale;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 4019:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getDomainLocale = getDomainLocale;
+const basePath =  false || '';
+
+function getDomainLocale(path, locale, locales, domainLocales) {
+  if (true) {
+    const normalizeLocalePath = (__webpack_require__(6340).normalizeLocalePath);
+
+    const detectDomainLocale = (__webpack_require__(7565).detectDomainLocale);
+
+    const target = locale || normalizeLocalePath(path, locales).detectedLocale;
+    const domain = detectDomainLocale(domainLocales, undefined, target);
+
+    if (domain) {
+      const proto = `http${domain.http ? '' : 's'}://`;
+      const finalLocale = target === domain.defaultLocale ? '' : `/${target}`;
+      return `${proto}${domain.domain}${basePath}${finalLocale}${path}`;
+    }
+
+    return false;
+  } else {}
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 8771:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.hasBasePath = hasBasePath;
+
+var _pathHasPrefix = __webpack_require__(4567);
+
+const basePath =  false || '';
+
+function hasBasePath(path) {
+  return (0, _pathHasPrefix).pathHasPrefix(path, basePath);
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 877:
+/***/ ((module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = initHeadManager;
+exports.isEqualNode = isEqualNode;
+exports.DOMAttributeNames = void 0;
+
+function initHeadManager() {
+  return {
+    mountedInstances: new Set(),
+    updateHead: head => {
+      const tags = {};
+      head.forEach(h => {
+        if ( // If the font tag is loaded only on client navigation
+        // it won't be inlined. In this case revert to the original behavior
+        h.type === 'link' && h.props['data-optimized-fonts']) {
+          if (document.querySelector(`style[data-href="${h.props['data-href']}"]`)) {
+            return;
+          } else {
+            h.props.href = h.props['data-href'];
+            h.props['data-href'] = undefined;
+          }
+        }
+
+        const components = tags[h.type] || [];
+        components.push(h);
+        tags[h.type] = components;
+      });
+      const titleComponent = tags.title ? tags.title[0] : null;
+      let title = '';
+
+      if (titleComponent) {
+        const {
+          children
+        } = titleComponent.props;
+        title = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+      }
+
+      if (title !== document.title) document.title = title;
+      ['meta', 'base', 'link', 'style', 'script'].forEach(type => {
+        updateElements(type, tags[type] || []);
+      });
+    }
+  };
+}
+
+const DOMAttributeNames = {
+  acceptCharset: 'accept-charset',
+  className: 'class',
+  htmlFor: 'for',
+  httpEquiv: 'http-equiv',
+  noModule: 'noModule'
+};
+exports.DOMAttributeNames = DOMAttributeNames;
+
+function reactElementToDOM({
+  type,
+  props
+}) {
+  const el = document.createElement(type);
+
+  for (const p in props) {
+    if (!props.hasOwnProperty(p)) continue;
+    if (p === 'children' || p === 'dangerouslySetInnerHTML') continue; // we don't render undefined props to the DOM
+
+    if (props[p] === undefined) continue;
+    const attr = DOMAttributeNames[p] || p.toLowerCase();
+
+    if (type === 'script' && (attr === 'async' || attr === 'defer' || attr === 'noModule')) {
+      el[attr] = !!props[p];
+    } else {
+      el.setAttribute(attr, props[p]);
+    }
+  }
+
+  const {
+    children,
+    dangerouslySetInnerHTML
+  } = props;
+
+  if (dangerouslySetInnerHTML) {
+    el.innerHTML = dangerouslySetInnerHTML.__html || '';
+  } else if (children) {
+    el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+  }
+
+  return el;
+}
+
+function isEqualNode(oldTag, newTag) {
+  if (oldTag instanceof HTMLElement && newTag instanceof HTMLElement) {
+    const nonce = newTag.getAttribute('nonce'); // Only strip the nonce if `oldTag` has had it stripped. An element's nonce attribute will not
+    // be stripped if there is no content security policy response header that includes a nonce.
+
+    if (nonce && !oldTag.getAttribute('nonce')) {
+      const cloneTag = newTag.cloneNode(true);
+      cloneTag.setAttribute('nonce', '');
+      cloneTag.nonce = nonce;
+      return nonce === oldTag.nonce && oldTag.isEqualNode(cloneTag);
+    }
+  }
+
+  return oldTag.isEqualNode(newTag);
+}
+
+function updateElements(type, components) {
+  const headEl = document.getElementsByTagName('head')[0];
+  const headCountEl = headEl.querySelector('meta[name=next-head-count]');
+
+  if (false) {}
+
+  const headCount = Number(headCountEl.content);
+  const oldTags = [];
+
+  for (let i = 0, j = headCountEl.previousElementSibling; i < headCount; i++, j = (j == null ? void 0 : j.previousElementSibling) || null) {
+    var ref;
+
+    if ((j == null ? void 0 : (ref = j.tagName) == null ? void 0 : ref.toLowerCase()) === type) {
+      oldTags.push(j);
+    }
+  }
+
+  const newTags = components.map(reactElementToDOM).filter(newTag => {
+    for (let k = 0, len = oldTags.length; k < len; k++) {
+      const oldTag = oldTags[k];
+
+      if (isEqualNode(oldTag, newTag)) {
+        oldTags.splice(k, 1);
+        return false;
+      }
+    }
+
+    return true;
+  });
+  oldTags.forEach(t => {
+    var ref;
+    return (ref = t.parentNode) == null ? void 0 : ref.removeChild(t);
+  });
+  newTags.forEach(t => headEl.insertBefore(t, headCountEl));
+  headCountEl.content = (headCount - oldTags.length + newTags.length).toString();
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 7942:
+/***/ ((module, exports, __webpack_require__) => {
+
+"client";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
+
+var _object_without_properties_loose = (__webpack_require__(7273)/* ["default"] */ .Z);
+
+var _react = _interop_require_default(__webpack_require__(6689));
+
+var _router = __webpack_require__(5781);
+
+var _addLocale = __webpack_require__(7995);
+
+var _routerContext = __webpack_require__(4964);
+
+var _appRouterContext = __webpack_require__(3280);
+
+var _useIntersection = __webpack_require__(639);
+
+var _getDomainLocale = __webpack_require__(4019);
+
+var _addBasePath = __webpack_require__(227);
+
+'client';
+const prefetched = {};
+
+function prefetch(router, href, as, options) {
+  if (true) return;
+  if (!(0, _router).isLocalURL(href)) return; // Prefetch the JSON page if asked (only in the client)
+  // We need to handle a prefetch error here since we may be
+  // loading with priority which can reject but we don't
+  // want to force navigation since this is only a prefetch
+
+  Promise.resolve(router.prefetch(href, as, options)).catch(err => {
+    if (false) {}
+  });
+  const curLocale = options && typeof options.locale !== 'undefined' ? options.locale : router && router.locale; // Join on an invalid URI character
+
+  prefetched[href + '%' + as + (curLocale ? '%' + curLocale : '')] = true;
+}
+
+function isModifiedEvent(event) {
+  const {
+    target
+  } = event.currentTarget;
+  return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.nativeEvent && event.nativeEvent.which === 2;
+}
+
+function linkClicked(e, router, href, as, replace, shallow, scroll, locale, isAppRouter, prefetchEnabled) {
+  const {
+    nodeName
+  } = e.currentTarget; // anchors inside an svg have a lowercase nodeName
+
+  const isAnchorNodeName = nodeName.toUpperCase() === 'A';
+
+  if (isAnchorNodeName && (isModifiedEvent(e) || !(0, _router).isLocalURL(href))) {
+    // ignore click for browser’s default behavior
+    return;
+  }
+
+  e.preventDefault();
+
+  const navigate = () => {
+    // If the router is an NextRouter instance it will have `beforePopState`
+    if ('beforePopState' in router) {
+      router[replace ? 'replace' : 'push'](href, as, {
+        shallow,
+        locale,
+        scroll
+      });
+    } else {
+      // If `beforePopState` doesn't exist on the router it's the AppRouter.
+      const method = replace ? 'replace' : 'push';
+      router[method](href, {
+        forceOptimisticNavigation: !prefetchEnabled
+      });
+    }
+  };
+
+  if (isAppRouter) {
+    // @ts-expect-error startTransition exists.
+    _react.default.startTransition(navigate);
+  } else {
+    navigate();
+  }
+}
+
+const Link = /*#__PURE__*/_react.default.forwardRef(function LinkComponent(props, forwardedRef) {
+  if (false) { var createPropError; }
+
+  let children;
+
+  const {
+    href: hrefProp,
+    as: asProp,
+    children: childrenProp,
+    prefetch: prefetchProp,
+    passHref,
+    replace,
+    shallow,
+    scroll,
+    locale,
+    onClick,
+    onMouseEnter,
+    onTouchStart,
+    legacyBehavior = Boolean(false) !== true
+  } = props,
+        restProps = _object_without_properties_loose(props, ["href", "as", "children", "prefetch", "passHref", "replace", "shallow", "scroll", "locale", "onClick", "onMouseEnter", "onTouchStart", "legacyBehavior"]);
+
+  children = childrenProp;
+
+  if (legacyBehavior && (typeof children === 'string' || typeof children === 'number')) {
+    children = /*#__PURE__*/_react.default.createElement("a", null, children);
+  }
+
+  const p = prefetchProp !== false;
+
+  let router = _react.default.useContext(_routerContext.RouterContext); // TODO-APP: type error. Remove `as any`
+
+
+  const appRouter = _react.default.useContext(_appRouterContext.AppRouterContext);
+
+  if (appRouter) {
+    router = appRouter;
+  }
+
+  const {
+    href,
+    as
+  } = _react.default.useMemo(() => {
+    const [resolvedHref, resolvedAs] = (0, _router).resolveHref(router, hrefProp, true);
+    return {
+      href: resolvedHref,
+      as: asProp ? (0, _router).resolveHref(router, asProp) : resolvedAs || resolvedHref
+    };
+  }, [router, hrefProp, asProp]);
+
+  const previousHref = _react.default.useRef(href);
+
+  const previousAs = _react.default.useRef(as); // This will return the first child, if multiple are provided it will throw an error
+
+
+  let child;
+
+  if (legacyBehavior) {
+    if (false) {} else {
+      child = _react.default.Children.only(children);
+    }
+  }
+
+  const childRef = legacyBehavior ? child && typeof child === 'object' && child.ref : forwardedRef;
+  const [setIntersectionRef, isVisible, resetVisible] = (0, _useIntersection).useIntersection({
+    rootMargin: '200px'
+  });
+
+  const setRef = _react.default.useCallback(el => {
+    // Before the link getting observed, check if visible state need to be reset
+    if (previousAs.current !== as || previousHref.current !== href) {
+      resetVisible();
+      previousAs.current = as;
+      previousHref.current = href;
+    }
+
+    setIntersectionRef(el);
+
+    if (childRef) {
+      if (typeof childRef === 'function') childRef(el);else if (typeof childRef === 'object') {
+        childRef.current = el;
+      }
+    }
+  }, [as, childRef, href, resetVisible, setIntersectionRef]);
+
+  _react.default.useEffect(() => {
+    const shouldPrefetch = isVisible && p && (0, _router).isLocalURL(href);
+    const curLocale = typeof locale !== 'undefined' ? locale : router && router.locale;
+    const isPrefetched = prefetched[href + '%' + as + (curLocale ? '%' + curLocale : '')];
+
+    if (shouldPrefetch && !isPrefetched) {
+      prefetch(router, href, as, {
+        locale: curLocale
+      });
+    }
+  }, [as, href, isVisible, locale, p, router]);
+
+  const childProps = {
+    ref: setRef,
+    onClick: e => {
+      if (false) {}
+
+      if (!legacyBehavior && typeof onClick === 'function') {
+        onClick(e);
+      }
+
+      if (legacyBehavior && child.props && typeof child.props.onClick === 'function') {
+        child.props.onClick(e);
+      }
+
+      if (!e.defaultPrevented) {
+        linkClicked(e, router, href, as, replace, shallow, scroll, locale, Boolean(appRouter), p);
+      }
+    },
+    onMouseEnter: e => {
+      if (!legacyBehavior && typeof onMouseEnter === 'function') {
+        onMouseEnter(e);
+      }
+
+      if (legacyBehavior && child.props && typeof child.props.onMouseEnter === 'function') {
+        child.props.onMouseEnter(e);
+      } // Check for not prefetch disabled in page using appRouter
+
+
+      if (!(!p && appRouter)) {
+        if ((0, _router).isLocalURL(href)) {
+          prefetch(router, href, as, {
+            priority: true
+          });
+        }
+      }
+    },
+    onTouchStart: e => {
+      if (!legacyBehavior && typeof onTouchStart === 'function') {
+        onTouchStart(e);
+      }
+
+      if (legacyBehavior && child.props && typeof child.props.onTouchStart === 'function') {
+        child.props.onTouchStart(e);
+      } // Check for not prefetch disabled in page using appRouter
+
+
+      if (!(!p && appRouter)) {
+        if ((0, _router).isLocalURL(href)) {
+          prefetch(router, href, as, {
+            priority: true
+          });
+        }
+      }
+    }
+  }; // If child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
+  // defined, we specify the current 'href', so that repetition is not needed by the user
+
+  if (!legacyBehavior || passHref || child.type === 'a' && !('href' in child.props)) {
+    const curLocale = typeof locale !== 'undefined' ? locale : router && router.locale; // we only render domain locales if we are currently on a domain locale
+    // so that locale links are still visitable in development/preview envs
+
+    const localeDomain = router && router.isLocaleDomain && (0, _getDomainLocale).getDomainLocale(as, curLocale, router.locales, router.domainLocales);
+    childProps.href = localeDomain || (0, _addBasePath).addBasePath((0, _addLocale).addLocale(as, curLocale, router && router.defaultLocale));
+  }
+
+  return legacyBehavior ? /*#__PURE__*/_react.default.cloneElement(child, childProps) : /*#__PURE__*/_react.default.createElement("a", Object.assign({}, restProps, childProps), children);
+});
+
+var _default = Link;
+exports["default"] = _default;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 6340:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.normalizeLocalePath = void 0;
+
+const normalizeLocalePath = (pathname, locales) => {
+  if (true) {
+    return (__webpack_require__(4014).normalizeLocalePath)(pathname, locales);
+  }
+
+  return {
+    pathname,
+    detectedLocale: undefined
+  };
+};
+
+exports.normalizeLocalePath = normalizeLocalePath;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 4969:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.normalizePathTrailingSlash = void 0;
+
+var _removeTrailingSlash = __webpack_require__(3297);
+
+var _parsePath = __webpack_require__(8854);
+
+const normalizePathTrailingSlash = path => {
+  if (!path.startsWith('/') || undefined) {
+    return path;
+  }
+
+  const {
+    pathname,
+    query,
+    hash
+  } = (0, _parsePath).parsePath(path);
+
+  if (false) {}
+
+  return `${(0, _removeTrailingSlash).removeTrailingSlash(pathname)}${query}${hash}`;
+};
+
+exports.normalizePathTrailingSlash = normalizePathTrailingSlash;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 5678:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.removeBasePath = removeBasePath;
+
+var _hasBasePath = __webpack_require__(8771);
+
+const basePath =  false || '';
+
+function removeBasePath(path) {
+  if (false) {}
+
+  path = path.slice(basePath.length);
+  if (!path.startsWith('/')) path = `/${path}`;
+  return path;
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 9781:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.removeLocale = removeLocale;
+
+var _parsePath = __webpack_require__(8854);
+
+function removeLocale(path, locale) {
+  if (true) {
+    const {
+      pathname
+    } = (0, _parsePath).parsePath(path);
+    const pathLower = pathname.toLowerCase();
+    const localeLower = locale == null ? void 0 : locale.toLowerCase();
+    return locale && (pathLower.startsWith(`/${localeLower}/`) || pathLower === `/${localeLower}`) ? `${pathname.length === locale.length + 1 ? `/` : ``}${path.slice(locale.length + 1)}` : path;
+  }
+
+  return path;
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 6286:
+/***/ ((module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.cancelIdleCallback = exports.requestIdleCallback = void 0;
+
+const requestIdleCallback = typeof self !== 'undefined' && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function (cb) {
+  let start = Date.now();
+  return setTimeout(function () {
+    cb({
+      didTimeout: false,
+      timeRemaining: function () {
+        return Math.max(0, 50 - (Date.now() - start));
+      }
+    });
+  }, 1);
+};
+
+exports.requestIdleCallback = requestIdleCallback;
+
+const cancelIdleCallback = typeof self !== 'undefined' && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function (id) {
+  return clearTimeout(id);
+};
+
+exports.cancelIdleCallback = cancelIdleCallback;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 4989:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.markAssetError = markAssetError;
+exports.isAssetError = isAssetError;
+exports.getClientBuildManifest = getClientBuildManifest;
+exports.createRouteLoader = createRouteLoader;
+
+var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
+
+var _getAssetPathFromRoute = _interop_require_default(__webpack_require__(9565));
+
+var _trustedTypes = __webpack_require__(5740);
+
+var _requestIdleCallback = __webpack_require__(6286); // 3.8s was arbitrarily chosen as it's what https://web.dev/interactive
+// considers as "Good" time-to-interactive. We must assume something went
+// wrong beyond this point, and then fall-back to a full page transition to
+// show the user something of value.
+
+
+const MS_MAX_IDLE_DELAY = 3800;
+
+function withFuture(key, map, generator) {
+  let entry = map.get(key);
+
+  if (entry) {
+    if ('future' in entry) {
+      return entry.future;
+    }
+
+    return Promise.resolve(entry);
+  }
+
+  let resolver;
+  const prom = new Promise(resolve => {
+    resolver = resolve;
+  });
+  map.set(key, entry = {
+    resolve: resolver,
+    future: prom
+  });
+  return generator ? generator() // eslint-disable-next-line no-sequences
+  .then(value => (resolver(value), value)).catch(err => {
+    map.delete(key);
+    throw err;
+  }) : prom;
+}
+
+function hasPrefetch(link) {
+  try {
+    link = document.createElement('link');
+    return (// detect IE11 since it supports prefetch but isn't detected
+      // with relList.support
+      !!window.MSInputMethodContext && !!document.documentMode || link.relList.supports('prefetch')
+    );
+  } catch (e) {
+    return false;
+  }
+}
+
+const canPrefetch = hasPrefetch();
+
+function prefetchViaDom(href, as, link) {
+  return new Promise((res, rej) => {
+    const selector = `
+      link[rel="prefetch"][href^="${href}"],
+      link[rel="preload"][href^="${href}"],
+      script[src^="${href}"]`;
+
+    if (document.querySelector(selector)) {
+      return res();
+    }
+
+    link = document.createElement('link'); // The order of property assignment here is intentional:
+
+    if (as) link.as = as;
+    link.rel = `prefetch`;
+    link.crossOrigin = undefined;
+    link.onload = res;
+    link.onerror = rej; // `href` should always be last:
+
+    link.href = href;
+    document.head.appendChild(link);
+  });
+}
+
+const ASSET_LOAD_ERROR = Symbol('ASSET_LOAD_ERROR');
+
+function markAssetError(err) {
+  return Object.defineProperty(err, ASSET_LOAD_ERROR, {});
+}
+
+function isAssetError(err) {
+  return err && ASSET_LOAD_ERROR in err;
+}
+
+function appendScript(src, script) {
+  return new Promise((resolve, reject) => {
+    script = document.createElement('script'); // The order of property assignment here is intentional.
+    // 1. Setup success/failure hooks in case the browser synchronously
+    //    executes when `src` is set.
+
+    script.onload = resolve;
+
+    script.onerror = () => reject(markAssetError(new Error(`Failed to load script: ${src}`))); // 2. Configure the cross-origin attribute before setting `src` in case the
+    //    browser begins to fetch.
+
+
+    script.crossOrigin = undefined; // 3. Finally, set the source and inject into the DOM in case the child
+    //    must be appended for fetching to start.
+
+    script.src = src;
+    document.body.appendChild(script);
+  });
+} // We wait for pages to be built in dev before we start the route transition
+// timeout to prevent an un-necessary hard navigation in development.
+
+
+let devBuildPromise; // Resolve a promise that times out after given amount of milliseconds.
+
+function resolvePromiseWithTimeout(p, ms, err) {
+  return new Promise((resolve, reject) => {
+    let cancelled = false;
+    p.then(r => {
+      // Resolved, cancel the timeout
+      cancelled = true;
+      resolve(r);
+    }).catch(reject); // We wrap these checks separately for better dead-code elimination in
+    // production bundles.
+
+    if (false) {}
+
+    if (true) {
+      (0, _requestIdleCallback).requestIdleCallback(() => setTimeout(() => {
+        if (!cancelled) {
+          reject(err);
+        }
+      }, ms));
+    }
+  });
+}
+
+function getClientBuildManifest() {
+  if (self.__BUILD_MANIFEST) {
+    return Promise.resolve(self.__BUILD_MANIFEST);
+  }
+
+  const onBuildManifest = new Promise(resolve => {
+    // Mandatory because this is not concurrent safe:
+    const cb = self.__BUILD_MANIFEST_CB;
+
+    self.__BUILD_MANIFEST_CB = () => {
+      resolve(self.__BUILD_MANIFEST);
+      cb && cb();
+    };
+  });
+  return resolvePromiseWithTimeout(onBuildManifest, MS_MAX_IDLE_DELAY, markAssetError(new Error('Failed to load client build manifest')));
+}
+
+function getFilesForRoute(assetPrefix, route) {
+  if (false) {}
+
+  return getClientBuildManifest().then(manifest => {
+    if (!(route in manifest)) {
+      throw markAssetError(new Error(`Failed to lookup route: ${route}`));
+    }
+
+    const allFiles = manifest[route].map(entry => assetPrefix + '/_next/' + encodeURI(entry));
+    return {
+      scripts: allFiles.filter(v => v.endsWith('.js')).map(v => (0, _trustedTypes).__unsafeCreateTrustedScriptURL(v)),
+      css: allFiles.filter(v => v.endsWith('.css'))
+    };
+  });
+}
+
+function createRouteLoader(assetPrefix) {
+  const entrypoints = new Map();
+  const loadedScripts = new Map();
+  const styleSheets = new Map();
+  const routes = new Map();
+
+  function maybeExecuteScript(src) {
+    // With HMR we might need to "reload" scripts when they are
+    // disposed and readded. Executing scripts twice has no functional
+    // differences
+    if (true) {
+      let prom = loadedScripts.get(src.toString());
+
+      if (prom) {
+        return prom;
+      } // Skip executing script if it's already in the DOM:
+
+
+      if (document.querySelector(`script[src^="${src}"]`)) {
+        return Promise.resolve();
+      }
+
+      loadedScripts.set(src.toString(), prom = appendScript(src));
+      return prom;
+    } else {}
+  }
+
+  function fetchStyleSheet(href) {
+    let prom = styleSheets.get(href);
+
+    if (prom) {
+      return prom;
+    }
+
+    styleSheets.set(href, prom = fetch(href).then(res => {
+      if (!res.ok) {
+        throw new Error(`Failed to load stylesheet: ${href}`);
+      }
+
+      return res.text().then(text => ({
+        href: href,
+        content: text
+      }));
+    }).catch(err => {
+      throw markAssetError(err);
+    }));
+    return prom;
+  }
+
+  return {
+    whenEntrypoint(route) {
+      return withFuture(route, entrypoints);
+    },
+
+    onEntrypoint(route, execute) {
+      (execute ? Promise.resolve().then(() => execute()).then(exports => ({
+        component: exports && exports.default || exports,
+        exports: exports
+      }), err => ({
+        error: err
+      })) : Promise.resolve(undefined)).then(input => {
+        const old = entrypoints.get(route);
+
+        if (old && 'resolve' in old) {
+          if (input) {
+            entrypoints.set(route, input);
+            old.resolve(input);
+          }
+        } else {
+          if (input) {
+            entrypoints.set(route, input);
+          } else {
+            entrypoints.delete(route);
+          } // when this entrypoint has been resolved before
+          // the route is outdated and we want to invalidate
+          // this cache entry
+
+
+          routes.delete(route);
+        }
+      });
+    },
+
+    loadRoute(route, prefetch) {
+      return withFuture(route, routes, () => {
+        let devBuildPromiseResolve;
+
+        if (false) {}
+
+        return resolvePromiseWithTimeout(getFilesForRoute(assetPrefix, route).then(({
+          scripts,
+          css
+        }) => {
+          return Promise.all([entrypoints.has(route) ? [] : Promise.all(scripts.map(maybeExecuteScript)), Promise.all(css.map(fetchStyleSheet))]);
+        }).then(res => {
+          return this.whenEntrypoint(route).then(entrypoint => ({
+            entrypoint,
+            styles: res[1]
+          }));
+        }), MS_MAX_IDLE_DELAY, markAssetError(new Error(`Route did not complete loading: ${route}`))).then(({
+          entrypoint,
+          styles
+        }) => {
+          const res = Object.assign({
+            styles: styles
+          }, entrypoint);
+          return 'error' in entrypoint ? entrypoint : res;
+        }).catch(err => {
+          if (prefetch) {
+            // we don't want to cache errors during prefetch
+            throw err;
+          }
+
+          return {
+            error: err
+          };
+        }).finally(() => {
+          return devBuildPromiseResolve == null ? void 0 : devBuildPromiseResolve();
+        });
+      });
+    },
+
+    prefetch(route) {
+      // https://github.com/GoogleChromeLabs/quicklink/blob/453a661fa1fa940e2d2e044452398e38c67a98fb/src/index.mjs#L115-L118
+      // License: Apache 2.0
+      let cn;
+
+      if (cn = navigator.connection) {
+        // Don't prefetch if using 2G or if Save-Data is enabled.
+        if (cn.saveData || /2g/.test(cn.effectiveType)) return Promise.resolve();
+      }
+
+      return getFilesForRoute(assetPrefix, route).then(output => Promise.all(canPrefetch ? output.scripts.map(script => prefetchViaDom(script.toString(), 'script')) : [])).then(() => {
+        (0, _requestIdleCallback).requestIdleCallback(() => this.loadRoute(route, true).catch(() => {}));
+      }).catch( // swallow prefetch errors
+      () => {});
+    }
+
+  };
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 2189:
+/***/ ((module, exports, __webpack_require__) => {
+
+"client";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.handleClientScriptLoad = handleClientScriptLoad;
+exports.initScriptLoader = initScriptLoader;
+exports["default"] = void 0;
+
+var _extends = (__webpack_require__(6495)/* ["default"] */ .Z);
+
+var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z);
+
+var _object_without_properties_loose = (__webpack_require__(7273)/* ["default"] */ .Z);
+
+var _react = _interop_require_wildcard(__webpack_require__(6689));
+
+var _headManagerContext = __webpack_require__(2796);
+
+var _headManager = __webpack_require__(877);
+
+var _requestIdleCallback = __webpack_require__(6286);
+
+'client';
+const ScriptCache = new Map();
+const LoadCache = new Set();
+const ignoreProps = ['onLoad', 'onReady', 'dangerouslySetInnerHTML', 'children', 'onError', 'strategy'];
+
+const loadScript = props => {
+  const {
+    src,
+    id,
+    onLoad = () => {},
+    onReady = null,
+    dangerouslySetInnerHTML,
+    children = '',
+    strategy = 'afterInteractive',
+    onError
+  } = props;
+  const cacheKey = id || src; // Script has already loaded
+
+  if (cacheKey && LoadCache.has(cacheKey)) {
+    return;
+  } // Contents of this script are already loading/loaded
+
+
+  if (ScriptCache.has(src)) {
+    LoadCache.add(cacheKey); // It is possible that multiple `next/script` components all have same "src", but has different "onLoad"
+    // This is to make sure the same remote script will only load once, but "onLoad" are executed in order
+
+    ScriptCache.get(src).then(onLoad, onError);
+    return;
+  }
+  /** Execute after the script first loaded */
+
+
+  const afterLoad = () => {
+    // Run onReady for the first time after load event
+    if (onReady) {
+      onReady();
+    } // add cacheKey to LoadCache when load successfully
+
+
+    LoadCache.add(cacheKey);
+  };
+
+  const el = document.createElement('script');
+  const loadPromise = new Promise((resolve, reject) => {
+    el.addEventListener('load', function (e) {
+      resolve();
+
+      if (onLoad) {
+        onLoad.call(this, e);
+      }
+
+      afterLoad();
+    });
+    el.addEventListener('error', function (e) {
+      reject(e);
+    });
+  }).catch(function (e) {
+    if (onError) {
+      onError(e);
+    }
+  });
+
+  if (dangerouslySetInnerHTML) {
+    el.innerHTML = dangerouslySetInnerHTML.__html || '';
+    afterLoad();
+  } else if (children) {
+    el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+    afterLoad();
+  } else if (src) {
+    el.src = src; // do not add cacheKey into LoadCache for remote script here
+    // cacheKey will be added to LoadCache when it is actually loaded (see loadPromise above)
+
+    ScriptCache.set(src, loadPromise);
+  }
+
+  for (const [k, value] of Object.entries(props)) {
+    if (value === undefined || ignoreProps.includes(k)) {
+      continue;
+    }
+
+    const attr = _headManager.DOMAttributeNames[k] || k.toLowerCase();
+    el.setAttribute(attr, value);
+  }
+
+  if (strategy === 'worker') {
+    el.setAttribute('type', 'text/partytown');
+  }
+
+  el.setAttribute('data-nscript', strategy);
+  document.body.appendChild(el);
+};
+
+function handleClientScriptLoad(props) {
+  const {
+    strategy = 'afterInteractive'
+  } = props;
+
+  if (strategy === 'lazyOnload') {
+    window.addEventListener('load', () => {
+      (0, _requestIdleCallback).requestIdleCallback(() => loadScript(props));
+    });
+  } else {
+    loadScript(props);
+  }
+}
+
+function loadLazyScript(props) {
+  if (document.readyState === 'complete') {
+    (0, _requestIdleCallback).requestIdleCallback(() => loadScript(props));
+  } else {
+    window.addEventListener('load', () => {
+      (0, _requestIdleCallback).requestIdleCallback(() => loadScript(props));
+    });
+  }
+}
+
+function addBeforeInteractiveToCache() {
+  const scripts = [...document.querySelectorAll('[data-nscript="beforeInteractive"]'), ...document.querySelectorAll('[data-nscript="beforePageRender"]')];
+  scripts.forEach(script => {
+    const cacheKey = script.id || script.getAttribute('src');
+    LoadCache.add(cacheKey);
+  });
+}
+
+function initScriptLoader(scriptLoaderItems) {
+  scriptLoaderItems.forEach(handleClientScriptLoad);
+  addBeforeInteractiveToCache();
+}
+
+function Script(props) {
+  const {
+    id,
+    src = '',
+    onLoad = () => {},
+    onReady = null,
+    strategy = 'afterInteractive',
+    onError
+  } = props,
+        restProps = _object_without_properties_loose(props, ["id", "src", "onLoad", "onReady", "strategy", "onError"]); // Context is available only during SSR
+
+
+  const {
+    updateScripts,
+    scripts,
+    getIsSsr
+  } = (0, _react).useContext(_headManagerContext.HeadManagerContext);
+  /**
+  * - First mount:
+  *   1. The useEffect for onReady executes
+  *   2. hasOnReadyEffectCalled.current is false, but the script hasn't loaded yet (not in LoadCache)
+  *      onReady is skipped, set hasOnReadyEffectCalled.current to true
+  *   3. The useEffect for loadScript executes
+  *   4. hasLoadScriptEffectCalled.current is false, loadScript executes
+  *      Once the script is loaded, the onLoad and onReady will be called by then
+  *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+  *   5. The useEffect for onReady executes again
+  *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+  *   7. The useEffect for loadScript executes again
+  *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+  *
+  * - Second mount:
+  *   1. The useEffect for onReady executes
+  *   2. hasOnReadyEffectCalled.current is false, but the script has already loaded (found in LoadCache)
+  *      onReady is called, set hasOnReadyEffectCalled.current to true
+  *   3. The useEffect for loadScript executes
+  *   4. The script is already loaded, loadScript bails out
+  *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+  *   5. The useEffect for onReady executes again
+  *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+  *   7. The useEffect for loadScript executes again
+  *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+  */
+
+  const hasOnReadyEffectCalled = (0, _react).useRef(false);
+  (0, _react).useEffect(() => {
+    const cacheKey = id || src;
+
+    if (!hasOnReadyEffectCalled.current) {
+      // Run onReady if script has loaded before but component is re-mounted
+      if (onReady && cacheKey && LoadCache.has(cacheKey)) {
+        onReady();
+      }
+
+      hasOnReadyEffectCalled.current = true;
+    }
+  }, [onReady, id, src]);
+  const hasLoadScriptEffectCalled = (0, _react).useRef(false);
+  (0, _react).useEffect(() => {
+    if (!hasLoadScriptEffectCalled.current) {
+      if (strategy === 'afterInteractive') {
+        loadScript(props);
+      } else if (strategy === 'lazyOnload') {
+        loadLazyScript(props);
+      }
+
+      hasLoadScriptEffectCalled.current = true;
+    }
+  }, [props, strategy]);
+
+  if (strategy === 'beforeInteractive' || strategy === 'worker') {
+    if (updateScripts) {
+      scripts[strategy] = (scripts[strategy] || []).concat([_extends({
+        id,
+        src,
+        onLoad,
+        onReady,
+        onError
+      }, restProps)]);
+      updateScripts(scripts);
+    } else if (getIsSsr && getIsSsr()) {
+      // Script has already loaded during SSR
+      LoadCache.add(id || src);
+    } else if (getIsSsr && !getIsSsr()) {
+      loadScript(props);
+    }
+  }
+
+  return null;
+}
+
+Object.defineProperty(Script, '__nextScript', {
+  value: true
+});
+var _default = Script;
+exports["default"] = _default;
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 5740:
+/***/ ((module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.__unsafeCreateTrustedScriptURL = __unsafeCreateTrustedScriptURL;
+/**
+ * Stores the Trusted Types Policy. Starts as undefined and can be set to null
+ * if Trusted Types is not supported in the browser.
+ */
+
+let policy;
+/**
+ * Getter for the Trusted Types Policy. If it is undefined, it is instantiated
+ * here or set to null if Trusted Types is not supported in the browser.
+ */
+
+function getPolicy() {
+  if (typeof policy === 'undefined' && false) { var ref; }
+
+  return policy;
+}
+
+function __unsafeCreateTrustedScriptURL(url) {
+  var ref;
+  return ((ref = getPolicy()) == null ? void 0 : ref.createScriptURL(url)) || url;
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 639:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.useIntersection = useIntersection;
+
+var _react = __webpack_require__(6689);
+
+var _requestIdleCallback = __webpack_require__(6286);
+
+const hasIntersectionObserver = typeof IntersectionObserver === 'function';
+const observers = new Map();
+const idList = [];
+
+function createObserver(options) {
+  const id = {
+    root: options.root || null,
+    margin: options.rootMargin || ''
+  };
+  const existing = idList.find(obj => obj.root === id.root && obj.margin === id.margin);
+  let instance;
+
+  if (existing) {
+    instance = observers.get(existing);
+
+    if (instance) {
+      return instance;
+    }
+  }
+
+  const elements = new Map();
+  const observer = new IntersectionObserver(entries => {
+    entries.forEach(entry => {
+      const callback = elements.get(entry.target);
+      const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
+
+      if (callback && isVisible) {
+        callback(isVisible);
+      }
+    });
+  }, options);
+  instance = {
+    id,
+    observer,
+    elements
+  };
+  idList.push(id);
+  observers.set(id, instance);
+  return instance;
+}
+
+function observe(element, callback, options) {
+  const {
+    id,
+    observer,
+    elements
+  } = createObserver(options);
+  elements.set(element, callback);
+  observer.observe(element);
+  return function unobserve() {
+    elements.delete(element);
+    observer.unobserve(element); // Destroy observer when there's nothing left to watch:
+
+    if (elements.size === 0) {
+      observer.disconnect();
+      observers.delete(id);
+      const index = idList.findIndex(obj => obj.root === id.root && obj.margin === id.margin);
+
+      if (index > -1) {
+        idList.splice(index, 1);
+      }
+    }
+  };
+}
+
+function useIntersection({
+  rootRef,
+  rootMargin,
+  disabled
+}) {
+  const isDisabled = disabled || !hasIntersectionObserver;
+  const [visible, setVisible] = (0, _react).useState(false);
+  const [element, setElement] = (0, _react).useState(null);
+  (0, _react).useEffect(() => {
+    if (hasIntersectionObserver) {
+      if (isDisabled || visible) return;
+
+      if (element && element.tagName) {
+        const unobserve = observe(element, isVisible => isVisible && setVisible(isVisible), {
+          root: rootRef == null ? void 0 : rootRef.current,
+          rootMargin
+        });
+        return unobserve;
+      }
+    } else {
+      if (!visible) {
+        const idleCallback = (0, _requestIdleCallback).requestIdleCallback(() => setVisible(true));
+        return () => (0, _requestIdleCallback).cancelIdleCallback(idleCallback);
+      }
+    }
+  }, [element, isDisabled, rootMargin, rootRef, visible]);
+  const resetVisible = (0, _react).useCallback(() => {
+    setVisible(false);
+  }, []);
+  return [setElement, visible, resetVisible];
+}
+
+if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', {
+    value: true
+  });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+/***/ }),
+
+/***/ 5781:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.matchesMiddleware = matchesMiddleware;
+exports.isLocalURL = isLocalURL;
+exports.interpolateAs = interpolateAs;
+exports.resolveHref = resolveHref;
+exports.createKey = createKey;
+exports["default"] = void 0;
+
+var _async_to_generator = (__webpack_require__(932)/* ["default"] */ .Z);
+
+var _extends = (__webpack_require__(6495)/* ["default"] */ .Z);
+
+var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
+
+var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z);
+
+var _normalizeTrailingSlash = __webpack_require__(4969);
+
+var _removeTrailingSlash = __webpack_require__(3297);
+
+var _routeLoader = __webpack_require__(4989);
+
+var _script = __webpack_require__(2189);
+
+var _isError = _interop_require_wildcard(__webpack_require__(676));
+
+var _denormalizePagePath = __webpack_require__(4406);
+
+var _normalizeLocalePath = __webpack_require__(4014);
+
+var _mitt = _interop_require_default(__webpack_require__(8020));
+
+var _utils = __webpack_require__(9232);
+
+var _isDynamic = __webpack_require__(1428);
+
+var _parseRelativeUrl = __webpack_require__(1292);
+
+var _querystring = __webpack_require__(979);
+
+var _resolveRewrites = _interop_require_default(__webpack_require__(6052));
+
+var _routeMatcher = __webpack_require__(4226);
+
+var _routeRegex = __webpack_require__(5052);
+
+var _formatUrl = __webpack_require__(3938);
+
+var _detectDomainLocale = __webpack_require__(7565);
+
+var _parsePath = __webpack_require__(8854);
+
+var _addLocale = __webpack_require__(7995);
+
+var _removeLocale = __webpack_require__(9781);
+
+var _removeBasePath = __webpack_require__(5678);
+
+var _addBasePath = __webpack_require__(227);
+
+var _hasBasePath = __webpack_require__(8771);
+
+var _getNextPathnameInfo = __webpack_require__(5789);
+
+var _formatNextPathnameInfo = __webpack_require__(299);
+
+var _compareStates = __webpack_require__(6220);
+
+var _isBot = __webpack_require__(1897);
+
+function buildCancellationError() {
+  return Object.assign(new Error('Route Cancelled'), {
+    cancelled: true
+  });
+}
+
+function matchesMiddleware(options) {
+  return _matchesMiddleware.apply(this, arguments);
+}
+
+function _matchesMiddleware() {
+  _matchesMiddleware = _async_to_generator(function* (options) {
+    const matchers = yield Promise.resolve(options.router.pageLoader.getMiddleware());
+    if (!matchers) return false;
+    const {
+      pathname: asPathname
+    } = (0, _parsePath).parsePath(options.asPath); // remove basePath first since path prefix has to be in the order of `/${basePath}/${locale}`
+
+    const cleanedAs = (0, _hasBasePath).hasBasePath(asPathname) ? (0, _removeBasePath).removeBasePath(asPathname) : asPathname;
+    const asWithBasePathAndLocale = (0, _addBasePath).addBasePath((0, _addLocale).addLocale(cleanedAs, options.locale)); // Check only path match on client. Matching "has" should be done on server
+    // where we can access more info such as headers, HttpOnly cookie, etc.
+
+    return matchers.some(m => new RegExp(m.regexp).test(asWithBasePathAndLocale));
+  });
+  return _matchesMiddleware.apply(this, arguments);
+}
+
+function stripOrigin(url) {
+  const origin = (0, _utils).getLocationOrigin();
+  return url.startsWith(origin) ? url.substring(origin.length) : url;
+}
+
+function omit(object, keys) {
+  const omitted = {};
+  Object.keys(object).forEach(key => {
+    if (!keys.includes(key)) {
+      omitted[key] = object[key];
+    }
+  });
+  return omitted;
+}
+
+function isLocalURL(url) {
+  // prevent a hydration mismatch on href for url with anchor refs
+  if (!(0, _utils).isAbsoluteUrl(url)) return true;
+
+  try {
+    // absolute urls can be local if they are on the same origin
+    const locationOrigin = (0, _utils).getLocationOrigin();
+    const resolved = new URL(url, locationOrigin);
+    return resolved.origin === locationOrigin && (0, _hasBasePath).hasBasePath(resolved.pathname);
+  } catch (_) {
+    return false;
+  }
+}
+
+function interpolateAs(route, asPathname, query) {
+  let interpolatedRoute = '';
+  const dynamicRegex = (0, _routeRegex).getRouteRegex(route);
+  const dynamicGroups = dynamicRegex.groups;
+  const dynamicMatches = // Try to match the dynamic route against the asPath
+  (asPathname !== route ? (0, _routeMatcher).getRouteMatcher(dynamicRegex)(asPathname) : '') || // Fall back to reading the values from the href
+  // TODO: should this take priority; also need to change in the router.
+  query;
+  interpolatedRoute = route;
+  const params = Object.keys(dynamicGroups);
+
+  if (!params.every(param => {
+    let value = dynamicMatches[param] || '';
+    const {
+      repeat,
+      optional
+    } = dynamicGroups[param]; // support single-level catch-all
+    // TODO: more robust handling for user-error (passing `/`)
+
+    let replaced = `[${repeat ? '...' : ''}${param}]`;
+
+    if (optional) {
+      replaced = `${!value ? '/' : ''}[${replaced}]`;
+    }
+
+    if (repeat && !Array.isArray(value)) value = [value];
+    return (optional || param in dynamicMatches) && ( // Interpolate group into data URL if present
+    interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map( // these values should be fully encoded instead of just
+    // path delimiter escaped since they are being inserted
+    // into the URL and we expect URL encoded segments
+    // when parsing dynamic route params
+    segment => encodeURIComponent(segment)).join('/') : encodeURIComponent(value)) || '/');
+  })) {
+    interpolatedRoute = '' // did not satisfy all requirements
+    ; // n.b. We ignore this error because we handle warning for this case in
+    // development in the `<Link>` component directly.
+  }
+
+  return {
+    params,
+    result: interpolatedRoute
+  };
+}
+
+function resolveHref(router, href, resolveAs) {
+  // we use a dummy base url for relative urls
+  let base;
+  let urlAsString = typeof href === 'string' ? href : (0, _formatUrl).formatWithValidation(href); // repeated slashes and backslashes in the URL are considered
+  // invalid and will never match a Next.js page/file
+
+  const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
+  const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+  const urlParts = urlAsStringNoProto.split('?');
+
+  if ((urlParts[0] || '').match(/(\/\/|\\)/)) {
+    console.error(`Invalid href passed to next/router: ${urlAsString}, repeated forward-slashes (//) or backslashes \\ are not valid in the href`);
+    const normalizedUrl = (0, _utils).normalizeRepeatedSlashes(urlAsStringNoProto);
+    urlAsString = (urlProtoMatch ? urlProtoMatch[0] : '') + normalizedUrl;
+  } // Return because it cannot be routed by the Next.js router
+
+
+  if (!isLocalURL(urlAsString)) {
+    return resolveAs ? [urlAsString] : urlAsString;
+  }
+
+  try {
+    base = new URL(urlAsString.startsWith('#') ? router.asPath : router.pathname, 'http://n');
+  } catch (_) {
+    // fallback to / for invalid asPath values e.g. //
+    base = new URL('/', 'http://n');
+  }
+
+  try {
+    const finalUrl = new URL(urlAsString, base);
+    finalUrl.pathname = (0, _normalizeTrailingSlash).normalizePathTrailingSlash(finalUrl.pathname);
+    let interpolatedAs = '';
+
+    if ((0, _isDynamic).isDynamicRoute(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
+      const query = (0, _querystring).searchParamsToUrlQuery(finalUrl.searchParams);
+      const {
+        result,
+        params
+      } = interpolateAs(finalUrl.pathname, finalUrl.pathname, query);
+
+      if (result) {
+        interpolatedAs = (0, _formatUrl).formatWithValidation({
+          pathname: result,
+          hash: finalUrl.hash,
+          query: omit(query, params)
+        });
+      }
+    } // if the origin didn't change, it means we received a relative href
+
+
+    const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+    return resolveAs ? [resolvedHref, interpolatedAs || resolvedHref] : resolvedHref;
+  } catch (_1) {
+    return resolveAs ? [urlAsString] : urlAsString;
+  }
+}
+
+function prepareUrlAs(router, url, as) {
+  // If url and as provided as an object representation,
+  // we'll format them into the string version here.
+  let [resolvedHref, resolvedAs] = resolveHref(router, url, true);
+  const origin = (0, _utils).getLocationOrigin();
+  const hrefHadOrigin = resolvedHref.startsWith(origin);
+  const asHadOrigin = resolvedAs && resolvedAs.startsWith(origin);
+  resolvedHref = stripOrigin(resolvedHref);
+  resolvedAs = resolvedAs ? stripOrigin(resolvedAs) : resolvedAs;
+  const preparedUrl = hrefHadOrigin ? resolvedHref : (0, _addBasePath).addBasePath(resolvedHref);
+  const preparedAs = as ? stripOrigin(resolveHref(router, as)) : resolvedAs || resolvedHref;
+  return {
+    url: preparedUrl,
+    as: asHadOrigin ? preparedAs : (0, _addBasePath).addBasePath(preparedAs)
+  };
+}
+
+function resolveDynamicRoute(pathname, pages) {
+  const cleanPathname = (0, _removeTrailingSlash).removeTrailingSlash((0, _denormalizePagePath).denormalizePagePath(pathname));
+
+  if (cleanPathname === '/404' || cleanPathname === '/_error') {
+    return pathname;
+  } // handle resolving href for dynamic routes
+
+
+  if (!pages.includes(cleanPathname)) {
+    // eslint-disable-next-line array-callback-return
+    pages.some(page => {
+      if ((0, _isDynamic).isDynamicRoute(page) && (0, _routeRegex).getRouteRegex(page).re.test(cleanPathname)) {
+        pathname = page;
+        return true;
+      }
+    });
+  }
+
+  return (0, _removeTrailingSlash).removeTrailingSlash(pathname);
+}
+
+function getMiddlewareData(source, response, options) {
+  const nextConfig = {
+    basePath: options.router.basePath,
+    i18n: {
+      locales: options.router.locales
+    },
+    trailingSlash: Boolean(false)
+  };
+  const rewriteHeader = response.headers.get('x-nextjs-rewrite');
+  let rewriteTarget = rewriteHeader || response.headers.get('x-nextjs-matched-path');
+  const matchedPath = response.headers.get('x-matched-path');
+
+  if (matchedPath && !rewriteTarget && !matchedPath.includes('__next_data_catchall') && !matchedPath.includes('/_error') && !matchedPath.includes('/404')) {
+    // leverage x-matched-path to detect next.config.js rewrites
+    rewriteTarget = matchedPath;
+  }
+
+  if (rewriteTarget) {
+    if (rewriteTarget.startsWith('/')) {
+      const parsedRewriteTarget = (0, _parseRelativeUrl).parseRelativeUrl(rewriteTarget);
+      const pathnameInfo = (0, _getNextPathnameInfo).getNextPathnameInfo(parsedRewriteTarget.pathname, {
+        nextConfig,
+        parseData: true
+      });
+      let fsPathname = (0, _removeTrailingSlash).removeTrailingSlash(pathnameInfo.pathname);
+      return Promise.all([options.router.pageLoader.getPageList(), (0, _routeLoader).getClientBuildManifest()]).then(([pages, {
+        __rewrites: rewrites
+      }]) => {
+        let as = (0, _addLocale).addLocale(pathnameInfo.pathname, pathnameInfo.locale);
+
+        if ((0, _isDynamic).isDynamicRoute(as) || !rewriteHeader && pages.includes((0, _normalizeLocalePath).normalizeLocalePath((0, _removeBasePath).removeBasePath(as), options.router.locales).pathname)) {
+          const parsedSource = (0, _getNextPathnameInfo).getNextPathnameInfo((0, _parseRelativeUrl).parseRelativeUrl(source).pathname, {
+            parseData: true
+          });
+          as = (0, _addBasePath).addBasePath(parsedSource.pathname);
+          parsedRewriteTarget.pathname = as;
+        }
+
+        if (false) {} else if (!pages.includes(fsPathname)) {
+          const resolvedPathname = resolveDynamicRoute(fsPathname, pages);
+
+          if (resolvedPathname !== fsPathname) {
+            fsPathname = resolvedPathname;
+          }
+        }
+
+        const resolvedHref = !pages.includes(fsPathname) ? resolveDynamicRoute((0, _normalizeLocalePath).normalizeLocalePath((0, _removeBasePath).removeBasePath(parsedRewriteTarget.pathname), options.router.locales).pathname, pages) : fsPathname;
+
+        if ((0, _isDynamic).isDynamicRoute(resolvedHref)) {
+          const matches = (0, _routeMatcher).getRouteMatcher((0, _routeRegex).getRouteRegex(resolvedHref))(as);
+          Object.assign(parsedRewriteTarget.query, matches || {});
+        }
+
+        return {
+          type: 'rewrite',
+          parsedAs: parsedRewriteTarget,
+          resolvedHref
+        };
+      });
+    }
+
+    const src = (0, _parsePath).parsePath(source);
+    const pathname = (0, _formatNextPathnameInfo).formatNextPathnameInfo(_extends({}, (0, _getNextPathnameInfo).getNextPathnameInfo(src.pathname, {
+      nextConfig,
+      parseData: true
+    }), {
+      defaultLocale: options.router.defaultLocale,
+      buildId: ''
+    }));
+    return Promise.resolve({
+      type: 'redirect-external',
+      destination: `${pathname}${src.query}${src.hash}`
+    });
+  }
+
+  const redirectTarget = response.headers.get('x-nextjs-redirect');
+
+  if (redirectTarget) {
+    if (redirectTarget.startsWith('/')) {
+      const src = (0, _parsePath).parsePath(redirectTarget);
+      const pathname = (0, _formatNextPathnameInfo).formatNextPathnameInfo(_extends({}, (0, _getNextPathnameInfo).getNextPathnameInfo(src.pathname, {
+        nextConfig,
+        parseData: true
+      }), {
+        defaultLocale: options.router.defaultLocale,
+        buildId: ''
+      }));
+      return Promise.resolve({
+        type: 'redirect-internal',
+        newAs: `${pathname}${src.query}${src.hash}`,
+        newUrl: `${pathname}${src.query}${src.hash}`
+      });
+    }
+
+    return Promise.resolve({
+      type: 'redirect-external',
+      destination: redirectTarget
+    });
+  }
+
+  return Promise.resolve({
+    type: 'next'
+  });
+}
+
+function withMiddlewareEffects(options) {
+  return matchesMiddleware(options).then(matches => {
+    if (matches && options.fetchData) {
+      return options.fetchData().then(data => getMiddlewareData(data.dataHref, data.response, options).then(effect => ({
+        dataHref: data.dataHref,
+        cacheKey: data.cacheKey,
+        json: data.json,
+        response: data.response,
+        text: data.text,
+        effect
+      }))).catch(_err => {
+        /**
+        * TODO: Revisit this in the future.
+        * For now we will not consider middleware data errors to be fatal.
+        * maybe we should revisit in the future.
+        */
+        return null;
+      });
+    }
+
+    return null;
+  });
+}
+
+const manualScrollRestoration = (/* unused pure expression or super */ null && ( false && 0));
+const SSG_DATA_NOT_FOUND = Symbol('SSG_DATA_NOT_FOUND');
+
+function fetchRetry(url, attempts, options) {
+  return fetch(url, {
+    // Cookies are required to be present for Next.js' SSG "Preview Mode".
+    // Cookies may also be required for `getServerSideProps`.
+    //
+    // > `fetch` won’t send cookies, unless you set the credentials init
+    // > option.
+    // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
+    //
+    // > For maximum browser compatibility when it comes to sending &
+    // > receiving cookies, always supply the `credentials: 'same-origin'`
+    // > option instead of relying on the default.
+    // https://github.com/github/fetch#caveats
+    credentials: 'same-origin',
+    method: options.method || 'GET',
+    headers: Object.assign({}, options.headers, {
+      'x-nextjs-data': '1'
+    })
+  }).then(response => {
+    return !response.ok && attempts > 1 && response.status >= 500 ? fetchRetry(url, attempts - 1, options) : response;
+  });
+}
+
+const backgroundCache = {};
+
+function handleSmoothScroll(fn) {
+  const htmlElement = document.documentElement;
+  const existing = htmlElement.style.scrollBehavior;
+  htmlElement.style.scrollBehavior = 'auto';
+  fn();
+  htmlElement.style.scrollBehavior = existing;
+}
+
+function tryToParseAsJSON(text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    return null;
+  }
+}
+
+function fetchNextData({
+  dataHref,
+  inflightCache,
+  isPrefetch,
+  hasMiddleware,
+  isServerRender,
+  parseJSON,
+  persistCache,
+  isBackground,
+  unstable_skipClientCache
+}) {
+  const {
+    href: cacheKey
+  } = new URL(dataHref, window.location.href);
+  var ref1;
+
+  const getData = params => {
+    return fetchRetry(dataHref, isServerRender ? 3 : 1, {
+      headers: isPrefetch ? {
+        purpose: 'prefetch'
+      } : {},
+      method: (ref1 = params == null ? void 0 : params.method) != null ? ref1 : 'GET'
+    }).then(response => {
+      if (response.ok && (params == null ? void 0 : params.method) === 'HEAD') {
+        return {
+          dataHref,
+          response,
+          text: '',
+          json: {},
+          cacheKey
+        };
+      }
+
+      return response.text().then(text => {
+        if (!response.ok) {
+          /**
+          * When the data response is a redirect because of a middleware
+          * we do not consider it an error. The headers must bring the
+          * mapped location.
+          * TODO: Change the status code in the handler.
+          */
+          if (hasMiddleware && [301, 302, 307, 308].includes(response.status)) {
+            return {
+              dataHref,
+              response,
+              text,
+              json: {},
+              cacheKey
+            };
+          }
+
+          if (!hasMiddleware && response.status === 404) {
+            var ref;
+
+            if ((ref = tryToParseAsJSON(text)) == null ? void 0 : ref.notFound) {
+              return {
+                dataHref,
+                json: {
+                  notFound: SSG_DATA_NOT_FOUND
+                },
+                response,
+                text,
+                cacheKey
+              };
+            }
+          }
+
+          const error = new Error(`Failed to load static props`);
+          /**
+          * We should only trigger a server-side transition if this was
+          * caused on a client-side transition. Otherwise, we'd get into
+          * an infinite loop.
+          */
+
+          if (!isServerRender) {
+            (0, _routeLoader).markAssetError(error);
+          }
+
+          throw error;
+        }
+
+        return {
+          dataHref,
+          json: parseJSON ? tryToParseAsJSON(text) : null,
+          response,
+          text,
+          cacheKey
+        };
+      });
+    }).then(data => {
+      if (!persistCache || false || data.response.headers.get('x-middleware-cache') === 'no-cache') {
+        delete inflightCache[cacheKey];
+      }
+
+      return data;
+    }).catch(err => {
+      delete inflightCache[cacheKey];
+      throw err;
+    });
+  }; // when skipping client cache we wait to update
+  // inflight cache until successful data response
+  // this allows racing click event with fetching newer data
+  // without blocking navigation when stale data is available
+
+
+  if (unstable_skipClientCache && persistCache) {
+    return getData({}).then(data => {
+      inflightCache[cacheKey] = Promise.resolve(data);
+      return data;
+    });
+  }
+
+  if (inflightCache[cacheKey] !== undefined) {
+    return inflightCache[cacheKey];
+  }
+
+  return inflightCache[cacheKey] = getData(isBackground ? {
+    method: 'HEAD'
+  } : {});
+}
+
+function createKey() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+function handleHardNavigation({
+  url,
+  router
+}) {
+  // ensure we don't trigger a hard navigation to the same
+  // URL as this can end up with an infinite refresh
+  if (url === (0, _addBasePath).addBasePath((0, _addLocale).addLocale(router.asPath, router.locale))) {
+    throw new Error(`Invariant: attempted to hard navigate to the same URL ${url} ${location.href}`);
+  }
+
+  window.location.href = url;
+}
+
+const getCancelledHandler = ({
+  route,
+  router
+}) => {
+  let cancelled = false;
+
+  const cancel = router.clc = () => {
+    cancelled = true;
+  };
+
+  const handleCancelled = () => {
+    if (cancelled) {
+      const error = new Error(`Abort fetching component for route: "${route}"`);
+      error.cancelled = true;
+      throw error;
+    }
+
+    if (cancel === router.clc) {
+      router.clc = null;
+    }
+  };
+
+  return handleCancelled;
+};
+
+class Router {
+  reload() {
+    window.location.reload();
+  }
+  /**
+  * Go back in history
+  */
+
+
+  back() {
+    window.history.back();
+  }
+  /**
+  * Performs a `pushState` with arguments
+  * @param url of the route
+  * @param as masks `url` for the browser
+  * @param options object you can define `shallow` and other options
+  */
+
+
+  push(url, as, options = {}) {
+    if (false) {}
+
+    ({
+      url,
+      as
+    } = prepareUrlAs(this, url, as));
+    return this.change('pushState', url, as, options);
+  }
+  /**
+  * Performs a `replaceState` with arguments
+  * @param url of the route
+  * @param as masks `url` for the browser
+  * @param options object you can define `shallow` and other options
+  */
+
+
+  replace(url, as, options = {}) {
+    ({
+      url,
+      as
+    } = prepareUrlAs(this, url, as));
+    return this.change('replaceState', url, as, options);
+  }
+
+  change(method, url, as, options, forcedScroll) {
+    var _this = this;
+
+    return _async_to_generator(function* () {
+      if (!isLocalURL(url)) {
+        handleHardNavigation({
+          url,
+          router: _this
+        });
+        return false;
+      } // WARNING: `_h` is an internal option for handing Next.js client-side
+      // hydration. Your app should _never_ use this property. It may change at
+      // any time without notice.
+
+
+      const isQueryUpdating = options._h;
+      const shouldResolveHref = isQueryUpdating || options._shouldResolveHref || (0, _parsePath).parsePath(url).pathname === (0, _parsePath).parsePath(as).pathname;
+
+      const nextState = _extends({}, _this.state); // for static pages with query params in the URL we delay
+      // marking the router ready until after the query is updated
+      // or a navigation has occurred
+
+
+      const readyStateChange = _this.isReady !== true;
+      _this.isReady = true;
+      const isSsr = _this.isSsr;
+
+      if (!isQueryUpdating) {
+        _this.isSsr = false;
+      } // if a route transition is already in progress before
+      // the query updating is triggered ignore query updating
+
+
+      if (isQueryUpdating && _this.clc) {
+        return false;
+      }
+
+      const prevLocale = nextState.locale;
+
+      if (true) {
+        nextState.locale = options.locale === false ? _this.defaultLocale : options.locale || nextState.locale;
+
+        if (typeof options.locale === 'undefined') {
+          options.locale = nextState.locale;
+        }
+
+        const parsedAs = (0, _parseRelativeUrl).parseRelativeUrl((0, _hasBasePath).hasBasePath(as) ? (0, _removeBasePath).removeBasePath(as) : as);
+        const localePathResult = (0, _normalizeLocalePath).normalizeLocalePath(parsedAs.pathname, _this.locales);
+
+        if (localePathResult.detectedLocale) {
+          nextState.locale = localePathResult.detectedLocale;
+          parsedAs.pathname = (0, _addBasePath).addBasePath(parsedAs.pathname);
+          as = (0, _formatUrl).formatWithValidation(parsedAs);
+          url = (0, _addBasePath).addBasePath((0, _normalizeLocalePath).normalizeLocalePath((0, _hasBasePath).hasBasePath(url) ? (0, _removeBasePath).removeBasePath(url) : url, _this.locales).pathname);
+        }
+
+        let didNavigate = false; // we need to wrap this in the env check again since regenerator runtime
+        // moves this on its own due to the return
+
+        if (true) {
+          var ref; // if the locale isn't configured hard navigate to show 404 page
+
+          if (!((ref = _this.locales) == null ? void 0 : ref.includes(nextState.locale))) {
+            parsedAs.pathname = (0, _addLocale).addLocale(parsedAs.pathname, nextState.locale);
+            handleHardNavigation({
+              url: (0, _formatUrl).formatWithValidation(parsedAs),
+              router: _this
+            }); // this was previously a return but was removed in favor
+            // of better dead code elimination with regenerator runtime
+
+            didNavigate = true;
+          }
+        }
+
+        const detectedDomain = (0, _detectDomainLocale).detectDomainLocale(_this.domainLocales, undefined, nextState.locale); // we need to wrap this in the env check again since regenerator runtime
+        // moves this on its own due to the return
+
+        if (true) {
+          // if we are navigating to a domain locale ensure we redirect to the
+          // correct domain
+          if (!didNavigate && detectedDomain && _this.isLocaleDomain && self.location.hostname !== detectedDomain.domain) {
+            const asNoBasePath = (0, _removeBasePath).removeBasePath(as);
+            handleHardNavigation({
+              url: `http${detectedDomain.http ? '' : 's'}://${detectedDomain.domain}${(0, _addBasePath).addBasePath(`${nextState.locale === detectedDomain.defaultLocale ? '' : `/${nextState.locale}`}${asNoBasePath === '/' ? '' : asNoBasePath}` || '/')}`,
+              router: _this
+            }); // this was previously a return but was removed in favor
+            // of better dead code elimination with regenerator runtime
+
+            didNavigate = true;
+          }
+        }
+
+        if (didNavigate) {
+          return new Promise(() => {});
+        }
+      } // marking route changes as a navigation start entry
+
+
+      if (_utils.ST) {
+        performance.mark('routeChange');
+      }
+
+      const {
+        shallow = false,
+        scroll = true
+      } = options;
+      const routeProps = {
+        shallow
+      };
+
+      if (_this._inFlightRoute && _this.clc) {
+        if (!isSsr) {
+          Router.events.emit('routeChangeError', buildCancellationError(), _this._inFlightRoute, routeProps);
+        }
+
+        _this.clc();
+
+        _this.clc = null;
+      }
+
+      as = (0, _addBasePath).addBasePath((0, _addLocale).addLocale((0, _hasBasePath).hasBasePath(as) ? (0, _removeBasePath).removeBasePath(as) : as, options.locale, _this.defaultLocale));
+      const cleanedAs = (0, _removeLocale).removeLocale((0, _hasBasePath).hasBasePath(as) ? (0, _removeBasePath).removeBasePath(as) : as, nextState.locale);
+      _this._inFlightRoute = as;
+      const localeChange = prevLocale !== nextState.locale; // If the url change is only related to a hash change
+      // We should not proceed. We should only change the state.
+
+      if (!isQueryUpdating && _this.onlyAHashChange(cleanedAs) && !localeChange) {
+        nextState.asPath = cleanedAs;
+        Router.events.emit('hashChangeStart', as, routeProps); // TODO: do we need the resolved href when only a hash change?
+
+        _this.changeState(method, url, as, _extends({}, options, {
+          scroll: false
+        }));
+
+        if (scroll) {
+          _this.scrollToHash(cleanedAs);
+        }
+
+        try {
+          yield _this.set(nextState, _this.components[nextState.route], null);
+        } catch (err) {
+          if ((0, _isError).default(err) && err.cancelled) {
+            Router.events.emit('routeChangeError', err, cleanedAs, routeProps);
+          }
+
+          throw err;
+        }
+
+        Router.events.emit('hashChangeComplete', as, routeProps);
+        return true;
+      }
+
+      let parsed = (0, _parseRelativeUrl).parseRelativeUrl(url);
+      let {
+        pathname,
+        query
+      } = parsed; // The build manifest needs to be loaded before auto-static dynamic pages
+      // get their query parameters to allow ensuring they can be parsed properly
+      // when rewritten to
+
+      let pages, rewrites;
+
+      try {
+        [pages, {
+          __rewrites: rewrites
+        }] = yield Promise.all([_this.pageLoader.getPageList(), (0, _routeLoader).getClientBuildManifest(), _this.pageLoader.getMiddleware()]);
+      } catch (err) {
+        // If we fail to resolve the page list or client-build manifest, we must
+        // do a server-side transition:
+        handleHardNavigation({
+          url: as,
+          router: _this
+        });
+        return false;
+      } // If asked to change the current URL we should reload the current page
+      // (not location.reload() but reload getInitialProps and other Next.js stuffs)
+      // We also need to set the method = replaceState always
+      // as this should not go into the history (That's how browsers work)
+      // We should compare the new asPath to the current asPath, not the url
+
+
+      if (!_this.urlIsNew(cleanedAs) && !localeChange) {
+        method = 'replaceState';
+      } // we need to resolve the as value using rewrites for dynamic SSG
+      // pages to allow building the data URL correctly
+
+
+      let resolvedAs = as; // url and as should always be prefixed with basePath by this
+      // point by either next/link or router.push/replace so strip the
+      // basePath from the pathname to match the pages dir 1-to-1
+
+      pathname = pathname ? (0, _removeTrailingSlash).removeTrailingSlash((0, _removeBasePath).removeBasePath(pathname)) : pathname; // we don't attempt resolve asPath when we need to execute
+      // middleware as the resolving will occur server-side
+
+      const isMiddlewareMatch = yield matchesMiddleware({
+        asPath: as,
+        locale: nextState.locale,
+        router: _this
+      });
+
+      if (options.shallow && isMiddlewareMatch) {
+        pathname = _this.pathname;
+      }
+
+      if (shouldResolveHref && pathname !== '/_error') {
+        options._shouldResolveHref = true;
+
+        if (false) {} else {
+          parsed.pathname = resolveDynamicRoute(pathname, pages);
+
+          if (parsed.pathname !== pathname) {
+            pathname = parsed.pathname;
+            parsed.pathname = (0, _addBasePath).addBasePath(pathname);
+
+            if (!isMiddlewareMatch) {
+              url = (0, _formatUrl).formatWithValidation(parsed);
+            }
+          }
+        }
+      }
+
+      if (!isLocalURL(as)) {
+        if (false) {}
+
+        handleHardNavigation({
+          url: as,
+          router: _this
+        });
+        return false;
+      }
+
+      resolvedAs = (0, _removeLocale).removeLocale((0, _removeBasePath).removeBasePath(resolvedAs), nextState.locale);
+      let route = (0, _removeTrailingSlash).removeTrailingSlash(pathname);
+      let routeMatch = false;
+
+      if ((0, _isDynamic).isDynamicRoute(route)) {
+        const parsedAs = (0, _parseRelativeUrl).parseRelativeUrl(resolvedAs);
+        const asPathname = parsedAs.pathname;
+        const routeRegex = (0, _routeRegex).getRouteRegex(route);
+        routeMatch = (0, _routeMatcher).getRouteMatcher(routeRegex)(asPathname);
+        const shouldInterpolate = route === asPathname;
+        const interpolatedAs = shouldInterpolate ? interpolateAs(route, asPathname, query) : {};
+
+        if (!routeMatch || shouldInterpolate && !interpolatedAs.result) {
+          const missingParams = Object.keys(routeRegex.groups).filter(param => !query[param]);
+
+          if (missingParams.length > 0 && !isMiddlewareMatch) {
+            if (false) {}
+
+            throw new Error((shouldInterpolate ? `The provided \`href\` (${url}) value is missing query values (${missingParams.join(', ')}) to be interpolated properly. ` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${route}). `) + `Read more: https://nextjs.org/docs/messages/${shouldInterpolate ? 'href-interpolation-failed' : 'incompatible-href-as'}`);
+          }
+        } else if (shouldInterpolate) {
+          as = (0, _formatUrl).formatWithValidation(Object.assign({}, parsedAs, {
+            pathname: interpolatedAs.result,
+            query: omit(query, interpolatedAs.params)
+          }));
+        } else {
+          // Merge params into `query`, overwriting any specified in search
+          Object.assign(query, routeMatch);
+        }
+      }
+
+      if (!isQueryUpdating) {
+        Router.events.emit('routeChangeStart', as, routeProps);
+      }
+
+      try {
+        var ref2, ref3;
+        let routeInfo = yield _this.getRouteInfo({
+          route,
+          pathname,
+          query,
+          as,
+          resolvedAs,
+          routeProps,
+          locale: nextState.locale,
+          isPreview: nextState.isPreview,
+          hasMiddleware: isMiddlewareMatch
+        });
+
+        if ('route' in routeInfo && isMiddlewareMatch) {
+          pathname = routeInfo.route || route;
+          route = pathname;
+
+          if (!routeProps.shallow) {
+            query = Object.assign({}, routeInfo.query || {}, query);
+          }
+
+          const cleanedParsedPathname = (0, _hasBasePath).hasBasePath(parsed.pathname) ? (0, _removeBasePath).removeBasePath(parsed.pathname) : parsed.pathname;
+
+          if (routeMatch && pathname !== cleanedParsedPathname) {
+            Object.keys(routeMatch).forEach(key => {
+              if (routeMatch && query[key] === routeMatch[key]) {
+                delete query[key];
+              }
+            });
+          }
+
+          if ((0, _isDynamic).isDynamicRoute(pathname)) {
+            const prefixedAs = !routeProps.shallow && routeInfo.resolvedAs ? routeInfo.resolvedAs : (0, _addBasePath).addBasePath((0, _addLocale).addLocale(new URL(as, location.href).pathname, nextState.locale), true);
+            let rewriteAs = prefixedAs;
+
+            if ((0, _hasBasePath).hasBasePath(rewriteAs)) {
+              rewriteAs = (0, _removeBasePath).removeBasePath(rewriteAs);
+            }
+
+            if (true) {
+              const localeResult = (0, _normalizeLocalePath).normalizeLocalePath(rewriteAs, _this.locales);
+              nextState.locale = localeResult.detectedLocale || nextState.locale;
+              rewriteAs = localeResult.pathname;
+            }
+
+            const routeRegex = (0, _routeRegex).getRouteRegex(pathname);
+            const curRouteMatch = (0, _routeMatcher).getRouteMatcher(routeRegex)(rewriteAs);
+
+            if (curRouteMatch) {
+              Object.assign(query, curRouteMatch);
+            }
+          }
+        } // If the routeInfo brings a redirect we simply apply it.
+
+
+        if ('type' in routeInfo) {
+          if (routeInfo.type === 'redirect-internal') {
+            return _this.change(method, routeInfo.newUrl, routeInfo.newAs, options);
+          } else {
+            handleHardNavigation({
+              url: routeInfo.destination,
+              router: _this
+            });
+            return new Promise(() => {});
+          }
+        }
+
+        let {
+          error,
+          props,
+          __N_SSG,
+          __N_SSP
+        } = routeInfo;
+        const component = routeInfo.Component;
+
+        if (component && component.unstable_scriptLoader) {
+          const scripts = [].concat(component.unstable_scriptLoader());
+          scripts.forEach(script => {
+            (0, _script).handleClientScriptLoad(script.props);
+          });
+        } // handle redirect on client-transition
+
+
+        if ((__N_SSG || __N_SSP) && props) {
+          if (props.pageProps && props.pageProps.__N_REDIRECT) {
+            // Use the destination from redirect without adding locale
+            options.locale = false;
+            const destination = props.pageProps.__N_REDIRECT; // check if destination is internal (resolves to a page) and attempt
+            // client-navigation if it is falling back to hard navigation if
+            // it's not
+
+            if (destination.startsWith('/') && props.pageProps.__N_REDIRECT_BASE_PATH !== false) {
+              const parsedHref = (0, _parseRelativeUrl).parseRelativeUrl(destination);
+              parsedHref.pathname = resolveDynamicRoute(parsedHref.pathname, pages);
+              const {
+                url: newUrl,
+                as: newAs
+              } = prepareUrlAs(_this, destination, destination);
+              return _this.change(method, newUrl, newAs, options);
+            }
+
+            handleHardNavigation({
+              url: destination,
+              router: _this
+            });
+            return new Promise(() => {});
+          }
+
+          nextState.isPreview = !!props.__N_PREVIEW; // handle SSG data 404
+
+          if (props.notFound === SSG_DATA_NOT_FOUND) {
+            let notFoundRoute;
+
+            try {
+              yield _this.fetchComponent('/404');
+              notFoundRoute = '/404';
+            } catch (_) {
+              notFoundRoute = '/_error';
+            }
+
+            routeInfo = yield _this.getRouteInfo({
+              route: notFoundRoute,
+              pathname: notFoundRoute,
+              query,
+              as,
+              resolvedAs,
+              routeProps: {
+                shallow: false
+              },
+              locale: nextState.locale,
+              isPreview: nextState.isPreview
+            });
+
+            if ('type' in routeInfo) {
+              throw new Error(`Unexpected middleware effect on /404`);
+            }
+          }
+        }
+
+        Router.events.emit('beforeHistoryChange', as, routeProps);
+
+        _this.changeState(method, url, as, options);
+
+        if (isQueryUpdating && pathname === '/_error' && ((ref2 = self.__NEXT_DATA__.props) == null ? void 0 : (ref3 = ref2.pageProps) == null ? void 0 : ref3.statusCode) === 500 && (props == null ? void 0 : props.pageProps)) {
+          // ensure statusCode is still correct for static 500 page
+          // when updating query information
+          props.pageProps.statusCode = 500;
+        }
+
+        var _route; // shallow routing is only allowed for same page URL changes.
+
+
+        const isValidShallowRoute = options.shallow && nextState.route === ((_route = routeInfo.route) != null ? _route : route);
+
+        var _scroll;
+
+        const shouldScroll = (_scroll = options.scroll) != null ? _scroll : !options._h && !isValidShallowRoute;
+        const resetScroll = shouldScroll ? {
+          x: 0,
+          y: 0
+        } : null; // the new state that the router gonna set
+
+        const upcomingRouterState = _extends({}, nextState, {
+          route,
+          pathname,
+          query,
+          asPath: cleanedAs,
+          isFallback: false
+        });
+
+        const upcomingScrollState = forcedScroll != null ? forcedScroll : resetScroll; // for query updates we can skip it if the state is unchanged and we don't
+        // need to scroll
+        // https://github.com/vercel/next.js/issues/37139
+
+        const canSkipUpdating = options._h && !upcomingScrollState && !readyStateChange && !localeChange && (0, _compareStates).compareRouterStates(upcomingRouterState, _this.state);
+
+        if (!canSkipUpdating) {
+          yield _this.set(upcomingRouterState, routeInfo, upcomingScrollState).catch(e => {
+            if (e.cancelled) error = error || e;else throw e;
+          });
+
+          if (error) {
+            if (!isQueryUpdating) {
+              Router.events.emit('routeChangeError', error, cleanedAs, routeProps);
+            }
+
+            throw error;
+          }
+
+          if (true) {
+            if (nextState.locale) {
+              document.documentElement.lang = nextState.locale;
+            }
+          }
+
+          if (!isQueryUpdating) {
+            Router.events.emit('routeChangeComplete', as, routeProps);
+          } // A hash mark # is the optional last part of a URL
+
+
+          const hashRegex = /#.+$/;
+
+          if (shouldScroll && hashRegex.test(as)) {
+            _this.scrollToHash(as);
+          }
+        }
+
+        return true;
+      } catch (err1) {
+        if ((0, _isError).default(err1) && err1.cancelled) {
+          return false;
+        }
+
+        throw err1;
+      }
+    })();
+  }
+
+  changeState(method, url, as, options = {}) {
+    if (false) {}
+
+    if (method !== 'pushState' || (0, _utils).getURL() !== as) {
+      this._shallow = options.shallow;
+      window.history[method]({
+        url,
+        as,
+        options,
+        __N: true,
+        key: this._key = method !== 'pushState' ? this._key : createKey()
+      }, // Most browsers currently ignores this parameter, although they may use it in the future.
+      // Passing the empty string here should be safe against future changes to the method.
+      // https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState
+      '', as);
+    }
+  }
+
+  handleRouteInfoError(err, pathname, query, as, routeProps, loadErrorFail) {
+    var _this = this;
+
+    return _async_to_generator(function* () {
+      console.error(err);
+
+      if (err.cancelled) {
+        // bubble up cancellation errors
+        throw err;
+      }
+
+      if ((0, _routeLoader).isAssetError(err) || loadErrorFail) {
+        Router.events.emit('routeChangeError', err, as, routeProps); // If we can't load the page it could be one of following reasons
+        //  1. Page doesn't exists
+        //  2. Page does exist in a different zone
+        //  3. Internal error while loading the page
+        // So, doing a hard reload is the proper way to deal with this.
+
+        handleHardNavigation({
+          url: as,
+          router: _this
+        }); // Changing the URL doesn't block executing the current code path.
+        // So let's throw a cancellation error stop the routing logic.
+
+        throw buildCancellationError();
+      }
+
+      try {
+        let props;
+        const {
+          page: Component,
+          styleSheets
+        } = yield _this.fetchComponent('/_error');
+        const routeInfo = {
+          props,
+          Component,
+          styleSheets,
+          err,
+          error: err
+        };
+
+        if (!routeInfo.props) {
+          try {
+            routeInfo.props = yield _this.getInitialProps(Component, {
+              err,
+              pathname,
+              query
+            });
+          } catch (gipErr) {
+            console.error('Error in error page `getInitialProps`: ', gipErr);
+            routeInfo.props = {};
+          }
+        }
+
+        return routeInfo;
+      } catch (routeInfoErr) {
+        return _this.handleRouteInfoError((0, _isError).default(routeInfoErr) ? routeInfoErr : new Error(routeInfoErr + ''), pathname, query, as, routeProps, true);
+      }
+    })();
+  }
+
+  getRouteInfo({
+    route: requestedRoute,
+    pathname,
+    query,
+    as,
+    resolvedAs,
+    routeProps,
+    locale,
+    hasMiddleware,
+    isPreview,
+    unstable_skipClientCache
+  }) {
+    var _this = this;
+
+    return _async_to_generator(function* () {
+      /**
+      * This `route` binding can change if there's a rewrite
+      * so we keep a reference to the original requested route
+      * so we can store the cache for it and avoid re-requesting every time
+      * for shallow routing purposes.
+      */
+      let route = requestedRoute;
+
+      try {
+        var ref, ref4, ref5;
+        const handleCancelled = getCancelledHandler({
+          route,
+          router: _this
+        });
+        let existingInfo = _this.components[route];
+
+        if (routeProps.shallow && existingInfo && _this.route === route) {
+          return existingInfo;
+        }
+
+        if (hasMiddleware) {
+          existingInfo = undefined;
+        }
+
+        let cachedRouteInfo = existingInfo && !('initial' in existingInfo) && true ? existingInfo : undefined;
+        const fetchNextDataParams = {
+          dataHref: _this.pageLoader.getDataHref({
+            href: (0, _formatUrl).formatWithValidation({
+              pathname,
+              query
+            }),
+            skipInterpolation: true,
+            asPath: resolvedAs,
+            locale
+          }),
+          hasMiddleware: true,
+          isServerRender: _this.isSsr,
+          parseJSON: true,
+          inflightCache: _this.sdc,
+          persistCache: !isPreview,
+          isPrefetch: false,
+          unstable_skipClientCache
+        };
+        const data = yield withMiddlewareEffects({
+          fetchData: () => fetchNextData(fetchNextDataParams),
+          asPath: resolvedAs,
+          locale: locale,
+          router: _this
+        });
+        handleCancelled();
+
+        if ((data == null ? void 0 : (ref = data.effect) == null ? void 0 : ref.type) === 'redirect-internal' || (data == null ? void 0 : (ref4 = data.effect) == null ? void 0 : ref4.type) === 'redirect-external') {
+          return data.effect;
+        }
+
+        if ((data == null ? void 0 : (ref5 = data.effect) == null ? void 0 : ref5.type) === 'rewrite') {
+          route = (0, _removeTrailingSlash).removeTrailingSlash(data.effect.resolvedHref);
+          pathname = data.effect.resolvedHref;
+          query = _extends({}, query, data.effect.parsedAs.query);
+          resolvedAs = (0, _removeBasePath).removeBasePath((0, _normalizeLocalePath).normalizeLocalePath(data.effect.parsedAs.pathname, _this.locales).pathname); // Check again the cache with the new destination.
+
+          existingInfo = _this.components[route];
+
+          if (routeProps.shallow && existingInfo && _this.route === route && !hasMiddleware) {
+            // If we have a match with the current route due to rewrite,
+            // we can copy the existing information to the rewritten one.
+            // Then, we return the information along with the matched route.
+            return _extends({}, existingInfo, {
+              route
+            });
+          }
+        }
+
+        if (route === '/api' || route.startsWith('/api/')) {
+          handleHardNavigation({
+            url: as,
+            router: _this
+          });
+          return new Promise(() => {});
+        }
+
+        const routeInfo = cachedRouteInfo || (yield _this.fetchComponent(route).then(res => ({
+          Component: res.page,
+          styleSheets: res.styleSheets,
+          __N_SSG: res.mod.__N_SSG,
+          __N_SSP: res.mod.__N_SSP
+        })));
+
+        if (false) {}
+
+        const shouldFetchData = routeInfo.__N_SSG || routeInfo.__N_SSP;
+        const {
+          props,
+          cacheKey
+        } = yield _this._getData(_async_to_generator(function* () {
+          if (shouldFetchData) {
+            const {
+              json,
+              cacheKey: _cacheKey
+            } = (data == null ? void 0 : data.json) ? data : yield fetchNextData({
+              dataHref: _this.pageLoader.getDataHref({
+                href: (0, _formatUrl).formatWithValidation({
+                  pathname,
+                  query
+                }),
+                asPath: resolvedAs,
+                locale
+              }),
+              isServerRender: _this.isSsr,
+              parseJSON: true,
+              inflightCache: _this.sdc,
+              persistCache: !isPreview,
+              isPrefetch: false,
+              unstable_skipClientCache
+            });
+            return {
+              cacheKey: _cacheKey,
+              props: json || {}
+            };
+          }
+
+          return {
+            headers: {},
+            cacheKey: '',
+            props: yield _this.getInitialProps(routeInfo.Component, // we provide AppTree later so this needs to be `any`
+            {
+              pathname,
+              query,
+              asPath: as,
+              locale,
+              locales: _this.locales,
+              defaultLocale: _this.defaultLocale
+            })
+          };
+        })); // Only bust the data cache for SSP routes although
+        // middleware can skip cache per request with
+        // x-middleware-cache: no-cache as well
+
+        if (routeInfo.__N_SSP && fetchNextDataParams.dataHref) {
+          delete _this.sdc[cacheKey];
+        } // we kick off a HEAD request in the background
+        // when a non-prefetch request is made to signal revalidation
+
+
+        if (!_this.isPreview && routeInfo.__N_SSG && true) {
+          fetchNextData(Object.assign({}, fetchNextDataParams, {
+            isBackground: true,
+            persistCache: false,
+            inflightCache: backgroundCache
+          })).catch(() => {});
+        }
+
+        props.pageProps = Object.assign({}, props.pageProps);
+        routeInfo.props = props;
+        routeInfo.route = route;
+        routeInfo.query = query;
+        routeInfo.resolvedAs = resolvedAs;
+        _this.components[route] = routeInfo;
+        return routeInfo;
+      } catch (err) {
+        return _this.handleRouteInfoError((0, _isError).getProperError(err), pathname, query, as, routeProps);
+      }
+    })();
+  }
+
+  set(state, data, resetScroll) {
+    this.state = state;
+    return this.sub(data, this.components['/_app'].Component, resetScroll);
+  }
+  /**
+  * Callback to execute before replacing router state
+  * @param cb callback to be executed
+  */
+
+
+  beforePopState(cb) {
+    this._bps = cb;
+  }
+
+  onlyAHashChange(as) {
+    if (!this.asPath) return false;
+    const [oldUrlNoHash, oldHash] = this.asPath.split('#');
+    const [newUrlNoHash, newHash] = as.split('#'); // Makes sure we scroll to the provided hash if the url/hash are the same
+
+    if (newHash && oldUrlNoHash === newUrlNoHash && oldHash === newHash) {
+      return true;
+    } // If the urls are change, there's more than a hash change
+
+
+    if (oldUrlNoHash !== newUrlNoHash) {
+      return false;
+    } // If the hash has changed, then it's a hash only change.
+    // This check is necessary to handle both the enter and
+    // leave hash === '' cases. The identity case falls through
+    // and is treated as a next reload.
+
+
+    return oldHash !== newHash;
+  }
+
+  scrollToHash(as) {
+    const [, hash = ''] = as.split('#'); // Scroll to top if the hash is just `#` with no value or `#top`
+    // To mirror browsers
+
+    if (hash === '' || hash === 'top') {
+      handleSmoothScroll(() => window.scrollTo(0, 0));
+      return;
+    } // Decode hash to make non-latin anchor works.
+
+
+    const rawHash = decodeURIComponent(hash); // First we check if the element by id is found
+
+    const idEl = document.getElementById(rawHash);
+
+    if (idEl) {
+      handleSmoothScroll(() => idEl.scrollIntoView());
+      return;
+    } // If there's no element with the id, we check the `name` property
+    // To mirror browsers
+
+
+    const nameEl = document.getElementsByName(rawHash)[0];
+
+    if (nameEl) {
+      handleSmoothScroll(() => nameEl.scrollIntoView());
+    }
+  }
+
+  urlIsNew(asPath) {
+    return this.asPath !== asPath;
+  }
+  /**
+  * Prefetch page code, you may wait for the data during page rendering.
+  * This feature only works in production!
+  * @param url the href of prefetched page
+  * @param asPath the as path of the prefetched page
+  */
+
+
+  prefetch(url, asPath = url, options = {}) {
+    var _this = this;
+
+    return _async_to_generator(function* () {
+      if (false) {}
+
+      let parsed = (0, _parseRelativeUrl).parseRelativeUrl(url);
+      let {
+        pathname,
+        query
+      } = parsed;
+
+      if (true) {
+        if (options.locale === false) {
+          pathname = (0, _normalizeLocalePath).normalizeLocalePath(pathname, _this.locales).pathname;
+          parsed.pathname = pathname;
+          url = (0, _formatUrl).formatWithValidation(parsed);
+          let parsedAs = (0, _parseRelativeUrl).parseRelativeUrl(asPath);
+          const localePathResult = (0, _normalizeLocalePath).normalizeLocalePath(parsedAs.pathname, _this.locales);
+          parsedAs.pathname = localePathResult.pathname;
+          options.locale = localePathResult.detectedLocale || _this.defaultLocale;
+          asPath = (0, _formatUrl).formatWithValidation(parsedAs);
+        }
+      }
+
+      const pages = yield _this.pageLoader.getPageList();
+      let resolvedAs = asPath;
+      const locale = typeof options.locale !== 'undefined' ? options.locale || undefined : _this.locale;
+
+      if (false) {}
+
+      parsed.pathname = resolveDynamicRoute(parsed.pathname, pages);
+
+      if ((0, _isDynamic).isDynamicRoute(parsed.pathname)) {
+        pathname = parsed.pathname;
+        parsed.pathname = pathname;
+        Object.assign(query, (0, _routeMatcher).getRouteMatcher((0, _routeRegex).getRouteRegex(parsed.pathname))((0, _parsePath).parsePath(asPath).pathname) || {});
+        url = (0, _formatUrl).formatWithValidation(parsed);
+      } // Prefetch is not supported in development mode because it would trigger on-demand-entries
+
+
+      if (false) {}
+
+      const route = (0, _removeTrailingSlash).removeTrailingSlash(pathname);
+      yield Promise.all([_this.pageLoader._isSsg(route).then(isSsg => {
+        return isSsg ? fetchNextData({
+          dataHref: _this.pageLoader.getDataHref({
+            href: url,
+            asPath: resolvedAs,
+            locale: locale
+          }),
+          isServerRender: false,
+          parseJSON: true,
+          inflightCache: _this.sdc,
+          persistCache: !_this.isPreview,
+          isPrefetch: true,
+          unstable_skipClientCache: options.unstable_skipClientCache || options.priority && !!true
+        }).then(() => false) : false;
+      }), _this.pageLoader[options.priority ? 'loadPage' : 'prefetch'](route)]);
+    })();
+  }
+
+  fetchComponent(route) {
+    var _this = this;
+
+    return _async_to_generator(function* () {
+      const handleCancelled = getCancelledHandler({
+        route,
+        router: _this
+      });
+
+      try {
+        const componentResult = yield _this.pageLoader.loadPage(route);
+        handleCancelled();
+        return componentResult;
+      } catch (err) {
+        handleCancelled();
+        throw err;
+      }
+    })();
+  }
+
+  _getData(fn) {
+    let cancelled = false;
+
+    const cancel = () => {
+      cancelled = true;
+    };
+
+    this.clc = cancel;
+    return fn().then(data => {
+      if (cancel === this.clc) {
+        this.clc = null;
+      }
+
+      if (cancelled) {
+        const err = new Error('Loading initial props cancelled');
+        err.cancelled = true;
+        throw err;
+      }
+
+      return data;
+    });
+  }
+
+  _getFlightData(dataHref) {
+    // Do not cache RSC flight response since it's not a static resource
+    return fetchNextData({
+      dataHref,
+      isServerRender: true,
+      parseJSON: false,
+      inflightCache: this.sdc,
+      persistCache: false,
+      isPrefetch: false
+    }).then(({
+      text
+    }) => ({
+      data: text
+    }));
+  }
+
+  getInitialProps(Component, ctx) {
+    const {
+      Component: App
+    } = this.components['/_app'];
+
+    const AppTree = this._wrapApp(App);
+
+    ctx.AppTree = AppTree;
+    return (0, _utils).loadGetInitialProps(App, {
+      AppTree,
+      Component,
+      router: this,
+      ctx
+    });
+  }
+
+  get route() {
+    return this.state.route;
+  }
+
+  get pathname() {
+    return this.state.pathname;
+  }
+
+  get query() {
+    return this.state.query;
+  }
+
+  get asPath() {
+    return this.state.asPath;
+  }
+
+  get locale() {
+    return this.state.locale;
+  }
+
+  get isFallback() {
+    return this.state.isFallback;
+  }
+
+  get isPreview() {
+    return this.state.isPreview;
+  }
+
+  constructor(pathname1, query1, as1, {
+    initialProps,
+    pageLoader,
+    App,
+    wrapApp,
+    Component,
+    err,
+    subscription,
+    isFallback,
+    locale,
+    locales,
+    defaultLocale,
+    domainLocales,
+    isPreview
+  }) {
+    // Server Data Cache
+    this.sdc = {};
+    this.isFirstPopStateEvent = true;
+    this._key = createKey();
+
+    this.onPopState = e => {
+      const {
+        isFirstPopStateEvent
+      } = this;
+      this.isFirstPopStateEvent = false;
+      const state = e.state;
+
+      if (!state) {
+        // We get state as undefined for two reasons.
+        //  1. With older safari (< 8) and older chrome (< 34)
+        //  2. When the URL changed with #
+        //
+        // In the both cases, we don't need to proceed and change the route.
+        // (as it's already changed)
+        // But we can simply replace the state with the new changes.
+        // Actually, for (1) we don't need to nothing. But it's hard to detect that event.
+        // So, doing the following for (1) does no harm.
+        const {
+          pathname,
+          query
+        } = this;
+        this.changeState('replaceState', (0, _formatUrl).formatWithValidation({
+          pathname: (0, _addBasePath).addBasePath(pathname),
+          query
+        }), (0, _utils).getURL());
+        return;
+      } // __NA is used to identify if the history entry can be handled by the app-router.
+
+
+      if (state.__NA) {
+        window.location.reload();
+        return;
+      }
+
+      if (!state.__N) {
+        return;
+      } // Safari fires popstateevent when reopening the browser.
+
+
+      if (isFirstPopStateEvent && this.locale === state.options.locale && state.as === this.asPath) {
+        return;
+      }
+
+      let forcedScroll;
+      const {
+        url,
+        as,
+        options,
+        key
+      } = state;
+
+      if (false) {}
+
+      this._key = key;
+      const {
+        pathname
+      } = (0, _parseRelativeUrl).parseRelativeUrl(url); // Make sure we don't re-render on initial load,
+      // can be caused by navigating back from an external site
+
+      if (this.isSsr && as === (0, _addBasePath).addBasePath(this.asPath) && pathname === (0, _addBasePath).addBasePath(this.pathname)) {
+        return;
+      } // If the downstream application returns falsy, return.
+      // They will then be responsible for handling the event.
+
+
+      if (this._bps && !this._bps(state)) {
+        return;
+      }
+
+      this.change('replaceState', url, as, Object.assign({}, options, {
+        shallow: options.shallow && this._shallow,
+        locale: options.locale || this.defaultLocale,
+        // @ts-ignore internal value not exposed on types
+        _h: 0
+      }), forcedScroll);
+    }; // represents the current component key
+
+
+    const route = (0, _removeTrailingSlash).removeTrailingSlash(pathname1); // set up the component cache (by route keys)
+
+    this.components = {}; // We should not keep the cache, if there's an error
+    // Otherwise, this cause issues when when going back and
+    // come again to the errored page.
+
+    if (pathname1 !== '/_error') {
+      this.components[route] = {
+        Component,
+        initial: true,
+        props: initialProps,
+        err,
+        __N_SSG: initialProps && initialProps.__N_SSG,
+        __N_SSP: initialProps && initialProps.__N_SSP
+      };
+    }
+
+    this.components['/_app'] = {
+      Component: App,
+      styleSheets: []
+    }; // Backwards compat for Router.router.events
+    // TODO: Should be remove the following major version as it was never documented
+
+    this.events = Router.events;
+    this.pageLoader = pageLoader; // if auto prerendered and dynamic route wait to update asPath
+    // until after mount to prevent hydration mismatch
+
+    const autoExportDynamic = (0, _isDynamic).isDynamicRoute(pathname1) && self.__NEXT_DATA__.autoExport;
+
+    this.basePath =  false || '';
+    this.sub = subscription;
+    this.clc = null;
+    this._wrapApp = wrapApp; // make sure to ignore extra popState in safari on navigating
+    // back from external site
+
+    this.isSsr = true;
+    this.isLocaleDomain = false;
+    this.isReady = !!(self.__NEXT_DATA__.gssp || self.__NEXT_DATA__.gip || self.__NEXT_DATA__.appGip && !self.__NEXT_DATA__.gsp || !autoExportDynamic && !self.location.search && !false);
+
+    if (true) {
+      this.locales = locales;
+      this.defaultLocale = defaultLocale;
+      this.domainLocales = domainLocales;
+      this.isLocaleDomain = !!(0, _detectDomainLocale).detectDomainLocale(domainLocales, self.location.hostname);
+    }
+
+    this.state = {
+      route,
+      pathname: pathname1,
+      query: query1,
+      asPath: autoExportDynamic ? pathname1 : as1,
+      isPreview: !!isPreview,
+      locale:  true ? locale : 0,
+      isFallback
+    };
+    this._initialMatchesMiddlewarePromise = Promise.resolve(false);
+
+    if (false) {}
+  }
+
+}
+
+Router.events = (0, _mitt).default();
+exports["default"] = Router;
+
+/***/ }),
+
+/***/ 1664:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(7942)
+
+
+/***/ })
+
+};
+;