twins-diff 0.1.4

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

@@ -0,0 +1,2356 @@
+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);
+    }
+}
+
+
+/***/ }),
+
+/***/ 2648:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+var __webpack_unused_export__;
+
+__webpack_unused_export__ = ({
+    value: true
+});
+exports.Z = _interopRequireDefault;
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+
+
+/***/ }),
+
+/***/ 8684:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.addBasePath = addBasePath;
+var _addPathPrefix = __webpack_require__(1751);
+var _normalizeTrailingSlash = __webpack_require__(2392);
+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;
+} //# sourceMappingURL=add-base-path.js.map
+
+
+/***/ }),
+
+/***/ 2725:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.addLocale = void 0;
+var _normalizeTrailingSlash = __webpack_require__(2392);
+const addLocale = (path, ...args)=>{
+    if (false) {}
+    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;
+} //# sourceMappingURL=add-locale.js.map
+
+
+/***/ }),
+
+/***/ 8748:
+/***/ ((module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.detectDomainLocale = void 0;
+const detectDomainLocale = (...args)=>{
+    if (false) {}
+};
+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;
+} //# sourceMappingURL=detect-domain-locale.js.map
+
+
+/***/ }),
+
+/***/ 1210:
+/***/ ((module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.getDomainLocale = getDomainLocale;
+const basePath = (/* unused pure expression or super */ null && ( false || ""));
+function getDomainLocale(path, locale, locales, domainLocales) {
+    if (false) {} else {
+        return false;
+    }
+}
+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;
+} //# sourceMappingURL=get-domain-locale.js.map
+
+
+/***/ }),
+
+/***/ 4119:
+/***/ ((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;
+} //# sourceMappingURL=has-base-path.js.map
+
+
+/***/ }),
+
+/***/ 8418:
+/***/ ((module, exports, __webpack_require__) => {
+
+"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__(6273);
+var _addLocale = __webpack_require__(2725);
+var _routerContext = __webpack_require__(4964);
+var _appRouterContext = __webpack_require__(3280);
+var _useIntersection = __webpack_require__(7190);
+var _getDomainLocale = __webpack_require__(1210);
+var _addBasePath = __webpack_require__(8684);
+// @ts-ignore useTransition exist
+const hasUseTransition = typeof _react.default.useTransition !== "undefined";
+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
+    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, soft, shallow, scroll, locale, startTransition) {
+    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 AppRouterInstance, then it'll have `softPush` and
+        // `softReplace`.
+        if ("softPush" in router && "softReplace" in router) {
+            // If we're doing a soft navigation, use the soft variants of
+            // replace/push.
+            const method = soft ? replace ? "softReplace" : "softPush" : replace ? "replace" : "push";
+            router[method](href);
+        } else {
+            router[replace ? "replace" : "push"](href, as, {
+                shallow,
+                locale,
+                scroll
+            });
+        }
+    };
+    if (startTransition) {
+        startTransition(navigate);
+    } else {
+        navigate();
+    }
+}
+const Link = /*#__PURE__*/ _react.default.forwardRef(function LinkComponent(props, forwardedRef) {
+    if (false) {}
+    let children;
+    const { href: hrefProp , as: asProp , children: childrenProp , prefetch: prefetchProp , passHref , replace , soft , shallow , scroll , locale , onClick , onMouseEnter , onTouchStart , legacyBehavior =Boolean(false) !== true  } = props, restProps = _object_without_properties_loose(props, [
+        "href",
+        "as",
+        "children",
+        "prefetch",
+        "passHref",
+        "replace",
+        "soft",
+        "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;
+    const [, /* isPending */ startTransition] = hasUseTransition ? // @ts-ignore useTransition exists
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    _react.default.useTransition() : [];
+    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, soft, shallow, scroll, locale, appRouter ? startTransition : undefined);
+            }
+        },
+        onMouseEnter: (e)=>{
+            if (!legacyBehavior && typeof onMouseEnter === "function") {
+                onMouseEnter(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") {
+                child.props.onMouseEnter(e);
+            }
+            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);
+            }
+            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;
+} //# sourceMappingURL=link.js.map
+
+
+/***/ }),
+
+/***/ 2392:
+/***/ ((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("/")) {
+        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;
+} //# sourceMappingURL=normalize-trailing-slash.js.map
+
+
+/***/ }),
+
+/***/ 9320:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.removeBasePath = removeBasePath;
+var _hasBasePath = __webpack_require__(4119);
+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;
+} //# sourceMappingURL=remove-base-path.js.map
+
+
+/***/ }),
+
+/***/ 5776:
+/***/ ((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 (false) {}
+    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;
+} //# sourceMappingURL=remove-locale.js.map
+
+
+/***/ }),
+
+/***/ 2669:
+/***/ ((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__(4991);
+var _requestIdleCallback = __webpack_require__(9311);
+// 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(// 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((exports1)=>({
+                    component: exports1 && exports1.default || exports1,
+                    exports: exports1
+                }), (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(()=>{});
+        }
+    };
+}
+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;
+} //# sourceMappingURL=route-loader.js.map
+
+
+/***/ }),
+
+/***/ 4991:
+/***/ ((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" && "undefined" !== "undefined") { 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;
+} //# sourceMappingURL=trusted-types.js.map
+
+
+/***/ }),
+
+/***/ 7190:
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+exports.useIntersection = useIntersection;
+var _react = __webpack_require__(6689);
+var _requestIdleCallback = __webpack_require__(9311);
+const hasIntersectionObserver = typeof IntersectionObserver === "function";
+function useIntersection({ rootRef , rootMargin , disabled  }) {
+    const isDisabled = disabled || !hasIntersectionObserver;
+    const unobserve = (0, _react).useRef();
+    const [visible, setVisible] = (0, _react).useState(false);
+    const [element, setElement] = (0, _react).useState(null);
+    (0, _react).useEffect(()=>{
+        if (hasIntersectionObserver) {
+            if (unobserve.current) {
+                unobserve.current();
+                unobserve.current = undefined;
+            }
+            if (isDisabled || visible) return;
+            if (element && element.tagName) {
+                unobserve.current = observe(element, (isVisible)=>isVisible && setVisible(isVisible), {
+                    root: rootRef == null ? void 0 : rootRef.current,
+                    rootMargin
+                });
+            }
+            return ()=>{
+                unobserve.current == null ? void 0 : unobserve.current();
+                unobserve.current = undefined;
+            };
+        } 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
+    ];
+}
+const observers = new Map();
+const idList = [];
+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 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;
+}
+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;
+} //# sourceMappingURL=use-intersection.js.map
+
+
+/***/ }),
+
+/***/ 6273:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+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__(2392);
+var _removeTrailingSlash = __webpack_require__(3297);
+var _routeLoader = __webpack_require__(2669);
+var _script = __webpack_require__(699);
+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__(8748);
+var _parsePath = __webpack_require__(8854);
+var _addLocale = __webpack_require__(2725);
+var _removeLocale = __webpack_require__(5776);
+var _removeBasePath = __webpack_require__(9320);
+var _addBasePath = __webpack_require__(8684);
+var _hasBasePath = __webpack_require__(4119);
+var _getNextPathnameInfo = __webpack_require__(5789);
+var _formatNextPathnameInfo = __webpack_require__(299);
+var _compareStates = __webpack_require__(6220);
+function buildCancellationError() {
+    return Object.assign(new Error("Route Cancelled"), {
+        cancelled: true
+    });
+}
+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 = (asPathname !== route ? (0, _routeMatcher).getRouteMatcher(dynamicRegex)(asPathname) : "") || // 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) && (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// 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 omit(object, keys) {
+    const omitted = {};
+    Object.keys(object).forEach((key)=>{
+        if (!keys.includes(key)) {
+            omitted[key] = object[key];
+        }
+    });
+    return omitted;
+}
+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 stripOrigin(url) {
+    const origin = (0, _utils).getLocationOrigin();
+    return url.startsWith(origin) ? url.substring(origin.length) : url;
+}
+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);
+}
+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 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: {}
+                };
+            }
+            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: {}
+                        };
+                    }
+                    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
+                            };
+                        }
+                    }
+                    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
+                };
+            });
+        }).then((data)=>{
+            if (!persistCache || "production" !== "production" || 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 tryToParseAsJSON(text) {
+    try {
+        return JSON.parse(text);
+    } catch (error) {
+        return null;
+    }
+}
+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 (false) { var ref; }
+            // 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 (err1) {
+                // 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 parsedAs1 = (0, _parseRelativeUrl).parseRelativeUrl(resolvedAs);
+                const asPathname = parsedAs1.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({}, parsedAs1, {
+                        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);
+                    }
+                    if (routeMatch && pathname !== parsed.pathname) {
+                        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 (false) {}
+                        const routeRegex1 = (0, _routeRegex).getRouteRegex(pathname);
+                        const curRouteMatch = (0, _routeMatcher).getRouteMatcher(routeRegex1)(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 (false) {}
+                    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 (err11) {
+                if ((0, _isError).default(err11) && err11.cancelled) {
+                    return false;
+                }
+                throw err11;
+            }
+        })();
+    }
+    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()
+            }, // 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) && "production" !== "development" ? 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,
+                        __N_RSC: !!res.mod.__next_rsc__
+                    })));
+                if (false) {}
+                /**
+       * For server components, non-SSR pages will have statically optimized
+       * flight data in a production build. So only development and SSR pages
+       * will always have the real-time generated and streamed flight data.
+       */ const useStreamedFlightData = routeInfo.__N_RSC && ( false || routeInfo.__N_SSP);
+                const shouldFetchData = routeInfo.__N_SSG || routeInfo.__N_SSP || routeInfo.__N_RSC;
+                const { props  } = yield _this._getData(_async_to_generator(function*() {
+                    if (shouldFetchData && !useStreamedFlightData) {
+                        const { json  } = (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 {
+                            props: json || {}
+                        };
+                    }
+                    return {
+                        headers: {},
+                        props: yield _this.getInitialProps(routeInfo.Component, {
+                            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) {
+                    const cacheKey = new URL(fetchNextDataParams.dataHref, window.location.href).href;
+                    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 && "production" !== "development") {
+                    fetchNextData(Object.assign({}, fetchNextDataParams, {
+                        isBackground: true,
+                        persistCache: false,
+                        inflightCache: backgroundCache
+                    })).catch(()=>{});
+                }
+                let flightInfo;
+                if (routeInfo.__N_RSC) {
+                    flightInfo = {
+                        __flight__: useStreamedFlightData ? (yield _this._getData(()=>_this._getFlightData((0, _formatUrl).formatWithValidation({
+                                query: _extends({}, query, {
+                                    __flight__: "1"
+                                }),
+                                pathname: (0, _isDynamic).isDynamicRoute(route) ? interpolateAs(pathname, (0, _parseRelativeUrl).parseRelativeUrl(resolvedAs).pathname, query).result : pathname
+                            })))).data : props.__flight__
+                    };
+                }
+                props.pageProps = Object.assign({}, props.pageProps, flightInfo);
+                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") {
+            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) {
+            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) {
+            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*() {
+            let parsed = (0, _parseRelativeUrl).parseRelativeUrl(url);
+            let { pathname , query  } = parsed;
+            if (false) {}
+            const pages = yield _this.pageLoader.getPageList();
+            let resolvedAs = asPath;
+            const locale = typeof options.locale !== "undefined" ? options.locale || undefined : _this.locale;
+            const isMiddlewareMatch = yield matchesMiddleware({
+                asPath: asPath,
+                locale: locale,
+                router: _this
+            });
+            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) || {});
+                if (!isMiddlewareMatch) {
+                    url = (0, _formatUrl).formatWithValidation(parsed);
+                }
+            }
+            // Prefetch is not supported in development mode because it would trigger on-demand-entries
+            if (false) {}
+            // TODO: if the route middleware's data request
+            // resolves to is not an SSG route we should bust the cache
+            // but we shouldn't allow prefetch to keep triggering
+            // requests for SSP pages
+            const data = yield withMiddlewareEffects({
+                fetchData: ()=>fetchNextData({
+                        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: !_this.isPreview,
+                        isPrefetch: true
+                    }),
+                asPath: asPath,
+                locale: locale,
+                router: _this
+            });
+            /**
+     * If there was a rewrite we apply the effects of the rewrite on the
+     * current parameters for the prefetch.
+     */ if ((data == null ? void 0 : data.effect.type) === "rewrite") {
+                parsed.pathname = data.effect.resolvedHref;
+                pathname = data.effect.resolvedHref;
+                query = _extends({}, query, data.effect.parsedAs.query);
+                resolvedAs = data.effect.parsedAs.pathname;
+                url = (0, _formatUrl).formatWithValidation(parsed);
+            }
+            /**
+     * If there is a redirect to an external destination then we don't have
+     * to prefetch content as it will be unused.
+     */ if ((data == null ? void 0 : data.effect.type) === "redirect-external") {
+                return;
+            }
+            const route = (0, _removeTrailingSlash).removeTrailingSlash(pathname);
+            yield Promise.all([
+                _this.pageLoader._isSsg(route).then((isSsg)=>{
+                    return isSsg ? fetchNextData({
+                        dataHref: (data == null ? void 0 : data.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 , isRsc  }){
+        // 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: pathname1  } = (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) && pathname1 === (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,
+                __N_RSC: !!isRsc
+            };
+        }
+        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 (false) {}
+        this.state = {
+            route,
+            pathname: pathname1,
+            query: query1,
+            asPath: autoExportDynamic ? pathname1 : as1,
+            isPreview: !!isPreview,
+            locale:  false ? 0 : undefined,
+            isFallback
+        };
+        this._initialMatchesMiddlewarePromise = Promise.resolve(false);
+        if (false) {}
+    }
+}
+Router.events = (0, _mitt).default();
+function matchesMiddleware(options) {
+    return Promise.resolve(options.router.pageLoader.getMiddleware()).then((middleware)=>{
+        const { pathname: asPathname  } = (0, _parsePath).parsePath(options.asPath);
+        const cleanedAs = (0, _hasBasePath).hasBasePath(asPathname) ? (0, _removeBasePath).removeBasePath(asPathname) : asPathname;
+        const regex = middleware == null ? void 0 : middleware.location;
+        return !!regex && new RegExp(regex).test((0, _addLocale).addLocale(cleanedAs, options.locale));
+    });
+}
+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,
+                        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;
+    });
+}
+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 src1 = (0, _parsePath).parsePath(redirectTarget);
+            const pathname1 = (0, _formatNextPathnameInfo).formatNextPathnameInfo(_extends({}, (0, _getNextPathnameInfo).getNextPathnameInfo(src1.pathname, {
+                nextConfig,
+                parseData: true
+            }), {
+                defaultLocale: options.router.defaultLocale,
+                buildId: ""
+            }));
+            return Promise.resolve({
+                type: "redirect-internal",
+                newAs: `${pathname1}${src1.query}${src1.hash}`,
+                newUrl: `${pathname1}${src1.query}${src1.hash}`
+            });
+        }
+        return Promise.resolve({
+            type: "redirect-external",
+            destination: redirectTarget
+        });
+    }
+    return Promise.resolve({
+        type: "next"
+    });
+}
+exports["default"] = Router; //# sourceMappingURL=router.js.map
+
+
+/***/ }),
+
+/***/ 1664:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(8418)
+
+
+/***/ })
+
+};
+;