Initial commit

node_modules/next/dist/esm/client/add-base-path.js

@@ -0,0 +1,8 @@
+import { addPathPrefix } from '../shared/lib/router/utils/add-path-prefix';
+import { normalizePathTrailingSlash } from './normalize-trailing-slash';
+const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+export function addBasePath(path, required) {
+    return normalizePathTrailingSlash(process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required ? path : addPathPrefix(path, basePath));
+}
+
+//# sourceMappingURL=add-base-path.js.map

node_modules/next/dist/esm/client/add-base-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/add-base-path.ts"],"sourcesContent":["import { addPathPrefix } from '../shared/lib/router/utils/add-path-prefix'\nimport { normalizePathTrailingSlash } from './normalize-trailing-slash'\n\nconst basePath = (process.env.__NEXT_ROUTER_BASEPATH as string) || ''\n\nexport function addBasePath(path: string, required?: boolean): string {\n  return normalizePathTrailingSlash(\n    process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required\n      ? path\n      : addPathPrefix(path, basePath)\n  )\n}\n"],"names":["addPathPrefix","normalizePathTrailingSlash","basePath","process","env","__NEXT_ROUTER_BASEPATH","addBasePath","path","required","__NEXT_MANUAL_CLIENT_BASE_PATH"],"mappings":"AAAA,SAASA,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,0BAA0B,QAAQ,6BAA4B;AAEvE,MAAMC,WAAW,AAACC,QAAQC,GAAG,CAACC,sBAAsB,IAAe;AAEnE,OAAO,SAASC,YAAYC,IAAY,EAAEC,QAAkB;IAC1D,OAAOP,2BACLE,QAAQC,GAAG,CAACK,8BAA8B,IAAI,CAACD,WAC3CD,OACAP,cAAcO,MAAML;AAE5B"}

node_modules/next/dist/esm/client/add-locale.js

@@ -0,0 +1,12 @@
+import { normalizePathTrailingSlash } from './normalize-trailing-slash';
+export const addLocale = function(path) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    if (process.env.__NEXT_I18N_SUPPORT) {
+        return normalizePathTrailingSlash(require('../shared/lib/router/utils/add-locale').addLocale(path, ...args));
+    }
+    return path;
+};
+
+//# sourceMappingURL=add-locale.js.map

node_modules/next/dist/esm/client/add-locale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/add-locale.ts"],"sourcesContent":["import type { addLocale as Fn } from '../shared/lib/router/utils/add-locale'\nimport { normalizePathTrailingSlash } from './normalize-trailing-slash'\n\nexport const addLocale: typeof Fn = (path, ...args) => {\n  if (process.env.__NEXT_I18N_SUPPORT) {\n    return normalizePathTrailingSlash(\n      require('../shared/lib/router/utils/add-locale').addLocale(path, ...args)\n    )\n  }\n  return path\n}\n"],"names":["normalizePathTrailingSlash","addLocale","path","args","process","env","__NEXT_I18N_SUPPORT","require"],"mappings":"AACA,SAASA,0BAA0B,QAAQ,6BAA4B;AAEvE,OAAO,MAAMC,YAAuB,SAACC;qCAASC;QAAAA;;IAC5C,IAAIC,QAAQC,GAAG,CAACC,mBAAmB,EAAE;QACnC,OAAON,2BACLO,QAAQ,yCAAyCN,SAAS,CAACC,SAASC;IAExE;IACA,OAAOD;AACT,EAAC"}

node_modules/next/dist/esm/client/app-bootstrap.js

@@ -0,0 +1,62 @@
+/**
+ * Before starting the Next.js runtime and requiring any module, we need to make
+ * sure the following scripts are executed in the correct order:
+ * - Polyfills
+ * - next/script with `beforeInteractive` strategy
+ */ const version = "15.3.2";
+window.next = {
+    version,
+    appDir: true
+};
+function loadScriptsInSequence(scripts, hydrate) {
+    if (!scripts || !scripts.length) {
+        return hydrate();
+    }
+    return scripts.reduce((promise, param)=>{
+        let [src, props] = param;
+        return promise.then(()=>{
+            return new Promise((resolve, reject)=>{
+                const el = document.createElement('script');
+                if (props) {
+                    for(const key in props){
+                        if (key !== 'children') {
+                            el.setAttribute(key, props[key]);
+                        }
+                    }
+                }
+                if (src) {
+                    el.src = src;
+                    el.onload = ()=>resolve();
+                    el.onerror = reject;
+                } else if (props) {
+                    el.innerHTML = props.children;
+                    setTimeout(resolve);
+                }
+                document.head.appendChild(el);
+            });
+        });
+    }, Promise.resolve()).catch((err)=>{
+        console.error(err);
+    // Still try to hydrate even if there's an error.
+    }).then(()=>{
+        hydrate();
+    });
+}
+export function appBootstrap(hydrate) {
+    loadScriptsInSequence(self.__next_s, ()=>{
+        // If the static shell is being debugged, skip hydration if the
+        // `__nextppronly` query is present. This is only enabled when the
+        // environment variable `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` is
+        // set to `1`. Otherwise the following is optimized out.
+        if (process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING === '1') {
+            const search = new URLSearchParams(window.location.search);
+            if (search.get('__nextppronly') === 'fallback' || search.get('__nextppronly') === '1') {
+                console.warn("Skipping hydration due to __nextppronly=" + search.get('__nextppronly'));
+                return;
+            }
+        }
+        hydrate();
+    });
+}
+
+//# sourceMappingURL=app-bootstrap.js.map

node_modules/next/dist/esm/client/app-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-bootstrap.ts"],"sourcesContent":["/**\n * Before starting the Next.js runtime and requiring any module, we need to make\n * sure the following scripts are executed in the correct order:\n * - Polyfills\n * - next/script with `beforeInteractive` strategy\n */\n\nconst version = process.env.__NEXT_VERSION\n\nwindow.next = {\n  version,\n  appDir: true,\n}\n\nfunction loadScriptsInSequence(\n  scripts: [src: string, props: { [prop: string]: any }][],\n  hydrate: () => void\n) {\n  if (!scripts || !scripts.length) {\n    return hydrate()\n  }\n\n  return scripts\n    .reduce((promise, [src, props]) => {\n      return promise.then(() => {\n        return new Promise<void>((resolve, reject) => {\n          const el = document.createElement('script')\n\n          if (props) {\n            for (const key in props) {\n              if (key !== 'children') {\n                el.setAttribute(key, props[key])\n              }\n            }\n          }\n\n          if (src) {\n            el.src = src\n            el.onload = () => resolve()\n            el.onerror = reject\n          } else if (props) {\n            el.innerHTML = props.children\n            setTimeout(resolve)\n          }\n\n          document.head.appendChild(el)\n        })\n      })\n    }, Promise.resolve())\n    .catch((err: Error) => {\n      console.error(err)\n      // Still try to hydrate even if there's an error.\n    })\n    .then(() => {\n      hydrate()\n    })\n}\n\nexport function appBootstrap(hydrate: () => void) {\n  loadScriptsInSequence((self as any).__next_s, () => {\n    // If the static shell is being debugged, skip hydration if the\n    // `__nextppronly` query is present. This is only enabled when the\n    // environment variable `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` is\n    // set to `1`. Otherwise the following is optimized out.\n    if (process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING === '1') {\n      const search = new URLSearchParams(window.location.search)\n      if (\n        search.get('__nextppronly') === 'fallback' ||\n        search.get('__nextppronly') === '1'\n      ) {\n        console.warn(\n          `Skipping hydration due to __nextppronly=${search.get('__nextppronly')}`\n        )\n        return\n      }\n    }\n\n    hydrate()\n  })\n}\n"],"names":["version","process","env","__NEXT_VERSION","window","next","appDir","loadScriptsInSequence","scripts","hydrate","length","reduce","promise","src","props","then","Promise","resolve","reject","el","document","createElement","key","setAttribute","onload","onerror","innerHTML","children","setTimeout","head","appendChild","catch","err","console","error","appBootstrap","self","__next_s","__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING","search","URLSearchParams","location","get","warn"],"mappings":"AAAA;;;;;CAKC,GAED,MAAMA,UAAUC,QAAQC,GAAG,CAACC,cAAc;AAE1CC,OAAOC,IAAI,GAAG;IACZL;IACAM,QAAQ;AACV;AAEA,SAASC,sBACPC,OAAwD,EACxDC,OAAmB;IAEnB,IAAI,CAACD,WAAW,CAACA,QAAQE,MAAM,EAAE;QAC/B,OAAOD;IACT;IAEA,OAAOD,QACJG,MAAM,CAAC,CAACC;YAAS,CAACC,KAAKC,MAAM;QAC5B,OAAOF,QAAQG,IAAI,CAAC;YAClB,OAAO,IAAIC,QAAc,CAACC,SAASC;gBACjC,MAAMC,KAAKC,SAASC,aAAa,CAAC;gBAElC,IAAIP,OAAO;oBACT,IAAK,MAAMQ,OAAOR,MAAO;wBACvB,IAAIQ,QAAQ,YAAY;4BACtBH,GAAGI,YAAY,CAACD,KAAKR,KAAK,CAACQ,IAAI;wBACjC;oBACF;gBACF;gBAEA,IAAIT,KAAK;oBACPM,GAAGN,GAAG,GAAGA;oBACTM,GAAGK,MAAM,GAAG,IAAMP;oBAClBE,GAAGM,OAAO,GAAGP;gBACf,OAAO,IAAIJ,OAAO;oBAChBK,GAAGO,SAAS,GAAGZ,MAAMa,QAAQ;oBAC7BC,WAAWX;gBACb;gBAEAG,SAASS,IAAI,CAACC,WAAW,CAACX;YAC5B;QACF;IACF,GAAGH,QAAQC,OAAO,IACjBc,KAAK,CAAC,CAACC;QACNC,QAAQC,KAAK,CAACF;IACd,iDAAiD;IACnD,GACCjB,IAAI,CAAC;QACJN;IACF;AACJ;AAEA,OAAO,SAAS0B,aAAa1B,OAAmB;IAC9CF,sBAAsB,AAAC6B,KAAaC,QAAQ,EAAE;QAC5C,+DAA+D;QAC/D,kEAAkE;QAClE,uEAAuE;QACvE,wDAAwD;QACxD,IAAIpC,QAAQC,GAAG,CAACoC,0CAA0C,KAAK,KAAK;YAClE,MAAMC,SAAS,IAAIC,gBAAgBpC,OAAOqC,QAAQ,CAACF,MAAM;YACzD,IACEA,OAAOG,GAAG,CAAC,qBAAqB,cAChCH,OAAOG,GAAG,CAAC,qBAAqB,KAChC;gBACAT,QAAQU,IAAI,CACV,AAAC,6CAA0CJ,OAAOG,GAAG,CAAC;gBAExD;YACF;QACF;QAEAjC;IACF;AACF"}

node_modules/next/dist/esm/client/app-build-id.js

@@ -0,0 +1,21 @@
+// This gets assigned as a side-effect during app initialization. Because it
+// represents the build used to create the JS bundle, it should never change
+// after being set, so we store it in a global variable.
+//
+// When performing RSC requests, if the incoming data has a different build ID,
+// we perform an MPA navigation/refresh to load the updated build and ensure
+// that the client and server in sync.
+// Starts as an empty string. In practice, because setAppBuildId is called
+// during initialization before hydration starts, this will always get
+// reassigned to the actual build ID before it's ever needed by a navigation.
+// If for some reasons it didn't, due to a bug or race condition, then on
+// navigation the build comparision would fail and trigger an MPA navigation.
+let globalBuildId = '';
+export function setAppBuildId(buildId) {
+    globalBuildId = buildId;
+}
+export function getAppBuildId() {
+    return globalBuildId;
+}
+
+//# sourceMappingURL=app-build-id.js.map

node_modules/next/dist/esm/client/app-build-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-build-id.ts"],"sourcesContent":["// This gets assigned as a side-effect during app initialization. Because it\n// represents the build used to create the JS bundle, it should never change\n// after being set, so we store it in a global variable.\n//\n// When performing RSC requests, if the incoming data has a different build ID,\n// we perform an MPA navigation/refresh to load the updated build and ensure\n// that the client and server in sync.\n\n// Starts as an empty string. In practice, because setAppBuildId is called\n// during initialization before hydration starts, this will always get\n// reassigned to the actual build ID before it's ever needed by a navigation.\n// If for some reasons it didn't, due to a bug or race condition, then on\n// navigation the build comparision would fail and trigger an MPA navigation.\nlet globalBuildId: string = ''\n\nexport function setAppBuildId(buildId: string) {\n  globalBuildId = buildId\n}\n\nexport function getAppBuildId(): string {\n  return globalBuildId\n}\n"],"names":["globalBuildId","setAppBuildId","buildId","getAppBuildId"],"mappings":"AAAA,4EAA4E;AAC5E,4EAA4E;AAC5E,wDAAwD;AACxD,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAC5E,sCAAsC;AAEtC,0EAA0E;AAC1E,sEAAsE;AACtE,6EAA6E;AAC7E,yEAAyE;AACzE,6EAA6E;AAC7E,IAAIA,gBAAwB;AAE5B,OAAO,SAASC,cAAcC,OAAe;IAC3CF,gBAAgBE;AAClB;AAEA,OAAO,SAASC;IACd,OAAOH;AACT"}

node_modules/next/dist/esm/client/app-call-server.js

@@ -0,0 +1,18 @@
+import { startTransition } from 'react';
+import { ACTION_SERVER_ACTION } from './components/router-reducer/router-reducer-types';
+import { dispatchAppRouterAction } from './components/use-action-queue';
+export async function callServer(actionId, actionArgs) {
+    return new Promise((resolve, reject)=>{
+        startTransition(()=>{
+            dispatchAppRouterAction({
+                type: ACTION_SERVER_ACTION,
+                actionId,
+                actionArgs,
+                resolve,
+                reject
+            });
+        });
+    });
+}
+
+//# sourceMappingURL=app-call-server.js.map

node_modules/next/dist/esm/client/app-call-server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-call-server.ts"],"sourcesContent":["import { startTransition } from 'react'\nimport { ACTION_SERVER_ACTION } from './components/router-reducer/router-reducer-types'\nimport { dispatchAppRouterAction } from './components/use-action-queue'\n\nexport async function callServer(actionId: string, actionArgs: any[]) {\n  return new Promise((resolve, reject) => {\n    startTransition(() => {\n      dispatchAppRouterAction({\n        type: ACTION_SERVER_ACTION,\n        actionId,\n        actionArgs,\n        resolve,\n        reject,\n      })\n    })\n  })\n}\n"],"names":["startTransition","ACTION_SERVER_ACTION","dispatchAppRouterAction","callServer","actionId","actionArgs","Promise","resolve","reject","type"],"mappings":"AAAA,SAASA,eAAe,QAAQ,QAAO;AACvC,SAASC,oBAAoB,QAAQ,mDAAkD;AACvF,SAASC,uBAAuB,QAAQ,gCAA+B;AAEvE,OAAO,eAAeC,WAAWC,QAAgB,EAAEC,UAAiB;IAClE,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3BR,gBAAgB;YACdE,wBAAwB;gBACtBO,MAAMR;gBACNG;gBACAC;gBACAE;gBACAC;YACF;QACF;IACF;AACF"}

node_modules/next/dist/esm/client/app-dir/form.js

@@ -0,0 +1,142 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useContext } from 'react';
+import { addBasePath } from '../add-base-path';
+import { useMergedRef } from '../use-merged-ref';
+import { AppRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { PrefetchKind } from '../components/router-reducer/router-reducer-types';
+import { checkFormActionUrl, createFormSubmitDestinationUrl, DISALLOWED_FORM_PROPS, hasReactClientActionAttributes, hasUnsupportedSubmitterAttributes } from '../form-shared';
+import { mountFormInstance, unmountPrefetchableInstance } from '../components/links';
+export default function Form(param) {
+    let { replace, scroll, prefetch: prefetchProp, ref: externalRef, ...props } = param;
+    const router = useContext(AppRouterContext);
+    const actionProp = props.action;
+    const isNavigatingForm = typeof actionProp === 'string';
+    // Validate `action`
+    if (process.env.NODE_ENV === 'development') {
+        if (isNavigatingForm) {
+            checkFormActionUrl(actionProp, 'action');
+        }
+    }
+    // Validate `prefetch`
+    if (process.env.NODE_ENV === 'development') {
+        if (!(prefetchProp === undefined || prefetchProp === false || prefetchProp === null)) {
+            console.error('The `prefetch` prop of <Form> must be `false` or `null`');
+        }
+        if (prefetchProp !== undefined && !isNavigatingForm) {
+            console.error('Passing `prefetch` to a <Form> whose `action` is a function has no effect.');
+        }
+    }
+    const prefetch = prefetchProp === false || prefetchProp === null ? prefetchProp : null;
+    // Validate `scroll` and `replace`
+    if (process.env.NODE_ENV === 'development') {
+        if (!isNavigatingForm && (replace !== undefined || scroll !== undefined)) {
+            console.error('Passing `replace` or `scroll` to a <Form> whose `action` is a function has no effect.\n' + 'See the relevant docs to learn how to control this behavior for navigations triggered from actions:\n' + '  `redirect()`       - https://nextjs.org/docs/app/api-reference/functions/redirect#parameters\n' + '  `router.replace()` - https://nextjs.org/docs/app/api-reference/functions/use-router#userouter\n');
+        }
+    }
+    // Clean up any unsupported form props (and warn if present)
+    for (const key of DISALLOWED_FORM_PROPS){
+        if (key in props) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error("<Form> does not support changing `" + key + "`. " + (isNavigatingForm ? "If you'd like to use it to perform a mutation, consider making `action` a function instead.\n" + "Learn more: https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations" : ''));
+            }
+            delete props[key];
+        }
+    }
+    const isPrefetchEnabled = // if we don't have an action path, we can't prefetch anything.
+    !!router && isNavigatingForm && prefetch === null;
+    const observeFormVisibilityOnMount = useCallback((element)=>{
+        if (isPrefetchEnabled && router !== null) {
+            mountFormInstance(element, actionProp, router, PrefetchKind.AUTO);
+        }
+        return ()=>{
+            unmountPrefetchableInstance(element);
+        };
+    }, [
+        isPrefetchEnabled,
+        actionProp,
+        router
+    ]);
+    const mergedRef = useMergedRef(observeFormVisibilityOnMount, externalRef != null ? externalRef : null);
+    if (!isNavigatingForm) {
+        return /*#__PURE__*/ _jsx("form", {
+            ...props,
+            ref: mergedRef
+        });
+    }
+    const actionHref = addBasePath(actionProp);
+    return /*#__PURE__*/ _jsx("form", {
+        ...props,
+        ref: mergedRef,
+        action: actionHref,
+        onSubmit: (event)=>onFormSubmit(event, {
+                router,
+                actionHref,
+                replace,
+                scroll,
+                onSubmit: props.onSubmit
+            })
+    });
+}
+function onFormSubmit(event, param) {
+    let { actionHref, onSubmit, replace, scroll, router } = param;
+    if (typeof onSubmit === 'function') {
+        onSubmit(event);
+        // if the user called event.preventDefault(), do nothing.
+        // (this matches what Link does for `onClick`)
+        if (event.defaultPrevented) {
+            return;
+        }
+    }
+    if (!router) {
+        // Form was somehow used outside of the router (but not in pages, the implementation is forked!).
+        // We can't perform a soft navigation, so let the native submit handling do its thing.
+        return;
+    }
+    const formElement = event.currentTarget;
+    const submitter = event.nativeEvent.submitter;
+    let action = actionHref;
+    if (submitter) {
+        if (process.env.NODE_ENV === 'development') {
+            // the way server actions are encoded (e.g. `formMethod="post")
+            // causes some unnecessary dev-mode warnings from `hasUnsupportedSubmitterAttributes`.
+            // we'd bail out anyway, but we just do it silently.
+            if (hasReactServerActionAttributes(submitter)) {
+                return;
+            }
+        }
+        if (hasUnsupportedSubmitterAttributes(submitter)) {
+            return;
+        }
+        // client actions have `formAction="javascript:..."`. We obviously can't prefetch/navigate to that.
+        if (hasReactClientActionAttributes(submitter)) {
+            return;
+        }
+        // If the submitter specified an alternate formAction,
+        // use that URL instead -- this is what a native form would do.
+        // NOTE: `submitter.formAction` is unreliable, because it will give us `location.href` if it *wasn't* set
+        // NOTE: this should not have `basePath` added, because we can't add it before hydration
+        const submitterFormAction = submitter.getAttribute('formAction');
+        if (submitterFormAction !== null) {
+            if (process.env.NODE_ENV === 'development') {
+                checkFormActionUrl(submitterFormAction, 'formAction');
+            }
+            action = submitterFormAction;
+        }
+    }
+    const targetUrl = createFormSubmitDestinationUrl(action, formElement);
+    // Finally, no more reasons for bailing out.
+    event.preventDefault();
+    const method = replace ? 'replace' : 'push';
+    const targetHref = targetUrl.href;
+    router[method](targetHref, {
+        scroll
+    });
+}
+function hasReactServerActionAttributes(submitter) {
+    // https://github.com/facebook/react/blob/942eb80381b96f8410eab1bef1c539bed1ab0eb1/packages/react-client/src/ReactFlightReplyClient.js#L931-L934
+    const name = submitter.getAttribute('name');
+    return name && (name.startsWith('$ACTION_ID_') || name.startsWith('$ACTION_REF_'));
+}
+
+//# sourceMappingURL=form.js.map

node_modules/next/dist/esm/client/app-dir/link.js

@@ -0,0 +1,355 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useOptimistic, useRef } from 'react';
+import { formatUrl } from '../../shared/lib/router/utils/format-url';
+import { AppRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { PrefetchKind } from '../components/router-reducer/router-reducer-types';
+import { useMergedRef } from '../use-merged-ref';
+import { isAbsoluteUrl } from '../../shared/lib/utils';
+import { addBasePath } from '../add-base-path';
+import { warnOnce } from '../../shared/lib/utils/warn-once';
+import { IDLE_LINK_STATUS, mountLinkInstance, onNavigationIntent, unmountLinkForCurrentNavigation, unmountPrefetchableInstance } from '../components/links';
+import { isLocalURL } from '../../shared/lib/router/utils/is-local-url';
+import { dispatchNavigateAction } from '../components/app-router-instance';
+import { errorOnce } from '../../shared/lib/utils/error-once';
+function isModifiedEvent(event) {
+    const eventTarget = event.currentTarget;
+    const target = eventTarget.getAttribute('target');
+    return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
+    event.nativeEvent && event.nativeEvent.which === 2;
+}
+function linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate) {
+    const { nodeName } = e.currentTarget;
+    // anchors inside an svg have a lowercase nodeName
+    const isAnchorNodeName = nodeName.toUpperCase() === 'A';
+    if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute('download')) {
+        // ignore click for browser’s default behavior
+        return;
+    }
+    if (!isLocalURL(href)) {
+        if (replace) {
+            // browser default behavior does not replace the history state
+            // so we need to do it manually
+            e.preventDefault();
+            location.replace(href);
+        }
+        // ignore click for browser’s default behavior
+        return;
+    }
+    e.preventDefault();
+    const navigate = ()=>{
+        if (onNavigate) {
+            let isDefaultPrevented = false;
+            onNavigate({
+                preventDefault: ()=>{
+                    isDefaultPrevented = true;
+                }
+            });
+            if (isDefaultPrevented) {
+                return;
+            }
+        }
+        dispatchNavigateAction(as || href, replace ? 'replace' : 'push', scroll != null ? scroll : true, linkInstanceRef.current);
+    };
+    React.startTransition(navigate);
+}
+function formatStringOrUrl(urlObjOrString) {
+    if (typeof urlObjOrString === 'string') {
+        return urlObjOrString;
+    }
+    return formatUrl(urlObjOrString);
+}
+/**
+ * A React component that extends the HTML `<a>` element to provide
+ * [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+ * and client-side navigation. This is the primary way to navigate between routes in Next.js.
+ *
+ * @remarks
+ * - Prefetching is only enabled in production.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/components/link
+ */ export default function LinkComponent(props) {
+    const [linkStatus, setOptimisticLinkStatus] = useOptimistic(IDLE_LINK_STATUS);
+    let children;
+    const linkInstanceRef = useRef(null);
+    const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, onClick, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, onNavigate, ref: forwardedRef, unstable_dynamicOnHover, ...restProps } = props;
+    children = childrenProp;
+    if (legacyBehavior && (typeof children === 'string' || typeof children === 'number')) {
+        children = /*#__PURE__*/ _jsx("a", {
+            children: children
+        });
+    }
+    const router = React.useContext(AppRouterContext);
+    const prefetchEnabled = prefetchProp !== false;
+    /**
+   * The possible states for prefetch are:
+   * - null: this is the default "auto" mode, where we will prefetch partially if the link is in the viewport
+   * - true: we will prefetch if the link is visible and prefetch the full page, not just partially
+   * - false: we will not prefetch if in the viewport at all
+   * - 'unstable_dynamicOnHover': this starts in "auto" mode, but switches to "full" when the link is hovered
+   */ const appPrefetchKind = prefetchProp === null ? PrefetchKind.AUTO : PrefetchKind.FULL;
+    if (process.env.NODE_ENV !== 'production') {
+        function createPropError(args) {
+            return Object.defineProperty(new Error("Failed prop type: The prop `" + args.key + "` expects a " + args.expected + " in `<Link>`, but got `" + args.actual + "` instead." + (typeof window !== 'undefined' ? "\nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                value: "E319",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // TypeScript trick for type-guarding:
+        const requiredPropsGuard = {
+            href: true
+        };
+        const requiredProps = Object.keys(requiredPropsGuard);
+        requiredProps.forEach((key)=>{
+            if (key === 'href') {
+                if (props[key] == null || typeof props[key] !== 'string' && typeof props[key] !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: props[key] === null ? 'null' : typeof props[key]
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+        // TypeScript trick for type-guarding:
+        const optionalPropsGuard = {
+            as: true,
+            replace: true,
+            scroll: true,
+            shallow: true,
+            passHref: true,
+            prefetch: true,
+            unstable_dynamicOnHover: true,
+            onClick: true,
+            onMouseEnter: true,
+            onTouchStart: true,
+            legacyBehavior: true,
+            onNavigate: true
+        };
+        const optionalProps = Object.keys(optionalPropsGuard);
+        optionalProps.forEach((key)=>{
+            const valType = typeof props[key];
+            if (key === 'as') {
+                if (props[key] && valType !== 'string' && valType !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'onClick' || key === 'onMouseEnter' || key === 'onTouchStart' || key === 'onNavigate') {
+                if (props[key] && valType !== 'function') {
+                    throw createPropError({
+                        key,
+                        expected: '`function`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'replace' || key === 'scroll' || key === 'shallow' || key === 'passHref' || key === 'prefetch' || key === 'legacyBehavior' || key === 'unstable_dynamicOnHover') {
+                if (props[key] != null && valType !== 'boolean') {
+                    throw createPropError({
+                        key,
+                        expected: '`boolean`',
+                        actual: valType
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        if (props.locale) {
+            warnOnce('The `locale` prop is not supported in `next/link` while using the `app` router. Read more about app router internalization: https://nextjs.org/docs/app/building-your-application/routing/internationalization');
+        }
+        if (!asProp) {
+            let href;
+            if (typeof hrefProp === 'string') {
+                href = hrefProp;
+            } else if (typeof hrefProp === 'object' && typeof hrefProp.pathname === 'string') {
+                href = hrefProp.pathname;
+            }
+            if (href) {
+                const hasDynamicSegment = href.split('/').some((segment)=>segment.startsWith('[') && segment.endsWith(']'));
+                if (hasDynamicSegment) {
+                    throw Object.defineProperty(new Error("Dynamic href `" + href + "` found in <Link> while using the `/app` router, this is not supported. Read more: https://nextjs.org/docs/messages/app-dir-dynamic-href"), "__NEXT_ERROR_CODE", {
+                        value: "E267",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+        }
+    }
+    const { href, as } = React.useMemo(()=>{
+        const resolvedHref = formatStringOrUrl(hrefProp);
+        return {
+            href: resolvedHref,
+            as: asProp ? formatStringOrUrl(asProp) : resolvedHref
+        };
+    }, [
+        hrefProp,
+        asProp
+    ]);
+    // This will return the first child, if multiple are provided it will throw an error
+    let child;
+    if (legacyBehavior) {
+        if (process.env.NODE_ENV === 'development') {
+            if (onClick) {
+                console.warn('"onClick" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link');
+            }
+            if (onMouseEnterProp) {
+                console.warn('"onMouseEnter" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link');
+            }
+            try {
+                child = React.Children.only(children);
+            } catch (err) {
+                if (!children) {
+                    throw Object.defineProperty(new Error("No children were passed to <Link> with `href` of `" + hrefProp + "` but one child is required https://nextjs.org/docs/messages/link-no-children"), "__NEXT_ERROR_CODE", {
+                        value: "E320",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                throw Object.defineProperty(new Error("Multiple children were passed to <Link> with `href` of `" + hrefProp + "` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children" + (typeof window !== 'undefined' ? " \nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                    value: "E266",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else {
+            child = React.Children.only(children);
+        }
+    } else {
+        if (process.env.NODE_ENV === 'development') {
+            if ((children == null ? void 0 : children.type) === 'a') {
+                throw Object.defineProperty(new Error('Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor'), "__NEXT_ERROR_CODE", {
+                    value: "E209",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
+    }
+    const childRef = legacyBehavior ? child && typeof child === 'object' && child.ref : forwardedRef;
+    // Use a callback ref to attach an IntersectionObserver to the anchor tag on
+    // mount. In the future we will also use this to keep track of all the
+    // currently mounted <Link> instances, e.g. so we can re-prefetch them after
+    // a revalidation or refresh.
+    const observeLinkVisibilityOnMount = React.useCallback((element)=>{
+        if (router !== null) {
+            linkInstanceRef.current = mountLinkInstance(element, href, router, appPrefetchKind, prefetchEnabled, setOptimisticLinkStatus);
+        }
+        return ()=>{
+            if (linkInstanceRef.current) {
+                unmountLinkForCurrentNavigation(linkInstanceRef.current);
+                linkInstanceRef.current = null;
+            }
+            unmountPrefetchableInstance(element);
+        };
+    }, [
+        prefetchEnabled,
+        href,
+        router,
+        appPrefetchKind,
+        setOptimisticLinkStatus
+    ]);
+    const mergedRef = useMergedRef(observeLinkVisibilityOnMount, childRef);
+    const childProps = {
+        ref: mergedRef,
+        onClick (e) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (!e) {
+                    throw Object.defineProperty(new Error('Component rendered inside next/link has to pass click event to "onClick" prop.'), "__NEXT_ERROR_CODE", {
+                        value: "E312",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+            if (!legacyBehavior && typeof onClick === 'function') {
+                onClick(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onClick === 'function') {
+                child.props.onClick(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (e.defaultPrevented) {
+                return;
+            }
+            linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate);
+        },
+        onMouseEnter (e) {
+            if (!legacyBehavior && typeof onMouseEnterProp === 'function') {
+                onMouseEnterProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onMouseEnter === 'function') {
+                child.props.onMouseEnter(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled || process.env.NODE_ENV === 'development') {
+                return;
+            }
+            const upgradeToDynamicPrefetch = unstable_dynamicOnHover === true;
+            onNavigationIntent(e.currentTarget, upgradeToDynamicPrefetch);
+        },
+        onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? undefined : function onTouchStart(e) {
+            if (!legacyBehavior && typeof onTouchStartProp === 'function') {
+                onTouchStartProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onTouchStart === 'function') {
+                child.props.onTouchStart(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled) {
+                return;
+            }
+            const upgradeToDynamicPrefetch = unstable_dynamicOnHover === true;
+            onNavigationIntent(e.currentTarget, upgradeToDynamicPrefetch);
+        }
+    };
+    // 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 the url is absolute, we can bypass the logic to prepend the basePath.
+    if (isAbsoluteUrl(as)) {
+        childProps.href = as;
+    } else if (!legacyBehavior || passHref || child.type === 'a' && !('href' in child.props)) {
+        childProps.href = addBasePath(as);
+    }
+    let link;
+    if (legacyBehavior) {
+        if (process.env.NODE_ENV === 'development') {
+            errorOnce('`legacyBehavior` is deprecated and will be removed in a future ' + 'release. A codemod is available to upgrade your components:\n\n' + 'npx @next/codemod@latest new-link .\n\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components');
+        }
+        link = /*#__PURE__*/ React.cloneElement(child, childProps);
+    } else {
+        link = /*#__PURE__*/ _jsx("a", {
+            ...restProps,
+            ...childProps,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsx(LinkStatusContext.Provider, {
+        value: linkStatus,
+        children: link
+    });
+}
+const LinkStatusContext = /*#__PURE__*/ createContext(IDLE_LINK_STATUS);
+export const useLinkStatus = ()=>{
+    return useContext(LinkStatusContext);
+};
+
+//# sourceMappingURL=link.js.map

node_modules/next/dist/esm/client/app-find-source-map-url.js

@@ -0,0 +1,22 @@
+const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+const pathname = "" + basePath + "/__nextjs_source-map";
+export const findSourceMapURL = process.env.NODE_ENV === 'development' ? function findSourceMapURL(filename) {
+    if (filename === '') {
+        return null;
+    }
+    if (filename.startsWith(document.location.origin) && filename.includes('/_next/static')) {
+        // This is a request for a client chunk. This can only happen when
+        // using Turbopack. In this case, since we control how those source
+        // maps are generated, we can safely assume that the sourceMappingURL
+        // is relative to the filename, with an added `.map` extension. The
+        // browser can just request this file, and it gets served through the
+        // normal dev server, without the need to route this through
+        // the `/__nextjs_source-map` dev middleware.
+        return "" + filename + ".map";
+    }
+    const url = new URL(pathname, document.location.origin);
+    url.searchParams.set('filename', filename);
+    return url.href;
+} : undefined;
+
+//# sourceMappingURL=app-find-source-map-url.js.map

node_modules/next/dist/esm/client/app-find-source-map-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-find-source-map-url.ts"],"sourcesContent":["const basePath = process.env.__NEXT_ROUTER_BASEPATH || ''\nconst pathname = `${basePath}/__nextjs_source-map`\n\nexport const findSourceMapURL =\n  process.env.NODE_ENV === 'development'\n    ? function findSourceMapURL(filename: string): string | null {\n        if (filename === '') {\n          return null\n        }\n\n        if (\n          filename.startsWith(document.location.origin) &&\n          filename.includes('/_next/static')\n        ) {\n          // This is a request for a client chunk. This can only happen when\n          // using Turbopack. In this case, since we control how those source\n          // maps are generated, we can safely assume that the sourceMappingURL\n          // is relative to the filename, with an added `.map` extension. The\n          // browser can just request this file, and it gets served through the\n          // normal dev server, without the need to route this through\n          // the `/__nextjs_source-map` dev middleware.\n          return `${filename}.map`\n        }\n\n        const url = new URL(pathname, document.location.origin)\n        url.searchParams.set('filename', filename)\n\n        return url.href\n      }\n    : undefined\n"],"names":["basePath","process","env","__NEXT_ROUTER_BASEPATH","pathname","findSourceMapURL","NODE_ENV","filename","startsWith","document","location","origin","includes","url","URL","searchParams","set","href","undefined"],"mappings":"AAAA,MAAMA,WAAWC,QAAQC,GAAG,CAACC,sBAAsB,IAAI;AACvD,MAAMC,WAAW,AAAC,KAAEJ,WAAS;AAE7B,OAAO,MAAMK,mBACXJ,QAAQC,GAAG,CAACI,QAAQ,KAAK,gBACrB,SAASD,iBAAiBE,QAAgB;IACxC,IAAIA,aAAa,IAAI;QACnB,OAAO;IACT;IAEA,IACEA,SAASC,UAAU,CAACC,SAASC,QAAQ,CAACC,MAAM,KAC5CJ,SAASK,QAAQ,CAAC,kBAClB;QACA,kEAAkE;QAClE,mEAAmE;QACnE,qEAAqE;QACrE,mEAAmE;QACnE,qEAAqE;QACrE,4DAA4D;QAC5D,6CAA6C;QAC7C,OAAO,AAAC,KAAEL,WAAS;IACrB;IAEA,MAAMM,MAAM,IAAIC,IAAIV,UAAUK,SAASC,QAAQ,CAACC,MAAM;IACtDE,IAAIE,YAAY,CAACC,GAAG,CAAC,YAAYT;IAEjC,OAAOM,IAAII,IAAI;AACjB,IACAC,UAAS"}

node_modules/next/dist/esm/client/app-index.js

@@ -0,0 +1,220 @@
+// imports polyfill from `@next/polyfill-module` after build.
+import { jsx as _jsx } from "react/jsx-runtime";
+import '../build/polyfills/polyfill-module';
+import './components/globals/patch-console';
+import './components/globals/handle-global-errors';
+import ReactDOMClient from 'react-dom/client';
+import React, { use } from 'react';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { createFromReadableStream } from 'react-server-dom-webpack/client';
+import { HeadManagerContext } from '../shared/lib/head-manager-context.shared-runtime';
+import { onRecoverableError } from './react-client-callbacks/on-recoverable-error';
+import { onCaughtError, onUncaughtError } from './react-client-callbacks/error-boundary-callbacks';
+import { callServer } from './app-call-server';
+import { findSourceMapURL } from './app-find-source-map-url';
+import { createMutableActionQueue } from './components/app-router-instance';
+import AppRouter from './components/app-router';
+import { createInitialRouterState } from './components/router-reducer/create-initial-router-state';
+import { MissingSlotContext } from '../shared/lib/app-router-context.shared-runtime';
+import { setAppBuildId } from './app-build-id';
+/// <reference types="react-dom/experimental" />
+const appElement = document;
+const encoder = new TextEncoder();
+let initialServerDataBuffer = undefined;
+let initialServerDataWriter = undefined;
+let initialServerDataLoaded = false;
+let initialServerDataFlushed = false;
+let initialFormStateData = null;
+function nextServerDataCallback(seg) {
+    if (seg[0] === 0) {
+        initialServerDataBuffer = [];
+    } else if (seg[0] === 1) {
+        if (!initialServerDataBuffer) throw Object.defineProperty(new Error('Unexpected server data: missing bootstrap script.'), "__NEXT_ERROR_CODE", {
+            value: "E18",
+            enumerable: false,
+            configurable: true
+        });
+        if (initialServerDataWriter) {
+            initialServerDataWriter.enqueue(encoder.encode(seg[1]));
+        } else {
+            initialServerDataBuffer.push(seg[1]);
+        }
+    } else if (seg[0] === 2) {
+        initialFormStateData = seg[1];
+    } else if (seg[0] === 3) {
+        if (!initialServerDataBuffer) throw Object.defineProperty(new Error('Unexpected server data: missing bootstrap script.'), "__NEXT_ERROR_CODE", {
+            value: "E18",
+            enumerable: false,
+            configurable: true
+        });
+        // Decode the base64 string back to binary data.
+        const binaryString = atob(seg[1]);
+        const decodedChunk = new Uint8Array(binaryString.length);
+        for(var i = 0; i < binaryString.length; i++){
+            decodedChunk[i] = binaryString.charCodeAt(i);
+        }
+        if (initialServerDataWriter) {
+            initialServerDataWriter.enqueue(decodedChunk);
+        } else {
+            initialServerDataBuffer.push(decodedChunk);
+        }
+    }
+}
+function isStreamErrorOrUnfinished(ctr) {
+    // If `desiredSize` is null, it means the stream is closed or errored. If it is lower than 0, the stream is still unfinished.
+    return ctr.desiredSize === null || ctr.desiredSize < 0;
+}
+// There might be race conditions between `nextServerDataRegisterWriter` and
+// `DOMContentLoaded`. The former will be called when React starts to hydrate
+// the root, the latter will be called when the DOM is fully loaded.
+// For streaming, the former is called first due to partial hydration.
+// For non-streaming, the latter can be called first.
+// Hence, we use two variables `initialServerDataLoaded` and
+// `initialServerDataFlushed` to make sure the writer will be closed and
+// `initialServerDataBuffer` will be cleared in the right time.
+function nextServerDataRegisterWriter(ctr) {
+    if (initialServerDataBuffer) {
+        initialServerDataBuffer.forEach((val)=>{
+            ctr.enqueue(typeof val === 'string' ? encoder.encode(val) : val);
+        });
+        if (initialServerDataLoaded && !initialServerDataFlushed) {
+            if (isStreamErrorOrUnfinished(ctr)) {
+                ctr.error(Object.defineProperty(new Error('The connection to the page was unexpectedly closed, possibly due to the stop button being clicked, loss of Wi-Fi, or an unstable internet connection.'), "__NEXT_ERROR_CODE", {
+                    value: "E117",
+                    enumerable: false,
+                    configurable: true
+                }));
+            } else {
+                ctr.close();
+            }
+            initialServerDataFlushed = true;
+            initialServerDataBuffer = undefined;
+        }
+    }
+    initialServerDataWriter = ctr;
+}
+// When `DOMContentLoaded`, we can close all pending writers to finish hydration.
+const DOMContentLoaded = function() {
+    if (initialServerDataWriter && !initialServerDataFlushed) {
+        initialServerDataWriter.close();
+        initialServerDataFlushed = true;
+        initialServerDataBuffer = undefined;
+    }
+    initialServerDataLoaded = true;
+};
+// It's possible that the DOM is already loaded.
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', DOMContentLoaded, false);
+} else {
+    // Delayed in marco task to ensure it's executed later than hydration
+    setTimeout(DOMContentLoaded);
+}
+const nextServerDataLoadingGlobal = self.__next_f = self.__next_f || [];
+nextServerDataLoadingGlobal.forEach(nextServerDataCallback);
+nextServerDataLoadingGlobal.push = nextServerDataCallback;
+const readable = new ReadableStream({
+    start (controller) {
+        nextServerDataRegisterWriter(controller);
+    }
+});
+const initialServerResponse = createFromReadableStream(readable, {
+    callServer,
+    findSourceMapURL
+});
+function ServerRoot(param) {
+    let { pendingActionQueue } = param;
+    const initialRSCPayload = use(initialServerResponse);
+    const actionQueue = use(pendingActionQueue);
+    const router = /*#__PURE__*/ _jsx(AppRouter, {
+        actionQueue: actionQueue,
+        globalErrorComponentAndStyles: initialRSCPayload.G,
+        assetPrefix: initialRSCPayload.p
+    });
+    if (process.env.NODE_ENV === 'development' && initialRSCPayload.m) {
+        // We provide missing slot information in a context provider only during development
+        // as we log some additional information about the missing slots in the console.
+        return /*#__PURE__*/ _jsx(MissingSlotContext, {
+            value: initialRSCPayload.m,
+            children: router
+        });
+    }
+    return router;
+}
+const StrictModeIfEnabled = process.env.__NEXT_STRICT_MODE_APP ? React.StrictMode : React.Fragment;
+function Root(param) {
+    let { children } = param;
+    if (process.env.__NEXT_TEST_MODE) {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        React.useEffect(()=>{
+            window.__NEXT_HYDRATED = true;
+            window.__NEXT_HYDRATED_AT = performance.now();
+            window.__NEXT_HYDRATED_CB == null ? void 0 : window.__NEXT_HYDRATED_CB.call(window);
+        }, []);
+    }
+    return children;
+}
+const reactRootOptions = {
+    onRecoverableError,
+    onCaughtError,
+    onUncaughtError
+};
+export function hydrate(instrumentationHooks) {
+    // React overrides `.then` and doesn't return a new promise chain,
+    // so we wrap the action queue in a promise to ensure that its value
+    // is defined when the promise resolves.
+    // https://github.com/facebook/react/blob/163365a07872337e04826c4f501565d43dbd2fd4/packages/react-client/src/ReactFlightClient.js#L189-L190
+    const pendingActionQueue = new Promise((resolve, reject)=>{
+        initialServerResponse.then((initialRSCPayload)=>{
+            // setAppBuildId should be called only once, during JS initialization
+            // and before any components have hydrated.
+            setAppBuildId(initialRSCPayload.b);
+            const initialTimestamp = Date.now();
+            resolve(createMutableActionQueue(createInitialRouterState({
+                navigatedAt: initialTimestamp,
+                initialFlightData: initialRSCPayload.f,
+                initialCanonicalUrlParts: initialRSCPayload.c,
+                initialParallelRoutes: new Map(),
+                location: window.location,
+                couldBeIntercepted: initialRSCPayload.i,
+                postponed: initialRSCPayload.s,
+                prerendered: initialRSCPayload.S
+            }), instrumentationHooks));
+        }, (err)=>reject(err));
+    });
+    const reactEl = /*#__PURE__*/ _jsx(StrictModeIfEnabled, {
+        children: /*#__PURE__*/ _jsx(HeadManagerContext.Provider, {
+            value: {
+                appDir: true
+            },
+            children: /*#__PURE__*/ _jsx(Root, {
+                children: /*#__PURE__*/ _jsx(ServerRoot, {
+                    pendingActionQueue: pendingActionQueue
+                })
+            })
+        })
+    });
+    if (document.documentElement.id === '__next_error__') {
+        let element = reactEl;
+        // Server rendering failed, fall back to client-side rendering
+        if (process.env.NODE_ENV !== 'production') {
+            const { createRootLevelDevOverlayElement } = require('./components/react-dev-overlay/app/client-entry');
+            // Note this won't cause hydration mismatch because we are doing CSR w/o hydration
+            element = createRootLevelDevOverlayElement(element);
+        }
+        ReactDOMClient.createRoot(appElement, reactRootOptions).render(element);
+    } else {
+        React.startTransition(()=>{
+            ReactDOMClient.hydrateRoot(appElement, reactEl, {
+                ...reactRootOptions,
+                formState: initialFormStateData
+            });
+        });
+    }
+    // TODO-APP: Remove this logic when Float has GC built-in in development.
+    if (process.env.NODE_ENV !== 'production') {
+        const { linkGc } = require('./app-link-gc');
+        linkGc();
+    }
+}
+
+//# sourceMappingURL=app-index.js.map

node_modules/next/dist/esm/client/app-link-gc.js

@@ -0,0 +1,61 @@
+export function linkGc() {
+    // TODO-APP: Remove this logic when Float has GC built-in in development.
+    if (process.env.NODE_ENV !== 'production') {
+        const callback = (mutationList)=>{
+            for (const mutation of mutationList){
+                if (mutation.type === 'childList') {
+                    for (const node of mutation.addedNodes){
+                        if ('tagName' in node && node.tagName === 'LINK') {
+                            var _link_dataset_precedence;
+                            const link = node;
+                            if ((_link_dataset_precedence = link.dataset.precedence) == null ? void 0 : _link_dataset_precedence.startsWith('next')) {
+                                const href = link.getAttribute('href');
+                                if (href) {
+                                    const [resource, version] = href.split('?v=', 2);
+                                    if (version) {
+                                        const currentOrigin = window.location.origin;
+                                        const allLinks = [
+                                            ...document.querySelectorAll('link[href^="' + resource + '"]'),
+                                            // It's possible that the resource is a full URL or only pathname,
+                                            // so we need to remove the alternative href as well.
+                                            ...document.querySelectorAll('link[href^="' + (resource.startsWith(currentOrigin) ? resource.slice(currentOrigin.length) : currentOrigin + resource) + '"]')
+                                        ];
+                                        for (const otherLink of allLinks){
+                                            var _otherLink_dataset_precedence;
+                                            if ((_otherLink_dataset_precedence = otherLink.dataset.precedence) == null ? void 0 : _otherLink_dataset_precedence.startsWith('next')) {
+                                                const otherHref = otherLink.getAttribute('href');
+                                                if (otherHref) {
+                                                    const [, otherVersion] = otherHref.split('?v=', 2);
+                                                    if (!otherVersion || +otherVersion < +version) {
+                                                        // Delay the removal of the stylesheet to avoid FOUC
+                                                        // caused by `@font-face` rules, as they seem to be
+                                                        // a couple of ticks delayed between the old and new
+                                                        // styles being swapped even if the font is cached.
+                                                        setTimeout(()=>{
+                                                            otherLink.remove();
+                                                        }, 5);
+                                                        const preloadLink = document.querySelector('link[rel="preload"][as="style"][href="' + otherHref + '"]');
+                                                        if (preloadLink) {
+                                                            preloadLink.remove();
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        // Create an observer instance linked to the callback function
+        const observer = new MutationObserver(callback);
+        observer.observe(document.head, {
+            childList: true
+        });
+    }
+}
+
+//# sourceMappingURL=app-link-gc.js.map

node_modules/next/dist/esm/client/app-next-dev.js

@@ -0,0 +1,12 @@
+// TODO-APP: hydration warning
+import './app-webpack';
+import { appBootstrap } from './app-bootstrap';
+import { initializeDevBuildIndicatorForAppRouter } from './dev/dev-build-indicator/initialize-for-app-router';
+const instrumentationHooks = require('../lib/require-instrumentation-client');
+appBootstrap(()=>{
+    const { hydrate } = require('./app-index');
+    hydrate(instrumentationHooks);
+    initializeDevBuildIndicatorForAppRouter();
+});
+
+//# sourceMappingURL=app-next-dev.js.map

node_modules/next/dist/esm/client/app-next-dev.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-next-dev.ts"],"sourcesContent":["// TODO-APP: hydration warning\n\nimport './app-webpack'\n\nimport { appBootstrap } from './app-bootstrap'\nimport { initializeDevBuildIndicatorForAppRouter } from './dev/dev-build-indicator/initialize-for-app-router'\n\nconst instrumentationHooks = require('../lib/require-instrumentation-client')\n\nappBootstrap(() => {\n  const { hydrate } = require('./app-index')\n  hydrate(instrumentationHooks)\n  initializeDevBuildIndicatorForAppRouter()\n})\n"],"names":["appBootstrap","initializeDevBuildIndicatorForAppRouter","instrumentationHooks","require","hydrate"],"mappings":"AAAA,8BAA8B;AAE9B,OAAO,gBAAe;AAEtB,SAASA,YAAY,QAAQ,kBAAiB;AAC9C,SAASC,uCAAuC,QAAQ,sDAAqD;AAE7G,MAAMC,uBAAuBC,QAAQ;AAErCH,aAAa;IACX,MAAM,EAAEI,OAAO,EAAE,GAAGD,QAAQ;IAC5BC,QAAQF;IACRD;AACF"}

node_modules/next/dist/esm/client/app-next-turbopack.js

@@ -0,0 +1,15 @@
+// TODO-APP: hydration warning
+import { appBootstrap } from './app-bootstrap';
+window.next.version += '-turbo';
+self.__webpack_hash__ = '';
+const instrumentationHooks = require('../lib/require-instrumentation-client');
+appBootstrap(()=>{
+    const { hydrate } = require('./app-index');
+    hydrate(instrumentationHooks);
+    if (process.env.NODE_ENV !== 'production') {
+        const { initializeDevBuildIndicatorForAppRouter } = require('./dev/dev-build-indicator/initialize-for-app-router');
+        initializeDevBuildIndicatorForAppRouter();
+    }
+});
+
+//# sourceMappingURL=app-next-turbopack.js.map

node_modules/next/dist/esm/client/app-next-turbopack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-next-turbopack.ts"],"sourcesContent":["// TODO-APP: hydration warning\n\nimport { appBootstrap } from './app-bootstrap'\n\nwindow.next.version += '-turbo'\n;(self as any).__webpack_hash__ = ''\n\nconst instrumentationHooks = require('../lib/require-instrumentation-client')\n\nappBootstrap(() => {\n  const { hydrate } = require('./app-index')\n  hydrate(instrumentationHooks)\n\n  if (process.env.NODE_ENV !== 'production') {\n    const { initializeDevBuildIndicatorForAppRouter } =\n      require('./dev/dev-build-indicator/initialize-for-app-router') as typeof import('./dev/dev-build-indicator/initialize-for-app-router')\n    initializeDevBuildIndicatorForAppRouter()\n  }\n})\n"],"names":["appBootstrap","window","next","version","self","__webpack_hash__","instrumentationHooks","require","hydrate","process","env","NODE_ENV","initializeDevBuildIndicatorForAppRouter"],"mappings":"AAAA,8BAA8B;AAE9B,SAASA,YAAY,QAAQ,kBAAiB;AAE9CC,OAAOC,IAAI,CAACC,OAAO,IAAI;AACrBC,KAAaC,gBAAgB,GAAG;AAElC,MAAMC,uBAAuBC,QAAQ;AAErCP,aAAa;IACX,MAAM,EAAEQ,OAAO,EAAE,GAAGD,QAAQ;IAC5BC,QAAQF;IAER,IAAIG,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAM,EAAEC,uCAAuC,EAAE,GAC/CL,QAAQ;QACVK;IACF;AACF"}

node_modules/next/dist/esm/client/app-next.js

@@ -0,0 +1,14 @@
+// This import must go first because it needs to patch webpack chunk loading
+// before React patches chunk loading.
+import './app-webpack';
+import { appBootstrap } from './app-bootstrap';
+const instrumentationHooks = require('../lib/require-instrumentation-client');
+appBootstrap(()=>{
+    const { hydrate } = require('./app-index');
+    // Include app-router and layout-router in the main chunk
+    require('next/dist/client/components/app-router');
+    require('next/dist/client/components/layout-router');
+    hydrate(instrumentationHooks);
+});
+
+//# sourceMappingURL=app-next.js.map

node_modules/next/dist/esm/client/app-next.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-next.ts"],"sourcesContent":["// This import must go first because it needs to patch webpack chunk loading\n// before React patches chunk loading.\nimport './app-webpack'\nimport { appBootstrap } from './app-bootstrap'\n\nconst instrumentationHooks = require('../lib/require-instrumentation-client')\n\nappBootstrap(() => {\n  const { hydrate } = require('./app-index')\n  // Include app-router and layout-router in the main chunk\n  require('next/dist/client/components/app-router')\n  require('next/dist/client/components/layout-router')\n  hydrate(instrumentationHooks)\n})\n"],"names":["appBootstrap","instrumentationHooks","require","hydrate"],"mappings":"AAAA,4EAA4E;AAC5E,sCAAsC;AACtC,OAAO,gBAAe;AACtB,SAASA,YAAY,QAAQ,kBAAiB;AAE9C,MAAMC,uBAAuBC,QAAQ;AAErCF,aAAa;IACX,MAAM,EAAEG,OAAO,EAAE,GAAGD,QAAQ;IAC5B,yDAAyD;IACzDA,QAAQ;IACRA,QAAQ;IACRC,QAAQF;AACV"}

node_modules/next/dist/esm/client/app-webpack.js

@@ -0,0 +1,56 @@
+// Override chunk URL mapping in the webpack runtime
+// https://github.com/webpack/webpack/blob/2738eebc7880835d88c727d364ad37f3ec557593/lib/RuntimeGlobals.js#L204
+import { getDeploymentIdQueryOrEmptyString } from '../build/deployment-id';
+import { encodeURIPath } from '../shared/lib/encode-uri-path';
+// If we have a deployment ID, we need to append it to the webpack chunk names
+// I am keeping the process check explicit so this can be statically optimized
+if (process.env.NEXT_DEPLOYMENT_ID) {
+    const suffix = getDeploymentIdQueryOrEmptyString();
+    // eslint-disable-next-line no-undef
+    const getChunkScriptFilename = __webpack_require__.u;
+    // eslint-disable-next-line no-undef
+    __webpack_require__.u = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return(// We encode the chunk filename because our static server matches against and encoded
+        // filename path.
+        encodeURIPath(getChunkScriptFilename(...args)) + suffix);
+    };
+    // eslint-disable-next-line no-undef
+    const getChunkCssFilename = __webpack_require__.k;
+    // eslint-disable-next-line no-undef
+    __webpack_require__.k = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return getChunkCssFilename(...args) + suffix;
+    };
+    // eslint-disable-next-line no-undef
+    const getMiniCssFilename = __webpack_require__.miniCssF;
+    // eslint-disable-next-line no-undef
+    __webpack_require__.miniCssF = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return getMiniCssFilename(...args) + suffix;
+    };
+} else {
+    // eslint-disable-next-line no-undef
+    const getChunkScriptFilename = __webpack_require__.u;
+    // eslint-disable-next-line no-undef
+    __webpack_require__.u = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return(// We encode the chunk filename because our static server matches against and encoded
+        // filename path.
+        encodeURIPath(getChunkScriptFilename(...args)));
+    };
+// We don't need to override __webpack_require__.k because we don't modify
+// the css chunk name when not using deployment id suffixes
+// WE don't need to override __webpack_require__.miniCssF because we don't modify
+// the mini css chunk name when not using deployment id suffixes
+}
+
+//# sourceMappingURL=app-webpack.js.map

node_modules/next/dist/esm/client/app-webpack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/app-webpack.ts"],"sourcesContent":["// Override chunk URL mapping in the webpack runtime\n// https://github.com/webpack/webpack/blob/2738eebc7880835d88c727d364ad37f3ec557593/lib/RuntimeGlobals.js#L204\n\nimport { getDeploymentIdQueryOrEmptyString } from '../build/deployment-id'\nimport { encodeURIPath } from '../shared/lib/encode-uri-path'\n\ndeclare const __webpack_require__: any\n\n// If we have a deployment ID, we need to append it to the webpack chunk names\n// I am keeping the process check explicit so this can be statically optimized\nif (process.env.NEXT_DEPLOYMENT_ID) {\n  const suffix = getDeploymentIdQueryOrEmptyString()\n  // eslint-disable-next-line no-undef\n  const getChunkScriptFilename = __webpack_require__.u\n  // eslint-disable-next-line no-undef\n  __webpack_require__.u = (...args: any[]) =>\n    // We encode the chunk filename because our static server matches against and encoded\n    // filename path.\n    encodeURIPath(getChunkScriptFilename(...args)) + suffix\n\n  // eslint-disable-next-line no-undef\n  const getChunkCssFilename = __webpack_require__.k\n  // eslint-disable-next-line no-undef\n  __webpack_require__.k = (...args: any[]) =>\n    getChunkCssFilename(...args) + suffix\n\n  // eslint-disable-next-line no-undef\n  const getMiniCssFilename = __webpack_require__.miniCssF\n  // eslint-disable-next-line no-undef\n  __webpack_require__.miniCssF = (...args: any[]) =>\n    getMiniCssFilename(...args) + suffix\n} else {\n  // eslint-disable-next-line no-undef\n  const getChunkScriptFilename = __webpack_require__.u\n  // eslint-disable-next-line no-undef\n  __webpack_require__.u = (...args: any[]) =>\n    // We encode the chunk filename because our static server matches against and encoded\n    // filename path.\n    encodeURIPath(getChunkScriptFilename(...args))\n\n  // We don't need to override __webpack_require__.k because we don't modify\n  // the css chunk name when not using deployment id suffixes\n\n  // WE don't need to override __webpack_require__.miniCssF because we don't modify\n  // the mini css chunk name when not using deployment id suffixes\n}\n\nexport {}\n"],"names":["getDeploymentIdQueryOrEmptyString","encodeURIPath","process","env","NEXT_DEPLOYMENT_ID","suffix","getChunkScriptFilename","__webpack_require__","u","args","getChunkCssFilename","k","getMiniCssFilename","miniCssF"],"mappings":"AAAA,oDAAoD;AACpD,8GAA8G;AAE9G,SAASA,iCAAiC,QAAQ,yBAAwB;AAC1E,SAASC,aAAa,QAAQ,gCAA+B;AAI7D,8EAA8E;AAC9E,8EAA8E;AAC9E,IAAIC,QAAQC,GAAG,CAACC,kBAAkB,EAAE;IAClC,MAAMC,SAASL;IACf,oCAAoC;IACpC,MAAMM,yBAAyBC,oBAAoBC,CAAC;IACpD,oCAAoC;IACpCD,oBAAoBC,CAAC,GAAG;yCAAIC;YAAAA;;eAC1B,qFAAqF;QACrF,iBAAiB;QACjBR,cAAcK,0BAA0BG,SAASJ;;IAEnD,oCAAoC;IACpC,MAAMK,sBAAsBH,oBAAoBI,CAAC;IACjD,oCAAoC;IACpCJ,oBAAoBI,CAAC,GAAG;yCAAIF;YAAAA;;eAC1BC,uBAAuBD,QAAQJ;;IAEjC,oCAAoC;IACpC,MAAMO,qBAAqBL,oBAAoBM,QAAQ;IACvD,oCAAoC;IACpCN,oBAAoBM,QAAQ,GAAG;yCAAIJ;YAAAA;;eACjCG,sBAAsBH,QAAQJ;;AAClC,OAAO;IACL,oCAAoC;IACpC,MAAMC,yBAAyBC,oBAAoBC,CAAC;IACpD,oCAAoC;IACpCD,oBAAoBC,CAAC,GAAG;yCAAIC;YAAAA;;eAC1B,qFAAqF;QACrF,iBAAiB;QACjBR,cAAcK,0BAA0BG;;AAE1C,0EAA0E;AAC1E,2DAA2D;AAE3D,iFAAiF;AACjF,gEAAgE;AAClE"}

node_modules/next/dist/esm/client/assign-location.js

@@ -0,0 +1,19 @@
+import { addBasePath } from './add-base-path';
+/**
+ * Function to correctly assign location to URL
+ *
+ * The method will add basePath, and will also correctly add location (including if it is a relative path)
+ * @param location Location that should be added to the url
+ * @param url Base URL to which the location should be assigned
+ */ export function assignLocation(location, url) {
+    if (location.startsWith('.')) {
+        const urlBase = url.origin + url.pathname;
+        return new URL(// In order for a relative path to be added to the current url correctly, the current url must end with a slash
+        // new URL('./relative', 'https://example.com/subdir').href -> 'https://example.com/relative'
+        // new URL('./relative', 'https://example.com/subdir/').href -> 'https://example.com/subdir/relative'
+        (urlBase.endsWith('/') ? urlBase : urlBase + '/') + location);
+    }
+    return new URL(addBasePath(location), url.href);
+}
+
+//# sourceMappingURL=assign-location.js.map

node_modules/next/dist/esm/client/assign-location.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/assign-location.ts"],"sourcesContent":["import { addBasePath } from './add-base-path'\n\n/**\n * Function to correctly assign location to URL\n *\n * The method will add basePath, and will also correctly add location (including if it is a relative path)\n * @param location Location that should be added to the url\n * @param url Base URL to which the location should be assigned\n */\nexport function assignLocation(location: string, url: URL): URL {\n  if (location.startsWith('.')) {\n    const urlBase = url.origin + url.pathname\n    return new URL(\n      // In order for a relative path to be added to the current url correctly, the current url must end with a slash\n      // new URL('./relative', 'https://example.com/subdir').href -> 'https://example.com/relative'\n      // new URL('./relative', 'https://example.com/subdir/').href -> 'https://example.com/subdir/relative'\n      (urlBase.endsWith('/') ? urlBase : urlBase + '/') + location\n    )\n  }\n\n  return new URL(addBasePath(location), url.href)\n}\n"],"names":["addBasePath","assignLocation","location","url","startsWith","urlBase","origin","pathname","URL","endsWith","href"],"mappings":"AAAA,SAASA,WAAW,QAAQ,kBAAiB;AAE7C;;;;;;CAMC,GACD,OAAO,SAASC,eAAeC,QAAgB,EAAEC,GAAQ;IACvD,IAAID,SAASE,UAAU,CAAC,MAAM;QAC5B,MAAMC,UAAUF,IAAIG,MAAM,GAAGH,IAAII,QAAQ;QACzC,OAAO,IAAIC,IAIT,AAHA,+GAA+G;QAC/G,6FAA6F;QAC7F,qGAAqG;QACpGH,CAAAA,QAAQI,QAAQ,CAAC,OAAOJ,UAAUA,UAAU,GAAE,IAAKH;IAExD;IAEA,OAAO,IAAIM,IAAIR,YAAYE,WAAWC,IAAIO,IAAI;AAChD"}

node_modules/next/dist/esm/client/compat/router.js

@@ -0,0 +1,16 @@
+import { useContext } from 'react';
+import { RouterContext } from '../../shared/lib/router-context.shared-runtime';
+/**
+ * useRouter from `next/compat/router` is designed to assist developers
+ * migrating from `pages/` to `app/`. Unlike `next/router`, this hook does not
+ * throw when the `NextRouter` is not mounted, and instead returns `null`. The
+ * more concrete return type here lets developers use this hook within
+ * components that could be shared between both `app/` and `pages/` and handle
+ * to the case where the router is not mounted.
+ *
+ * @returns The `NextRouter` instance if it's available, otherwise `null`.
+ */ export function useRouter() {
+    return useContext(RouterContext);
+}
+
+//# sourceMappingURL=router.js.map

node_modules/next/dist/esm/client/compat/router.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/compat/router.ts"],"sourcesContent":["import { useContext } from 'react'\nimport { RouterContext } from '../../shared/lib/router-context.shared-runtime'\nimport type { NextRouter } from '../router'\n\n/**\n * useRouter from `next/compat/router` is designed to assist developers\n * migrating from `pages/` to `app/`. Unlike `next/router`, this hook does not\n * throw when the `NextRouter` is not mounted, and instead returns `null`. The\n * more concrete return type here lets developers use this hook within\n * components that could be shared between both `app/` and `pages/` and handle\n * to the case where the router is not mounted.\n *\n * @returns The `NextRouter` instance if it's available, otherwise `null`.\n */\nexport function useRouter(): NextRouter | null {\n  return useContext(RouterContext)\n}\n"],"names":["useContext","RouterContext","useRouter"],"mappings":"AAAA,SAASA,UAAU,QAAQ,QAAO;AAClC,SAASC,aAAa,QAAQ,iDAAgD;AAG9E;;;;;;;;;CASC,GACD,OAAO,SAASC;IACd,OAAOF,WAAWC;AACpB"}

node_modules/next/dist/esm/client/components/app-router-announcer.js

@@ -0,0 +1,64 @@
+import { useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+const ANNOUNCER_TYPE = 'next-route-announcer';
+const ANNOUNCER_ID = '__next-route-announcer__';
+function getAnnouncerNode() {
+    var _existingAnnouncer_shadowRoot;
+    const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0];
+    if (existingAnnouncer == null ? void 0 : (_existingAnnouncer_shadowRoot = existingAnnouncer.shadowRoot) == null ? void 0 : _existingAnnouncer_shadowRoot.childNodes[0]) {
+        return existingAnnouncer.shadowRoot.childNodes[0];
+    } else {
+        const container = document.createElement(ANNOUNCER_TYPE);
+        container.style.cssText = 'position:absolute';
+        const announcer = document.createElement('div');
+        announcer.ariaLive = 'assertive';
+        announcer.id = ANNOUNCER_ID;
+        announcer.role = 'alert';
+        announcer.style.cssText = 'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal';
+        // Use shadow DOM here to avoid any potential CSS bleed
+        const shadow = container.attachShadow({
+            mode: 'open'
+        });
+        shadow.appendChild(announcer);
+        document.body.appendChild(container);
+        return announcer;
+    }
+}
+export function AppRouterAnnouncer(param) {
+    let { tree } = param;
+    const [portalNode, setPortalNode] = useState(null);
+    useEffect(()=>{
+        const announcer = getAnnouncerNode();
+        setPortalNode(announcer);
+        return ()=>{
+            const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0];
+            if (container == null ? void 0 : container.isConnected) {
+                document.body.removeChild(container);
+            }
+        };
+    }, []);
+    const [routeAnnouncement, setRouteAnnouncement] = useState('');
+    const previousTitle = useRef(undefined);
+    useEffect(()=>{
+        let currentTitle = '';
+        if (document.title) {
+            currentTitle = document.title;
+        } else {
+            const pageHeader = document.querySelector('h1');
+            if (pageHeader) {
+                currentTitle = pageHeader.innerText || pageHeader.textContent || '';
+            }
+        }
+        // Only announce the title change, but not for the first load because screen
+        // readers do that automatically.
+        if (previousTitle.current !== undefined && previousTitle.current !== currentTitle) {
+            setRouteAnnouncement(currentTitle);
+        }
+        previousTitle.current = currentTitle;
+    }, [
+        tree
+    ]);
+    return portalNode ? /*#__PURE__*/ createPortal(routeAnnouncement, portalNode) : null;
+}
+
+//# sourceMappingURL=app-router-announcer.js.map

node_modules/next/dist/esm/client/components/app-router-announcer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/app-router-announcer.tsx"],"sourcesContent":["import { useEffect, useRef, useState } from 'react'\nimport { createPortal } from 'react-dom'\nimport type { FlightRouterState } from '../../server/app-render/types'\n\nconst ANNOUNCER_TYPE = 'next-route-announcer'\nconst ANNOUNCER_ID = '__next-route-announcer__'\n\nfunction getAnnouncerNode() {\n  const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0]\n  if (existingAnnouncer?.shadowRoot?.childNodes[0]) {\n    return existingAnnouncer.shadowRoot.childNodes[0] as HTMLElement\n  } else {\n    const container = document.createElement(ANNOUNCER_TYPE)\n    container.style.cssText = 'position:absolute'\n    const announcer = document.createElement('div')\n    announcer.ariaLive = 'assertive'\n    announcer.id = ANNOUNCER_ID\n    announcer.role = 'alert'\n    announcer.style.cssText =\n      'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal'\n\n    // Use shadow DOM here to avoid any potential CSS bleed\n    const shadow = container.attachShadow({ mode: 'open' })\n    shadow.appendChild(announcer)\n    document.body.appendChild(container)\n    return announcer\n  }\n}\n\nexport function AppRouterAnnouncer({ tree }: { tree: FlightRouterState }) {\n  const [portalNode, setPortalNode] = useState<HTMLElement | null>(null)\n\n  useEffect(() => {\n    const announcer = getAnnouncerNode()\n    setPortalNode(announcer)\n    return () => {\n      const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0]\n      if (container?.isConnected) {\n        document.body.removeChild(container)\n      }\n    }\n  }, [])\n\n  const [routeAnnouncement, setRouteAnnouncement] = useState('')\n  const previousTitle = useRef<string | undefined>(undefined)\n\n  useEffect(() => {\n    let currentTitle = ''\n    if (document.title) {\n      currentTitle = document.title\n    } else {\n      const pageHeader = document.querySelector('h1')\n      if (pageHeader) {\n        currentTitle = pageHeader.innerText || pageHeader.textContent || ''\n      }\n    }\n\n    // Only announce the title change, but not for the first load because screen\n    // readers do that automatically.\n    if (\n      previousTitle.current !== undefined &&\n      previousTitle.current !== currentTitle\n    ) {\n      setRouteAnnouncement(currentTitle)\n    }\n    previousTitle.current = currentTitle\n  }, [tree])\n\n  return portalNode ? createPortal(routeAnnouncement, portalNode) : null\n}\n"],"names":["useEffect","useRef","useState","createPortal","ANNOUNCER_TYPE","ANNOUNCER_ID","getAnnouncerNode","existingAnnouncer","document","getElementsByName","shadowRoot","childNodes","container","createElement","style","cssText","announcer","ariaLive","id","role","shadow","attachShadow","mode","appendChild","body","AppRouterAnnouncer","tree","portalNode","setPortalNode","getElementsByTagName","isConnected","removeChild","routeAnnouncement","setRouteAnnouncement","previousTitle","undefined","currentTitle","title","pageHeader","querySelector","innerText","textContent","current"],"mappings":"AAAA,SAASA,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,QAAO;AACnD,SAASC,YAAY,QAAQ,YAAW;AAGxC,MAAMC,iBAAiB;AACvB,MAAMC,eAAe;AAErB,SAASC;QAEHC;IADJ,MAAMA,oBAAoBC,SAASC,iBAAiB,CAACL,eAAe,CAAC,EAAE;IACvE,IAAIG,sCAAAA,gCAAAA,kBAAmBG,UAAU,qBAA7BH,8BAA+BI,UAAU,CAAC,EAAE,EAAE;QAChD,OAAOJ,kBAAkBG,UAAU,CAACC,UAAU,CAAC,EAAE;IACnD,OAAO;QACL,MAAMC,YAAYJ,SAASK,aAAa,CAACT;QACzCQ,UAAUE,KAAK,CAACC,OAAO,GAAG;QAC1B,MAAMC,YAAYR,SAASK,aAAa,CAAC;QACzCG,UAAUC,QAAQ,GAAG;QACrBD,UAAUE,EAAE,GAAGb;QACfW,UAAUG,IAAI,GAAG;QACjBH,UAAUF,KAAK,CAACC,OAAO,GACrB;QAEF,uDAAuD;QACvD,MAAMK,SAASR,UAAUS,YAAY,CAAC;YAAEC,MAAM;QAAO;QACrDF,OAAOG,WAAW,CAACP;QACnBR,SAASgB,IAAI,CAACD,WAAW,CAACX;QAC1B,OAAOI;IACT;AACF;AAEA,OAAO,SAASS,mBAAmB,KAAqC;IAArC,IAAA,EAAEC,IAAI,EAA+B,GAArC;IACjC,MAAM,CAACC,YAAYC,cAAc,GAAG1B,SAA6B;IAEjEF,UAAU;QACR,MAAMgB,YAAYV;QAClBsB,cAAcZ;QACd,OAAO;YACL,MAAMJ,YAAYJ,SAASqB,oBAAoB,CAACzB,eAAe,CAAC,EAAE;YAClE,IAAIQ,6BAAAA,UAAWkB,WAAW,EAAE;gBAC1BtB,SAASgB,IAAI,CAACO,WAAW,CAACnB;YAC5B;QACF;IACF,GAAG,EAAE;IAEL,MAAM,CAACoB,mBAAmBC,qBAAqB,GAAG/B,SAAS;IAC3D,MAAMgC,gBAAgBjC,OAA2BkC;IAEjDnC,UAAU;QACR,IAAIoC,eAAe;QACnB,IAAI5B,SAAS6B,KAAK,EAAE;YAClBD,eAAe5B,SAAS6B,KAAK;QAC/B,OAAO;YACL,MAAMC,aAAa9B,SAAS+B,aAAa,CAAC;YAC1C,IAAID,YAAY;gBACdF,eAAeE,WAAWE,SAAS,IAAIF,WAAWG,WAAW,IAAI;YACnE;QACF;QAEA,4EAA4E;QAC5E,iCAAiC;QACjC,IACEP,cAAcQ,OAAO,KAAKP,aAC1BD,cAAcQ,OAAO,KAAKN,cAC1B;YACAH,qBAAqBG;QACvB;QACAF,cAAcQ,OAAO,GAAGN;IAC1B,GAAG;QAACV;KAAK;IAET,OAAOC,2BAAaxB,aAAa6B,mBAAmBL,cAAc;AACpE"}

node_modules/next/dist/esm/client/components/app-router-headers.js

@@ -0,0 +1,31 @@
+export const RSC_HEADER = 'RSC';
+export const ACTION_HEADER = 'Next-Action';
+// TODO: Instead of sending the full router state, we only need to send the
+// segment path. Saves bytes. Then we could also use this field for segment
+// prefetches, which also need to specify a particular segment.
+export const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree';
+export const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch';
+// This contains the path to the segment being prefetched.
+// TODO: If we change Next-Router-State-Tree to be a segment path, we can use
+// that instead. Then Next-Router-Prefetch and Next-Router-Segment-Prefetch can
+// be merged into a single enum.
+export const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'Next-Router-Segment-Prefetch';
+export const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh';
+export const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
+export const NEXT_URL = 'Next-Url';
+export const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
+export const FLIGHT_HEADERS = [
+    RSC_HEADER,
+    NEXT_ROUTER_STATE_TREE_HEADER,
+    NEXT_ROUTER_PREFETCH_HEADER,
+    NEXT_HMR_REFRESH_HEADER,
+    NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+];
+export const NEXT_RSC_UNION_QUERY = '_rsc';
+export const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time';
+export const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed';
+export const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path';
+export const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query';
+export const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender';
+
+//# sourceMappingURL=app-router-headers.js.map

node_modules/next/dist/esm/client/components/app-router-headers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/app-router-headers.ts"],"sourcesContent":["export const RSC_HEADER = 'RSC' as const\nexport const ACTION_HEADER = 'Next-Action' as const\n// TODO: Instead of sending the full router state, we only need to send the\n// segment path. Saves bytes. Then we could also use this field for segment\n// prefetches, which also need to specify a particular segment.\nexport const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree' as const\nexport const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch' as const\n// This contains the path to the segment being prefetched.\n// TODO: If we change Next-Router-State-Tree to be a segment path, we can use\n// that instead. Then Next-Router-Prefetch and Next-Router-Segment-Prefetch can\n// be merged into a single enum.\nexport const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER =\n  'Next-Router-Segment-Prefetch' as const\nexport const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh' as const\nexport const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__' as const\nexport const NEXT_URL = 'Next-Url' as const\nexport const RSC_CONTENT_TYPE_HEADER = 'text/x-component' as const\n\nexport const FLIGHT_HEADERS = [\n  RSC_HEADER,\n  NEXT_ROUTER_STATE_TREE_HEADER,\n  NEXT_ROUTER_PREFETCH_HEADER,\n  NEXT_HMR_REFRESH_HEADER,\n  NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,\n] as const\n\nexport const NEXT_RSC_UNION_QUERY = '_rsc' as const\n\nexport const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time' as const\nexport const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed' as const\nexport const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path' as const\nexport const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query' as const\nexport const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender' as const\n"],"names":["RSC_HEADER","ACTION_HEADER","NEXT_ROUTER_STATE_TREE_HEADER","NEXT_ROUTER_PREFETCH_HEADER","NEXT_ROUTER_SEGMENT_PREFETCH_HEADER","NEXT_HMR_REFRESH_HEADER","NEXT_HMR_REFRESH_HASH_COOKIE","NEXT_URL","RSC_CONTENT_TYPE_HEADER","FLIGHT_HEADERS","NEXT_RSC_UNION_QUERY","NEXT_ROUTER_STALE_TIME_HEADER","NEXT_DID_POSTPONE_HEADER","NEXT_REWRITTEN_PATH_HEADER","NEXT_REWRITTEN_QUERY_HEADER","NEXT_IS_PRERENDER_HEADER"],"mappings":"AAAA,OAAO,MAAMA,aAAa,MAAc;AACxC,OAAO,MAAMC,gBAAgB,cAAsB;AACnD,2EAA2E;AAC3E,2EAA2E;AAC3E,+DAA+D;AAC/D,OAAO,MAAMC,gCAAgC,yBAAiC;AAC9E,OAAO,MAAMC,8BAA8B,uBAA+B;AAC1E,0DAA0D;AAC1D,6EAA6E;AAC7E,+EAA+E;AAC/E,gCAAgC;AAChC,OAAO,MAAMC,sCACX,+BAAuC;AACzC,OAAO,MAAMC,0BAA0B,mBAA2B;AAClE,OAAO,MAAMC,+BAA+B,4BAAoC;AAChF,OAAO,MAAMC,WAAW,WAAmB;AAC3C,OAAO,MAAMC,0BAA0B,mBAA2B;AAElE,OAAO,MAAMC,iBAAiB;IAC5BT;IACAE;IACAC;IACAE;IACAD;CACD,CAAS;AAEV,OAAO,MAAMM,uBAAuB,OAAe;AAEnD,OAAO,MAAMC,gCAAgC,sBAA8B;AAC3E,OAAO,MAAMC,2BAA2B,qBAA6B;AACrE,OAAO,MAAMC,6BAA6B,0BAAkC;AAC5E,OAAO,MAAMC,8BAA8B,2BAAmC;AAC9E,OAAO,MAAMC,2BAA2B,qBAA6B"}

node_modules/next/dist/esm/client/components/app-router-instance.js

@@ -0,0 +1,275 @@
+import { ACTION_REFRESH, ACTION_SERVER_ACTION, ACTION_NAVIGATE, ACTION_RESTORE, ACTION_HMR_REFRESH, PrefetchKind, ACTION_PREFETCH } from './router-reducer/router-reducer-types';
+import { reducer } from './router-reducer/router-reducer';
+import { startTransition } from 'react';
+import { isThenable } from '../../shared/lib/is-thenable';
+import { prefetch as prefetchWithSegmentCache } from './segment-cache';
+import { dispatchAppRouterAction } from './use-action-queue';
+import { addBasePath } from '../add-base-path';
+import { createPrefetchURL, isExternalURL } from './app-router';
+import { prefetchReducer } from './router-reducer/reducers/prefetch-reducer';
+import { setLinkForCurrentNavigation } from './links';
+function runRemainingActions(actionQueue, setState) {
+    if (actionQueue.pending !== null) {
+        actionQueue.pending = actionQueue.pending.next;
+        if (actionQueue.pending !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            runAction({
+                actionQueue,
+                action: actionQueue.pending,
+                setState
+            });
+        } else {
+            // No more actions are pending, check if a refresh is needed
+            if (actionQueue.needsRefresh) {
+                actionQueue.needsRefresh = false;
+                actionQueue.dispatch({
+                    type: ACTION_REFRESH,
+                    origin: window.location.origin
+                }, setState);
+            }
+        }
+    }
+}
+async function runAction(param) {
+    let { actionQueue, action, setState } = param;
+    const prevState = actionQueue.state;
+    actionQueue.pending = action;
+    const payload = action.payload;
+    const actionResult = actionQueue.action(prevState, payload);
+    function handleResult(nextState) {
+        // if we discarded this action, the state should also be discarded
+        if (action.discarded) {
+            return;
+        }
+        actionQueue.state = nextState;
+        runRemainingActions(actionQueue, setState);
+        action.resolve(nextState);
+    }
+    // if the action is a promise, set up a callback to resolve it
+    if (isThenable(actionResult)) {
+        actionResult.then(handleResult, (err)=>{
+            runRemainingActions(actionQueue, setState);
+            action.reject(err);
+        });
+    } else {
+        handleResult(actionResult);
+    }
+}
+function dispatchAction(actionQueue, payload, setState) {
+    let resolvers = {
+        resolve: setState,
+        reject: ()=>{}
+    };
+    // most of the action types are async with the exception of restore
+    // it's important that restore is handled quickly since it's fired on the popstate event
+    // and we don't want to add any delay on a back/forward nav
+    // this only creates a promise for the async actions
+    if (payload.type !== ACTION_RESTORE) {
+        // Create the promise and assign the resolvers to the object.
+        const deferredPromise = new Promise((resolve, reject)=>{
+            resolvers = {
+                resolve,
+                reject
+            };
+        });
+        startTransition(()=>{
+            // we immediately notify React of the pending promise -- the resolver is attached to the action node
+            // and will be called when the associated action promise resolves
+            setState(deferredPromise);
+        });
+    }
+    const newAction = {
+        payload,
+        next: null,
+        resolve: resolvers.resolve,
+        reject: resolvers.reject
+    };
+    // Check if the queue is empty
+    if (actionQueue.pending === null) {
+        // The queue is empty, so add the action and start it immediately
+        // Mark this action as the last in the queue
+        actionQueue.last = newAction;
+        runAction({
+            actionQueue,
+            action: newAction,
+            setState
+        });
+    } else if (payload.type === ACTION_NAVIGATE || payload.type === ACTION_RESTORE) {
+        // Navigations (including back/forward) take priority over any pending actions.
+        // Mark the pending action as discarded (so the state is never applied) and start the navigation action immediately.
+        actionQueue.pending.discarded = true;
+        // The rest of the current queue should still execute after this navigation.
+        // (Note that it can't contain any earlier navigations, because we always put those into `actionQueue.pending` by calling `runAction`)
+        newAction.next = actionQueue.pending.next;
+        // if the pending action was a server action, mark the queue as needing a refresh once events are processed
+        if (actionQueue.pending.payload.type === ACTION_SERVER_ACTION) {
+            actionQueue.needsRefresh = true;
+        }
+        runAction({
+            actionQueue,
+            action: newAction,
+            setState
+        });
+    } else {
+        // The queue is not empty, so add the action to the end of the queue
+        // It will be started by runRemainingActions after the previous action finishes
+        if (actionQueue.last !== null) {
+            actionQueue.last.next = newAction;
+        }
+        actionQueue.last = newAction;
+    }
+}
+let globalActionQueue = null;
+export function createMutableActionQueue(initialState, instrumentationHooks) {
+    const actionQueue = {
+        state: initialState,
+        dispatch: (payload, setState)=>dispatchAction(actionQueue, payload, setState),
+        action: async (state, action)=>{
+            const result = reducer(state, action);
+            return result;
+        },
+        pending: null,
+        last: null,
+        onRouterTransitionStart: instrumentationHooks !== null && typeof instrumentationHooks.onRouterTransitionStart === 'function' ? instrumentationHooks.onRouterTransitionStart : null
+    };
+    if (typeof window !== 'undefined') {
+        // The action queue is lazily created on hydration, but after that point
+        // it doesn't change. So we can store it in a global rather than pass
+        // it around everywhere via props/context.
+        if (globalActionQueue !== null) {
+            throw Object.defineProperty(new Error('Internal Next.js Error: createMutableActionQueue was called more ' + 'than once'), "__NEXT_ERROR_CODE", {
+                value: "E624",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        globalActionQueue = actionQueue;
+    }
+    return actionQueue;
+}
+export function getCurrentAppRouterState() {
+    return globalActionQueue !== null ? globalActionQueue.state : null;
+}
+function getAppRouterActionQueue() {
+    if (globalActionQueue === null) {
+        throw Object.defineProperty(new Error('Internal Next.js error: Router action dispatched before initialization.'), "__NEXT_ERROR_CODE", {
+            value: "E668",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return globalActionQueue;
+}
+function getProfilingHookForOnNavigationStart() {
+    if (globalActionQueue !== null) {
+        return globalActionQueue.onRouterTransitionStart;
+    }
+    return null;
+}
+export function dispatchNavigateAction(href, navigateType, shouldScroll, linkInstanceRef) {
+    // TODO: This stuff could just go into the reducer. Leaving as-is for now
+    // since we're about to rewrite all the router reducer stuff anyway.
+    const url = new URL(addBasePath(href), location.href);
+    if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+        window.next.__pendingUrl = url;
+    }
+    setLinkForCurrentNavigation(linkInstanceRef);
+    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
+    if (onRouterTransitionStart !== null) {
+        onRouterTransitionStart(href, navigateType);
+    }
+    dispatchAppRouterAction({
+        type: ACTION_NAVIGATE,
+        url,
+        isExternalUrl: isExternalURL(url),
+        locationSearch: location.search,
+        shouldScroll,
+        navigateType,
+        allowAliasing: true
+    });
+}
+export function dispatchTraverseAction(href, tree) {
+    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
+    if (onRouterTransitionStart !== null) {
+        onRouterTransitionStart(href, 'traverse');
+    }
+    dispatchAppRouterAction({
+        type: ACTION_RESTORE,
+        url: new URL(href),
+        tree
+    });
+}
+/**
+ * The app router that is exposed through `useRouter`. These are public API
+ * methods. Internal Next.js code should call the lower level methods directly
+ * (although there's lots of existing code that doesn't do that).
+ */ export const publicAppRouterInstance = {
+    back: ()=>window.history.back(),
+    forward: ()=>window.history.forward(),
+    prefetch: process.env.__NEXT_CLIENT_SEGMENT_CACHE ? // data in the router reducer state; it writes into a global mutable
+    // cache. So we don't need to dispatch an action.
+    (href, options)=>{
+        const actionQueue = getAppRouterActionQueue();
+        prefetchWithSegmentCache(href, actionQueue.state.nextUrl, actionQueue.state.tree, (options == null ? void 0 : options.kind) === PrefetchKind.FULL);
+    } : (href, options)=>{
+        // Use the old prefetch implementation.
+        const actionQueue = getAppRouterActionQueue();
+        const url = createPrefetchURL(href);
+        if (url !== null) {
+            var _options_kind;
+            // The prefetch reducer doesn't actually update any state or
+            // trigger a rerender. It just writes to a mutable cache. So we
+            // shouldn't bother calling setState/dispatch; we can just re-run
+            // the reducer directly using the current state.
+            // TODO: Refactor this away from a "reducer" so it's
+            // less confusing.
+            prefetchReducer(actionQueue.state, {
+                type: ACTION_PREFETCH,
+                url,
+                kind: (_options_kind = options == null ? void 0 : options.kind) != null ? _options_kind : PrefetchKind.FULL
+            });
+        }
+    },
+    replace: (href, options)=>{
+        startTransition(()=>{
+            var _options_scroll;
+            dispatchNavigateAction(href, 'replace', (_options_scroll = options == null ? void 0 : options.scroll) != null ? _options_scroll : true, null);
+        });
+    },
+    push: (href, options)=>{
+        startTransition(()=>{
+            var _options_scroll;
+            dispatchNavigateAction(href, 'push', (_options_scroll = options == null ? void 0 : options.scroll) != null ? _options_scroll : true, null);
+        });
+    },
+    refresh: ()=>{
+        startTransition(()=>{
+            dispatchAppRouterAction({
+                type: ACTION_REFRESH,
+                origin: window.location.origin
+            });
+        });
+    },
+    hmrRefresh: ()=>{
+        if (process.env.NODE_ENV !== 'development') {
+            throw Object.defineProperty(new Error('hmrRefresh can only be used in development mode. Please use refresh instead.'), "__NEXT_ERROR_CODE", {
+                value: "E485",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            startTransition(()=>{
+                dispatchAppRouterAction({
+                    type: ACTION_HMR_REFRESH,
+                    origin: window.location.origin
+                });
+            });
+        }
+    }
+};
+// Exists for debugging purposes. Don't use in application code.
+if (typeof window !== 'undefined' && window.next) {
+    window.next.router = publicAppRouterInstance;
+}
+
+//# sourceMappingURL=app-router-instance.js.map

node_modules/next/dist/esm/client/components/app-router.js

@@ -0,0 +1,505 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { use, useEffect, useMemo, startTransition, useInsertionEffect, useDeferredValue } from 'react';
+import { AppRouterContext, LayoutRouterContext, GlobalLayoutRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { ACTION_RESTORE } from './router-reducer/router-reducer-types';
+import { createHrefFromUrl } from './router-reducer/create-href-from-url';
+import { SearchParamsContext, PathnameContext, PathParamsContext } from '../../shared/lib/hooks-client-context.shared-runtime';
+import { dispatchAppRouterAction, useActionQueue } from './use-action-queue';
+import { default as DefaultGlobalError, ErrorBoundary } from './error-boundary';
+import { isBot } from '../../shared/lib/router/utils/is-bot';
+import { addBasePath } from '../add-base-path';
+import { AppRouterAnnouncer } from './app-router-announcer';
+import { RedirectBoundary } from './redirect-boundary';
+import { findHeadInCache } from './router-reducer/reducers/find-head-in-cache';
+import { unresolvedThenable } from './unresolved-thenable';
+import { removeBasePath } from '../remove-base-path';
+import { hasBasePath } from '../has-base-path';
+import { getSelectedParams } from './router-reducer/compute-changed-path';
+import { useNavFailureHandler } from './nav-failure-handler';
+import { dispatchTraverseAction, publicAppRouterInstance } from './app-router-instance';
+import { getRedirectTypeFromError, getURLFromRedirectError } from './redirect';
+import { isRedirectError, RedirectType } from './redirect-error';
+import { pingVisibleLinks } from './links';
+const globalMutable = {};
+export function isExternalURL(url) {
+    return url.origin !== window.location.origin;
+}
+/**
+ * Given a link href, constructs the URL that should be prefetched. Returns null
+ * in cases where prefetching should be disabled, like external URLs, or
+ * during development.
+ * @param href The href passed to <Link>, router.prefetch(), or similar
+ * @returns A URL object to prefetch, or null if prefetching should be disabled
+ */ export function createPrefetchURL(href) {
+    // Don't prefetch for bots as they don't navigate.
+    if (isBot(window.navigator.userAgent)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(addBasePath(href), window.location.href);
+    } catch (_) {
+        // TODO: Does this need to throw or can we just console.error instead? Does
+        // anyone rely on this throwing? (Seems unlikely.)
+        throw Object.defineProperty(new Error("Cannot prefetch '" + href + "' because it cannot be converted to a URL."), "__NEXT_ERROR_CODE", {
+            value: "E234",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Don't prefetch during development (improves compilation performance)
+    if (process.env.NODE_ENV === 'development') {
+        return null;
+    }
+    // External urls can't be prefetched in the same way.
+    if (isExternalURL(url)) {
+        return null;
+    }
+    return url;
+}
+function HistoryUpdater(param) {
+    let { appRouterState } = param;
+    useInsertionEffect(()=>{
+        if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+            // clear pending URL as navigation is no longer
+            // in flight
+            window.next.__pendingUrl = undefined;
+        }
+        const { tree, pushRef, canonicalUrl } = appRouterState;
+        const historyState = {
+            ...pushRef.preserveCustomHistoryState ? window.history.state : {},
+            // Identifier is shortened intentionally.
+            // __NA is used to identify if the history entry can be handled by the app-router.
+            // __N is used to identify if the history entry can be handled by the old router.
+            __NA: true,
+            __PRIVATE_NEXTJS_INTERNALS_TREE: tree
+        };
+        if (pushRef.pendingPush && // Skip pushing an additional history entry if the canonicalUrl is the same as the current url.
+        // This mirrors the browser behavior for normal navigation.
+        createHrefFromUrl(new URL(window.location.href)) !== canonicalUrl) {
+            // This intentionally mutates React state, pushRef is overwritten to ensure additional push/replace calls do not trigger an additional history entry.
+            pushRef.pendingPush = false;
+            window.history.pushState(historyState, '', canonicalUrl);
+        } else {
+            window.history.replaceState(historyState, '', canonicalUrl);
+        }
+    }, [
+        appRouterState
+    ]);
+    useEffect(()=>{
+        // The Next-Url and the base tree may affect the result of a prefetch
+        // task. Re-prefetch all visible links with the updated values. In most
+        // cases, this will not result in any new network requests, only if
+        // the prefetch result actually varies on one of these inputs.
+        if (process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
+            pingVisibleLinks(appRouterState.nextUrl, appRouterState.tree);
+        }
+    }, [
+        appRouterState.nextUrl,
+        appRouterState.tree
+    ]);
+    return null;
+}
+export function createEmptyCacheNode() {
+    return {
+        lazyData: null,
+        rsc: null,
+        prefetchRsc: null,
+        head: null,
+        prefetchHead: null,
+        parallelRoutes: new Map(),
+        loading: null,
+        navigatedAt: -1
+    };
+}
+function copyNextJsInternalHistoryState(data) {
+    if (data == null) data = {};
+    const currentState = window.history.state;
+    const __NA = currentState == null ? void 0 : currentState.__NA;
+    if (__NA) {
+        data.__NA = __NA;
+    }
+    const __PRIVATE_NEXTJS_INTERNALS_TREE = currentState == null ? void 0 : currentState.__PRIVATE_NEXTJS_INTERNALS_TREE;
+    if (__PRIVATE_NEXTJS_INTERNALS_TREE) {
+        data.__PRIVATE_NEXTJS_INTERNALS_TREE = __PRIVATE_NEXTJS_INTERNALS_TREE;
+    }
+    return data;
+}
+function Head(param) {
+    let { headCacheNode } = param;
+    // If this segment has a `prefetchHead`, it's the statically prefetched data.
+    // We should use that on initial render instead of `head`. Then we'll switch
+    // to `head` when the dynamic response streams in.
+    const head = headCacheNode !== null ? headCacheNode.head : null;
+    const prefetchHead = headCacheNode !== null ? headCacheNode.prefetchHead : null;
+    // If no prefetch data is available, then we go straight to rendering `head`.
+    const resolvedPrefetchRsc = prefetchHead !== null ? prefetchHead : head;
+    // We use `useDeferredValue` to handle switching between the prefetched and
+    // final values. The second argument is returned on initial render, then it
+    // re-renders with the first argument.
+    return useDeferredValue(head, resolvedPrefetchRsc);
+}
+/**
+ * The global router that wraps the application components.
+ */ function Router(param) {
+    let { actionQueue, assetPrefix, globalError } = param;
+    const state = useActionQueue(actionQueue);
+    const { canonicalUrl } = state;
+    // Add memoized pathname/query for useSearchParams and usePathname.
+    const { searchParams, pathname } = useMemo(()=>{
+        const url = new URL(canonicalUrl, typeof window === 'undefined' ? 'http://n' : window.location.href);
+        return {
+            // This is turned into a readonly class in `useSearchParams`
+            searchParams: url.searchParams,
+            pathname: hasBasePath(url.pathname) ? removeBasePath(url.pathname) : url.pathname
+        };
+    }, [
+        canonicalUrl
+    ]);
+    if (process.env.NODE_ENV !== 'production') {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { cache, prefetchCache, tree } = state;
+        // This hook is in a conditional but that is ok because `process.env.NODE_ENV` never changes
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useEffect(()=>{
+            // Add `window.nd` for debugging purposes.
+            // This is not meant for use in applications as concurrent rendering will affect the cache/tree/router.
+            // @ts-ignore this is for debugging
+            window.nd = {
+                router: publicAppRouterInstance,
+                cache,
+                prefetchCache,
+                tree
+            };
+        }, [
+            cache,
+            prefetchCache,
+            tree
+        ]);
+    }
+    useEffect(()=>{
+        // If the app is restored from bfcache, it's possible that
+        // pushRef.mpaNavigation is true, which would mean that any re-render of this component
+        // would trigger the mpa navigation logic again from the lines below.
+        // This will restore the router to the initial state in the event that the app is restored from bfcache.
+        function handlePageShow(event) {
+            var _window_history_state;
+            if (!event.persisted || !((_window_history_state = window.history.state) == null ? void 0 : _window_history_state.__PRIVATE_NEXTJS_INTERNALS_TREE)) {
+                return;
+            }
+            // Clear the pendingMpaPath value so that a subsequent MPA navigation to the same URL can be triggered.
+            // This is necessary because if the browser restored from bfcache, the pendingMpaPath would still be set to the value
+            // of the last MPA navigation.
+            globalMutable.pendingMpaPath = undefined;
+            dispatchAppRouterAction({
+                type: ACTION_RESTORE,
+                url: new URL(window.location.href),
+                tree: window.history.state.__PRIVATE_NEXTJS_INTERNALS_TREE
+            });
+        }
+        window.addEventListener('pageshow', handlePageShow);
+        return ()=>{
+            window.removeEventListener('pageshow', handlePageShow);
+        };
+    }, []);
+    useEffect(()=>{
+        // Ensure that any redirect errors that bubble up outside of the RedirectBoundary
+        // are caught and handled by the router.
+        function handleUnhandledRedirect(event) {
+            const error = 'reason' in event ? event.reason : event.error;
+            if (isRedirectError(error)) {
+                event.preventDefault();
+                const url = getURLFromRedirectError(error);
+                const redirectType = getRedirectTypeFromError(error);
+                // TODO: This should access the router methods directly, rather than
+                // go through the public interface.
+                if (redirectType === RedirectType.push) {
+                    publicAppRouterInstance.push(url, {});
+                } else {
+                    publicAppRouterInstance.replace(url, {});
+                }
+            }
+        }
+        window.addEventListener('error', handleUnhandledRedirect);
+        window.addEventListener('unhandledrejection', handleUnhandledRedirect);
+        return ()=>{
+            window.removeEventListener('error', handleUnhandledRedirect);
+            window.removeEventListener('unhandledrejection', handleUnhandledRedirect);
+        };
+    }, []);
+    // When mpaNavigation flag is set do a hard navigation to the new url.
+    // Infinitely suspend because we don't actually want to rerender any child
+    // components with the new URL and any entangled state updates shouldn't
+    // commit either (eg: useTransition isPending should stay true until the page
+    // unloads).
+    //
+    // This is a side effect in render. Don't try this at home, kids. It's
+    // probably safe because we know this is a singleton component and it's never
+    // in <Offscreen>. At least I hope so. (It will run twice in dev strict mode,
+    // but that's... fine?)
+    const { pushRef } = state;
+    if (pushRef.mpaNavigation) {
+        // if there's a re-render, we don't want to trigger another redirect if one is already in flight to the same URL
+        if (globalMutable.pendingMpaPath !== canonicalUrl) {
+            const location = window.location;
+            if (pushRef.pendingPush) {
+                location.assign(canonicalUrl);
+            } else {
+                location.replace(canonicalUrl);
+            }
+            globalMutable.pendingMpaPath = canonicalUrl;
+        }
+        // TODO-APP: Should we listen to navigateerror here to catch failed
+        // navigations somehow? And should we call window.stop() if a SPA navigation
+        // should interrupt an MPA one?
+        use(unresolvedThenable);
+    }
+    useEffect(()=>{
+        const originalPushState = window.history.pushState.bind(window.history);
+        const originalReplaceState = window.history.replaceState.bind(window.history);
+        // Ensure the canonical URL in the Next.js Router is updated when the URL is changed so that `usePathname` and `useSearchParams` hold the pushed values.
+        const applyUrlFromHistoryPushReplace = (url)=>{
+            var _window_history_state;
+            const href = window.location.href;
+            const tree = (_window_history_state = window.history.state) == null ? void 0 : _window_history_state.__PRIVATE_NEXTJS_INTERNALS_TREE;
+            startTransition(()=>{
+                dispatchAppRouterAction({
+                    type: ACTION_RESTORE,
+                    url: new URL(url != null ? url : href, href),
+                    tree
+                });
+            });
+        };
+        /**
+     * Patch pushState to ensure external changes to the history are reflected in the Next.js Router.
+     * Ensures Next.js internal history state is copied to the new history entry.
+     * Ensures usePathname and useSearchParams hold the newly provided url.
+     */ window.history.pushState = function pushState(data, _unused, url) {
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if ((data == null ? void 0 : data.__NA) || (data == null ? void 0 : data._N)) {
+                return originalPushState(data, _unused, url);
+            }
+            data = copyNextJsInternalHistoryState(data);
+            if (url) {
+                applyUrlFromHistoryPushReplace(url);
+            }
+            return originalPushState(data, _unused, url);
+        };
+        /**
+     * Patch replaceState to ensure external changes to the history are reflected in the Next.js Router.
+     * Ensures Next.js internal history state is copied to the new history entry.
+     * Ensures usePathname and useSearchParams hold the newly provided url.
+     */ window.history.replaceState = function replaceState(data, _unused, url) {
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if ((data == null ? void 0 : data.__NA) || (data == null ? void 0 : data._N)) {
+                return originalReplaceState(data, _unused, url);
+            }
+            data = copyNextJsInternalHistoryState(data);
+            if (url) {
+                applyUrlFromHistoryPushReplace(url);
+            }
+            return originalReplaceState(data, _unused, url);
+        };
+        /**
+     * Handle popstate event, this is used to handle back/forward in the browser.
+     * By default dispatches ACTION_RESTORE, however if the history entry was not pushed/replaced by app-router it will reload the page.
+     * That case can happen when the old router injected the history entry.
+     */ const onPopState = (event)=>{
+            if (!event.state) {
+                // TODO-APP: this case only happens when pushState/replaceState was called outside of Next.js. It should probably reload the page in this case.
+                return;
+            }
+            // This case happens when the history entry was pushed by the `pages` router.
+            if (!event.state.__NA) {
+                window.location.reload();
+                return;
+            }
+            // TODO-APP: Ideally the back button should not use startTransition as it should apply the updates synchronously
+            // Without startTransition works if the cache is there for this path
+            startTransition(()=>{
+                dispatchTraverseAction(window.location.href, event.state.__PRIVATE_NEXTJS_INTERNALS_TREE);
+            });
+        };
+        // Register popstate event to call onPopstate.
+        window.addEventListener('popstate', onPopState);
+        return ()=>{
+            window.history.pushState = originalPushState;
+            window.history.replaceState = originalReplaceState;
+            window.removeEventListener('popstate', onPopState);
+        };
+    }, []);
+    const { cache, tree, nextUrl, focusAndScrollRef } = state;
+    const matchingHead = useMemo(()=>{
+        return findHeadInCache(cache, tree[1]);
+    }, [
+        cache,
+        tree
+    ]);
+    // Add memoized pathParams for useParams.
+    const pathParams = useMemo(()=>{
+        return getSelectedParams(tree);
+    }, [
+        tree
+    ]);
+    const layoutRouterContext = useMemo(()=>{
+        return {
+            parentTree: tree,
+            parentCacheNode: cache,
+            parentSegmentPath: null,
+            // Root node always has `url`
+            // Provided in AppTreeContext to ensure it can be overwritten in layout-router
+            url: canonicalUrl
+        };
+    }, [
+        tree,
+        cache,
+        canonicalUrl
+    ]);
+    const globalLayoutRouterContext = useMemo(()=>{
+        return {
+            tree,
+            focusAndScrollRef,
+            nextUrl
+        };
+    }, [
+        tree,
+        focusAndScrollRef,
+        nextUrl
+    ]);
+    let head;
+    if (matchingHead !== null) {
+        // The head is wrapped in an extra component so we can use
+        // `useDeferredValue` to swap between the prefetched and final versions of
+        // the head. (This is what LayoutRouter does for segment data, too.)
+        //
+        // The `key` is used to remount the component whenever the head moves to
+        // a different segment.
+        const [headCacheNode, headKey] = matchingHead;
+        head = /*#__PURE__*/ _jsx(Head, {
+            headCacheNode: headCacheNode
+        }, headKey);
+    } else {
+        head = null;
+    }
+    let content = /*#__PURE__*/ _jsxs(RedirectBoundary, {
+        children: [
+            head,
+            cache.rsc,
+            /*#__PURE__*/ _jsx(AppRouterAnnouncer, {
+                tree: tree
+            })
+        ]
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        // In development, we apply few error boundaries and hot-reloader:
+        // - DevRootHTTPAccessFallbackBoundary: avoid using navigation API like notFound() in root layout
+        // - HotReloader:
+        //  - hot-reload the app when the code changes
+        //  - render dev overlay
+        //  - catch runtime errors and display global-error when necessary
+        if (typeof window !== 'undefined') {
+            const { DevRootHTTPAccessFallbackBoundary } = require('./dev-root-http-access-fallback-boundary');
+            content = /*#__PURE__*/ _jsx(DevRootHTTPAccessFallbackBoundary, {
+                children: content
+            });
+        }
+        const HotReloader = require('./react-dev-overlay/app/hot-reloader-client').default;
+        content = /*#__PURE__*/ _jsx(HotReloader, {
+            assetPrefix: assetPrefix,
+            globalError: globalError,
+            children: content
+        });
+    } else {
+        // In production, we only apply the user-customized global error boundary.
+        content = /*#__PURE__*/ _jsx(ErrorBoundary, {
+            errorComponent: globalError[0],
+            errorStyles: globalError[1],
+            children: content
+        });
+    }
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(HistoryUpdater, {
+                appRouterState: state
+            }),
+            /*#__PURE__*/ _jsx(RuntimeStyles, {}),
+            /*#__PURE__*/ _jsx(PathParamsContext.Provider, {
+                value: pathParams,
+                children: /*#__PURE__*/ _jsx(PathnameContext.Provider, {
+                    value: pathname,
+                    children: /*#__PURE__*/ _jsx(SearchParamsContext.Provider, {
+                        value: searchParams,
+                        children: /*#__PURE__*/ _jsx(GlobalLayoutRouterContext.Provider, {
+                            value: globalLayoutRouterContext,
+                            children: /*#__PURE__*/ _jsx(AppRouterContext.Provider, {
+                                value: publicAppRouterInstance,
+                                children: /*#__PURE__*/ _jsx(LayoutRouterContext.Provider, {
+                                    value: layoutRouterContext,
+                                    children: content
+                                })
+                            })
+                        })
+                    })
+                })
+            })
+        ]
+    });
+}
+export default function AppRouter(param) {
+    let { actionQueue, globalErrorComponentAndStyles: [globalErrorComponent, globalErrorStyles], assetPrefix } = param;
+    useNavFailureHandler();
+    return /*#__PURE__*/ _jsx(ErrorBoundary, {
+        // At the very top level, use the default GlobalError component as the final fallback.
+        // When the app router itself fails, which means the framework itself fails, we show the default error.
+        errorComponent: DefaultGlobalError,
+        children: /*#__PURE__*/ _jsx(Router, {
+            actionQueue: actionQueue,
+            assetPrefix: assetPrefix,
+            globalError: [
+                globalErrorComponent,
+                globalErrorStyles
+            ]
+        })
+    });
+}
+const runtimeStyles = new Set();
+let runtimeStyleChanged = new Set();
+globalThis._N_E_STYLE_LOAD = function(href) {
+    let len = runtimeStyles.size;
+    runtimeStyles.add(href);
+    if (runtimeStyles.size !== len) {
+        runtimeStyleChanged.forEach((cb)=>cb());
+    }
+    // TODO figure out how to get a promise here
+    // But maybe it's not necessary as react would block rendering until it's loaded
+    return Promise.resolve();
+};
+function RuntimeStyles() {
+    const [, forceUpdate] = React.useState(0);
+    const renderedStylesSize = runtimeStyles.size;
+    useEffect(()=>{
+        const changed = ()=>forceUpdate((c)=>c + 1);
+        runtimeStyleChanged.add(changed);
+        if (renderedStylesSize !== runtimeStyles.size) {
+            changed();
+        }
+        return ()=>{
+            runtimeStyleChanged.delete(changed);
+        };
+    }, [
+        renderedStylesSize,
+        forceUpdate
+    ]);
+    const dplId = process.env.NEXT_DEPLOYMENT_ID ? "?dpl=" + process.env.NEXT_DEPLOYMENT_ID : '';
+    return [
+        ...runtimeStyles
+    ].map((href, i)=>/*#__PURE__*/ _jsx("link", {
+            rel: "stylesheet",
+            href: "" + href + dplId,
+            // @ts-ignore
+            precedence: "next"
+        }, i));
+}
+
+//# sourceMappingURL=app-router.js.map

node_modules/next/dist/esm/client/components/bailout-to-client-rendering.js

@@ -0,0 +1,13 @@
+import { BailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr';
+import { workAsyncStorage } from '../../server/app-render/work-async-storage.external';
+export function bailoutToClientRendering(reason) {
+    const workStore = workAsyncStorage.getStore();
+    if (workStore == null ? void 0 : workStore.forceStatic) return;
+    if (workStore == null ? void 0 : workStore.isStaticGeneration) throw Object.defineProperty(new BailoutToCSRError(reason), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=bailout-to-client-rendering.js.map

node_modules/next/dist/esm/client/components/bailout-to-client-rendering.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/bailout-to-client-rendering.ts"],"sourcesContent":["import { BailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr'\nimport { workAsyncStorage } from '../../server/app-render/work-async-storage.external'\n\nexport function bailoutToClientRendering(reason: string): void | never {\n  const workStore = workAsyncStorage.getStore()\n\n  if (workStore?.forceStatic) return\n\n  if (workStore?.isStaticGeneration) throw new BailoutToCSRError(reason)\n}\n"],"names":["BailoutToCSRError","workAsyncStorage","bailoutToClientRendering","reason","workStore","getStore","forceStatic","isStaticGeneration"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,+CAA8C;AAChF,SAASC,gBAAgB,QAAQ,sDAAqD;AAEtF,OAAO,SAASC,yBAAyBC,MAAc;IACrD,MAAMC,YAAYH,iBAAiBI,QAAQ;IAE3C,IAAID,6BAAAA,UAAWE,WAAW,EAAE;IAE5B,IAAIF,6BAAAA,UAAWG,kBAAkB,EAAE,MAAM,qBAA6B,CAA7B,IAAIP,kBAAkBG,SAAtB,qBAAA;eAAA;oBAAA;sBAAA;IAA4B;AACvE"}

node_modules/next/dist/esm/client/components/client-page.js

@@ -0,0 +1,48 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { InvariantError } from '../../shared/lib/invariant-error';
+/**
+ * When the Page is a client component we send the params and searchParams to this client wrapper
+ * where they are turned into dynamically tracked values before being passed to the actual Page component.
+ *
+ * additionally we may send promises representing the params and searchParams. We don't ever use these passed
+ * values but it can be necessary for the sender to send a Promise that doesn't resolve in certain situations.
+ * It is up to the caller to decide if the promises are needed.
+ */ export function ClientPageRoot(param) {
+    let { Component, searchParams, params, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    promises } = param;
+    if (typeof window === 'undefined') {
+        const { workAsyncStorage } = require('../../server/app-render/work-async-storage.external');
+        let clientSearchParams;
+        let clientParams;
+        // We are going to instrument the searchParams prop with tracking for the
+        // appropriate context. We wrap differently in prerendering vs rendering
+        const store = workAsyncStorage.getStore();
+        if (!store) {
+            throw Object.defineProperty(new InvariantError('Expected workStore to exist when handling searchParams in a client Page.'), "__NEXT_ERROR_CODE", {
+                value: "E564",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const { createSearchParamsFromClient } = require('../../server/request/search-params');
+        clientSearchParams = createSearchParamsFromClient(searchParams, store);
+        const { createParamsFromClient } = require('../../server/request/params');
+        clientParams = createParamsFromClient(params, store);
+        return /*#__PURE__*/ _jsx(Component, {
+            params: clientParams,
+            searchParams: clientSearchParams
+        });
+    } else {
+        const { createRenderSearchParamsFromClient } = require('../request/search-params.browser');
+        const clientSearchParams = createRenderSearchParamsFromClient(searchParams);
+        const { createRenderParamsFromClient } = require('../request/params.browser');
+        const clientParams = createRenderParamsFromClient(params);
+        return /*#__PURE__*/ _jsx(Component, {
+            params: clientParams,
+            searchParams: clientSearchParams
+        });
+    }
+}
+
+//# sourceMappingURL=client-page.js.map

node_modules/next/dist/esm/client/components/client-page.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/client-page.tsx"],"sourcesContent":["'use client'\n\nimport type { ParsedUrlQuery } from 'querystring'\nimport { InvariantError } from '../../shared/lib/invariant-error'\n\nimport type { Params } from '../../server/request/params'\n\n/**\n * When the Page is a client component we send the params and searchParams to this client wrapper\n * where they are turned into dynamically tracked values before being passed to the actual Page component.\n *\n * additionally we may send promises representing the params and searchParams. We don't ever use these passed\n * values but it can be necessary for the sender to send a Promise that doesn't resolve in certain situations.\n * It is up to the caller to decide if the promises are needed.\n */\nexport function ClientPageRoot({\n  Component,\n  searchParams,\n  params,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  promises,\n}: {\n  Component: React.ComponentType<any>\n  searchParams: ParsedUrlQuery\n  params: Params\n  promises?: Array<Promise<any>>\n}) {\n  if (typeof window === 'undefined') {\n    const { workAsyncStorage } =\n      require('../../server/app-render/work-async-storage.external') as typeof import('../../server/app-render/work-async-storage.external')\n\n    let clientSearchParams: Promise<ParsedUrlQuery>\n    let clientParams: Promise<Params>\n    // We are going to instrument the searchParams prop with tracking for the\n    // appropriate context. We wrap differently in prerendering vs rendering\n    const store = workAsyncStorage.getStore()\n    if (!store) {\n      throw new InvariantError(\n        'Expected workStore to exist when handling searchParams in a client Page.'\n      )\n    }\n\n    const { createSearchParamsFromClient } =\n      require('../../server/request/search-params') as typeof import('../../server/request/search-params')\n    clientSearchParams = createSearchParamsFromClient(searchParams, store)\n\n    const { createParamsFromClient } =\n      require('../../server/request/params') as typeof import('../../server/request/params')\n    clientParams = createParamsFromClient(params, store)\n\n    return <Component params={clientParams} searchParams={clientSearchParams} />\n  } else {\n    const { createRenderSearchParamsFromClient } =\n      require('../request/search-params.browser') as typeof import('../request/search-params.browser')\n    const clientSearchParams = createRenderSearchParamsFromClient(searchParams)\n    const { createRenderParamsFromClient } =\n      require('../request/params.browser') as typeof import('../request/params.browser')\n    const clientParams = createRenderParamsFromClient(params)\n\n    return <Component params={clientParams} searchParams={clientSearchParams} />\n  }\n}\n"],"names":["InvariantError","ClientPageRoot","Component","searchParams","params","promises","window","workAsyncStorage","require","clientSearchParams","clientParams","store","getStore","createSearchParamsFromClient","createParamsFromClient","createRenderSearchParamsFromClient","createRenderParamsFromClient"],"mappings":"AAAA;;AAGA,SAASA,cAAc,QAAQ,mCAAkC;AAIjE;;;;;;;CAOC,GACD,OAAO,SAASC,eAAe,KAW9B;IAX8B,IAAA,EAC7BC,SAAS,EACTC,YAAY,EACZC,MAAM,EACN,6DAA6D;IAC7DC,QAAQ,EAMT,GAX8B;IAY7B,IAAI,OAAOC,WAAW,aAAa;QACjC,MAAM,EAAEC,gBAAgB,EAAE,GACxBC,QAAQ;QAEV,IAAIC;QACJ,IAAIC;QACJ,yEAAyE;QACzE,wEAAwE;QACxE,MAAMC,QAAQJ,iBAAiBK,QAAQ;QACvC,IAAI,CAACD,OAAO;YACV,MAAM,qBAEL,CAFK,IAAIX,eACR,6EADI,qBAAA;uBAAA;4BAAA;8BAAA;YAEN;QACF;QAEA,MAAM,EAAEa,4BAA4B,EAAE,GACpCL,QAAQ;QACVC,qBAAqBI,6BAA6BV,cAAcQ;QAEhE,MAAM,EAAEG,sBAAsB,EAAE,GAC9BN,QAAQ;QACVE,eAAeI,uBAAuBV,QAAQO;QAE9C,qBAAO,KAACT;YAAUE,QAAQM;YAAcP,cAAcM;;IACxD,OAAO;QACL,MAAM,EAAEM,kCAAkC,EAAE,GAC1CP,QAAQ;QACV,MAAMC,qBAAqBM,mCAAmCZ;QAC9D,MAAM,EAAEa,4BAA4B,EAAE,GACpCR,QAAQ;QACV,MAAME,eAAeM,6BAA6BZ;QAElD,qBAAO,KAACF;YAAUE,QAAQM;YAAcP,cAAcM;;IACxD;AACF"}

node_modules/next/dist/esm/client/components/client-segment.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { InvariantError } from '../../shared/lib/invariant-error';
+/**
+ * When the Page is a client component we send the params to this client wrapper
+ * where they are turned into dynamically tracked values before being passed to the actual Segment component.
+ *
+ * additionally we may send a promise representing params. We don't ever use this passed
+ * value but it can be necessary for the sender to send a Promise that doesn't resolve in certain situations
+ * such as when dynamicIO is enabled. It is up to the caller to decide if the promises are needed.
+ */ export function ClientSegmentRoot(param) {
+    let { Component, slots, params, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    promise } = param;
+    if (typeof window === 'undefined') {
+        const { workAsyncStorage } = require('../../server/app-render/work-async-storage.external');
+        let clientParams;
+        // We are going to instrument the searchParams prop with tracking for the
+        // appropriate context. We wrap differently in prerendering vs rendering
+        const store = workAsyncStorage.getStore();
+        if (!store) {
+            throw Object.defineProperty(new InvariantError('Expected workStore to exist when handling params in a client segment such as a Layout or Template.'), "__NEXT_ERROR_CODE", {
+                value: "E600",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const { createParamsFromClient } = require('../../server/request/params');
+        clientParams = createParamsFromClient(params, store);
+        return /*#__PURE__*/ _jsx(Component, {
+            ...slots,
+            params: clientParams
+        });
+    } else {
+        const { createRenderParamsFromClient } = require('../request/params.browser');
+        const clientParams = createRenderParamsFromClient(params);
+        return /*#__PURE__*/ _jsx(Component, {
+            ...slots,
+            params: clientParams
+        });
+    }
+}
+
+//# sourceMappingURL=client-segment.js.map

node_modules/next/dist/esm/client/components/client-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/client-segment.tsx"],"sourcesContent":["'use client'\n\nimport { InvariantError } from '../../shared/lib/invariant-error'\n\nimport type { Params } from '../../server/request/params'\n\n/**\n * When the Page is a client component we send the params to this client wrapper\n * where they are turned into dynamically tracked values before being passed to the actual Segment component.\n *\n * additionally we may send a promise representing params. We don't ever use this passed\n * value but it can be necessary for the sender to send a Promise that doesn't resolve in certain situations\n * such as when dynamicIO is enabled. It is up to the caller to decide if the promises are needed.\n */\nexport function ClientSegmentRoot({\n  Component,\n  slots,\n  params,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  promise,\n}: {\n  Component: React.ComponentType<any>\n  slots: { [key: string]: React.ReactNode }\n  params: Params\n  promise?: Promise<any>\n}) {\n  if (typeof window === 'undefined') {\n    const { workAsyncStorage } =\n      require('../../server/app-render/work-async-storage.external') as typeof import('../../server/app-render/work-async-storage.external')\n\n    let clientParams: Promise<Params>\n    // We are going to instrument the searchParams prop with tracking for the\n    // appropriate context. We wrap differently in prerendering vs rendering\n    const store = workAsyncStorage.getStore()\n    if (!store) {\n      throw new InvariantError(\n        'Expected workStore to exist when handling params in a client segment such as a Layout or Template.'\n      )\n    }\n\n    const { createParamsFromClient } =\n      require('../../server/request/params') as typeof import('../../server/request/params')\n    clientParams = createParamsFromClient(params, store)\n\n    return <Component {...slots} params={clientParams} />\n  } else {\n    const { createRenderParamsFromClient } =\n      require('../request/params.browser') as typeof import('../request/params.browser')\n    const clientParams = createRenderParamsFromClient(params)\n    return <Component {...slots} params={clientParams} />\n  }\n}\n"],"names":["InvariantError","ClientSegmentRoot","Component","slots","params","promise","window","workAsyncStorage","require","clientParams","store","getStore","createParamsFromClient","createRenderParamsFromClient"],"mappings":"AAAA;;AAEA,SAASA,cAAc,QAAQ,mCAAkC;AAIjE;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkB,KAWjC;IAXiC,IAAA,EAChCC,SAAS,EACTC,KAAK,EACLC,MAAM,EACN,6DAA6D;IAC7DC,OAAO,EAMR,GAXiC;IAYhC,IAAI,OAAOC,WAAW,aAAa;QACjC,MAAM,EAAEC,gBAAgB,EAAE,GACxBC,QAAQ;QAEV,IAAIC;QACJ,yEAAyE;QACzE,wEAAwE;QACxE,MAAMC,QAAQH,iBAAiBI,QAAQ;QACvC,IAAI,CAACD,OAAO;YACV,MAAM,qBAEL,CAFK,IAAIV,eACR,uGADI,qBAAA;uBAAA;4BAAA;8BAAA;YAEN;QACF;QAEA,MAAM,EAAEY,sBAAsB,EAAE,GAC9BJ,QAAQ;QACVC,eAAeG,uBAAuBR,QAAQM;QAE9C,qBAAO,KAACR;YAAW,GAAGC,KAAK;YAAEC,QAAQK;;IACvC,OAAO;QACL,MAAM,EAAEI,4BAA4B,EAAE,GACpCL,QAAQ;QACV,MAAMC,eAAeI,6BAA6BT;QAClD,qBAAO,KAACF;YAAW,GAAGC,KAAK;YAAEC,QAAQK;;IACvC;AACF"}

node_modules/next/dist/esm/client/components/default-layout.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+export default function DefaultLayout(param) {
+    let { children } = param;
+    return /*#__PURE__*/ _jsx("html", {
+        children: /*#__PURE__*/ _jsx("body", {
+            children: children
+        })
+    });
+}
+
+//# sourceMappingURL=default-layout.js.map

node_modules/next/dist/esm/client/components/default-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/default-layout.tsx"],"sourcesContent":["import React from 'react'\n\nexport default function DefaultLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html>\n      <body>{children}</body>\n    </html>\n  )\n}\n"],"names":["React","DefaultLayout","children","html","body"],"mappings":";AAAA,OAAOA,WAAW,QAAO;AAEzB,eAAe,SAASC,cAAc,KAIrC;IAJqC,IAAA,EACpCC,QAAQ,EAGT,GAJqC;IAKpC,qBACE,KAACC;kBACC,cAAA,KAACC;sBAAMF;;;AAGb"}

node_modules/next/dist/esm/client/components/dev-root-http-access-fallback-boundary.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { HTTPAccessFallbackBoundary } from './http-access-fallback/error-boundary';
+// TODO: error on using forbidden and unauthorized in root layout
+export function bailOnRootNotFound() {
+    throw Object.defineProperty(new Error('notFound() is not allowed to use in root layout'), "__NEXT_ERROR_CODE", {
+        value: "E192",
+        enumerable: false,
+        configurable: true
+    });
+}
+function NotAllowedRootHTTPFallbackError() {
+    bailOnRootNotFound();
+    return null;
+}
+export function DevRootHTTPAccessFallbackBoundary(param) {
+    let { children } = param;
+    return /*#__PURE__*/ _jsx(HTTPAccessFallbackBoundary, {
+        notFound: /*#__PURE__*/ _jsx(NotAllowedRootHTTPFallbackError, {}),
+        children: children
+    });
+}
+
+//# sourceMappingURL=dev-root-http-access-fallback-boundary.js.map

node_modules/next/dist/esm/client/components/dev-root-http-access-fallback-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/dev-root-http-access-fallback-boundary.tsx"],"sourcesContent":["'use client'\n\nimport React from 'react'\nimport { HTTPAccessFallbackBoundary } from './http-access-fallback/error-boundary'\n\n// TODO: error on using forbidden and unauthorized in root layout\nexport function bailOnRootNotFound() {\n  throw new Error('notFound() is not allowed to use in root layout')\n}\n\nfunction NotAllowedRootHTTPFallbackError() {\n  bailOnRootNotFound()\n  return null\n}\n\nexport function DevRootHTTPAccessFallbackBoundary({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <HTTPAccessFallbackBoundary notFound={<NotAllowedRootHTTPFallbackError />}>\n      {children}\n    </HTTPAccessFallbackBoundary>\n  )\n}\n"],"names":["React","HTTPAccessFallbackBoundary","bailOnRootNotFound","Error","NotAllowedRootHTTPFallbackError","DevRootHTTPAccessFallbackBoundary","children","notFound"],"mappings":"AAAA;;AAEA,OAAOA,WAAW,QAAO;AACzB,SAASC,0BAA0B,QAAQ,wCAAuC;AAElF,iEAAiE;AACjE,OAAO,SAASC;IACd,MAAM,qBAA4D,CAA5D,IAAIC,MAAM,oDAAV,qBAAA;eAAA;oBAAA;sBAAA;IAA2D;AACnE;AAEA,SAASC;IACPF;IACA,OAAO;AACT;AAEA,OAAO,SAASG,kCAAkC,KAIjD;IAJiD,IAAA,EAChDC,QAAQ,EAGT,GAJiD;IAKhD,qBACE,KAACL;QAA2BM,wBAAU,KAACH;kBACpCE;;AAGP"}

node_modules/next/dist/esm/client/components/error-boundary.js

@@ -0,0 +1,184 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { useUntrackedPathname } from './navigation-untracked';
+import { isNextRouterError } from './is-next-router-error';
+import { handleHardNavError } from './nav-failure-handler';
+const workAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/work-async-storage.external').workAsyncStorage : undefined;
+const styles = {
+    error: {
+        // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52
+        fontFamily: 'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+        height: '100vh',
+        textAlign: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center'
+    },
+    text: {
+        fontSize: '14px',
+        fontWeight: 400,
+        lineHeight: '28px',
+        margin: '0 8px'
+    }
+};
+// if we are revalidating we want to re-throw the error so the
+// function crashes so we can maintain our previous cache
+// instead of caching the error page
+function HandleISRError(param) {
+    let { error } = param;
+    if (workAsyncStorage) {
+        const store = workAsyncStorage.getStore();
+        if ((store == null ? void 0 : store.isRevalidate) || (store == null ? void 0 : store.isStaticGeneration)) {
+            console.error(error);
+            throw error;
+        }
+    }
+    return null;
+}
+export class ErrorBoundaryHandler extends React.Component {
+    static getDerivedStateFromError(error) {
+        if (isNextRouterError(error)) {
+            // Re-throw if an expected internal Next.js router error occurs
+            // this means it should be handled by a different boundary (such as a NotFound boundary in a parent segment)
+            throw error;
+        }
+        return {
+            error
+        };
+    }
+    static getDerivedStateFromProps(props, state) {
+        const { error } = state;
+        // if we encounter an error while
+        // a navigation is pending we shouldn't render
+        // the error boundary and instead should fallback
+        // to a hard navigation to attempt recovering
+        if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+            if (error && handleHardNavError(error)) {
+                // clear error so we don't render anything
+                return {
+                    error: null,
+                    previousPathname: props.pathname
+                };
+            }
+        }
+        /**
+     * Handles reset of the error boundary when a navigation happens.
+     * Ensures the error boundary does not stay enabled when navigating to a new page.
+     * Approach of setState in render is safe as it checks the previous pathname and then overrides
+     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
+     */ if (props.pathname !== state.previousPathname && state.error) {
+            return {
+                error: null,
+                previousPathname: props.pathname
+            };
+        }
+        return {
+            error: state.error,
+            previousPathname: props.pathname
+        };
+    }
+    // Explicit type is needed to avoid the generated `.d.ts` having a wide return type that could be specific to the `@types/react` version.
+    render() {
+        if (this.state.error) {
+            return /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx(HandleISRError, {
+                        error: this.state.error
+                    }),
+                    this.props.errorStyles,
+                    this.props.errorScripts,
+                    /*#__PURE__*/ _jsx(this.props.errorComponent, {
+                        error: this.state.error,
+                        reset: this.reset
+                    })
+                ]
+            });
+        }
+        return this.props.children;
+    }
+    constructor(props){
+        super(props), this.reset = ()=>{
+            this.setState({
+                error: null
+            });
+        };
+        this.state = {
+            error: null,
+            previousPathname: this.props.pathname
+        };
+    }
+}
+export function GlobalError(param) {
+    let { error } = param;
+    const digest = error == null ? void 0 : error.digest;
+    return /*#__PURE__*/ _jsxs("html", {
+        id: "__next_error__",
+        children: [
+            /*#__PURE__*/ _jsx("head", {}),
+            /*#__PURE__*/ _jsxs("body", {
+                children: [
+                    /*#__PURE__*/ _jsx(HandleISRError, {
+                        error: error
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        style: styles.error,
+                        children: /*#__PURE__*/ _jsxs("div", {
+                            children: [
+                                /*#__PURE__*/ _jsxs("h2", {
+                                    style: styles.text,
+                                    children: [
+                                        "Application error: a ",
+                                        digest ? 'server' : 'client',
+                                        "-side exception has occurred while loading ",
+                                        window.location.hostname,
+                                        " (see the",
+                                        ' ',
+                                        digest ? 'server logs' : 'browser console',
+                                        " for more information)."
+                                    ]
+                                }),
+                                digest ? /*#__PURE__*/ _jsx("p", {
+                                    style: styles.text,
+                                    children: "Digest: " + digest
+                                }) : null
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+// Exported so that the import signature in the loaders can be identical to user
+// supplied custom global error signatures.
+export default GlobalError;
+/**
+ * Handles errors through `getDerivedStateFromError`.
+ * Renders the provided error component and provides a way to `reset` the error boundary state.
+ */ /**
+ * Renders error boundary with the provided "errorComponent" property as the fallback.
+ * If no "errorComponent" property is provided it renders the children without an error boundary.
+ */ export function ErrorBoundary(param) {
+    let { errorComponent, errorStyles, errorScripts, children } = param;
+    // When we're rendering the missing params shell, this will return null. This
+    // is because we won't be rendering any not found boundaries or error
+    // boundaries for the missing params shell. When this runs on the client
+    // (where these errors can occur), we will get the correct pathname.
+    const pathname = useUntrackedPathname();
+    if (errorComponent) {
+        return /*#__PURE__*/ _jsx(ErrorBoundaryHandler, {
+            pathname: pathname,
+            errorComponent: errorComponent,
+            errorStyles: errorStyles,
+            errorScripts: errorScripts,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsx(_Fragment, {
+        children: children
+    });
+}
+
+//# sourceMappingURL=error-boundary.js.map

node_modules/next/dist/esm/client/components/errors/attach-hydration-error-state.js

@@ -0,0 +1,68 @@
+import { getDefaultHydrationErrorMessage, isHydrationError, testReactHydrationWarning } from '../is-hydration-error';
+import { hydrationErrorState, getReactHydrationDiffSegments } from './hydration-error-info';
+export function attachHydrationErrorState(error) {
+    let parsedHydrationErrorState = {};
+    const isHydrationWarning = testReactHydrationWarning(error.message);
+    const isHydrationRuntimeError = isHydrationError(error);
+    // If it's not hydration warnings or errors, skip
+    if (!(isHydrationRuntimeError || isHydrationWarning)) {
+        return;
+    }
+    const reactHydrationDiffSegments = getReactHydrationDiffSegments(error.message);
+    // If the reactHydrationDiffSegments exists
+    // and the diff (reactHydrationDiffSegments[1]) exists
+    // e.g. the hydration diff log error.
+    if (reactHydrationDiffSegments) {
+        const diff = reactHydrationDiffSegments[1];
+        parsedHydrationErrorState = {
+            ...error.details,
+            ...hydrationErrorState,
+            // If diff is present in error, we don't need to pick up the console logged warning.
+            // - if hydration error has diff, and is not hydration diff log, then it's a normal hydration error.
+            // - if hydration error no diff, then leverage the one from the hydration diff log.
+            warning: (diff && !isHydrationWarning ? null : hydrationErrorState.warning) || [
+                getDefaultHydrationErrorMessage(),
+                '',
+                ''
+            ],
+            // When it's hydration diff log, do not show notes section.
+            // This condition is only for the 1st squashed error.
+            notes: isHydrationWarning ? '' : reactHydrationDiffSegments[0],
+            reactOutputComponentDiff: diff
+        };
+        // Cache the `reactOutputComponentDiff` into hydrationErrorState.
+        // This is only required for now when we still squashed the hydration diff log into hydration error.
+        // Once the all error is logged to dev overlay in order, this will go away.
+        if (!hydrationErrorState.reactOutputComponentDiff && diff) {
+            hydrationErrorState.reactOutputComponentDiff = diff;
+        }
+        // If it's hydration runtime error that doesn't contain the diff, combine the diff from the cached hydration diff.
+        if (!diff && isHydrationRuntimeError && hydrationErrorState.reactOutputComponentDiff) {
+            parsedHydrationErrorState.reactOutputComponentDiff = hydrationErrorState.reactOutputComponentDiff;
+        }
+    } else {
+        // Normal runtime error, where it doesn't contain the hydration diff.
+        // If there's any extra information in the error message to display,
+        // append it to the error message details property
+        if (hydrationErrorState.warning) {
+            // The patched console.error found hydration errors logged by React
+            // Append the logged warning to the error message
+            parsedHydrationErrorState = {
+                ...error.details,
+                // It contains the warning, component stack, server and client tag names
+                ...hydrationErrorState
+            };
+        }
+        // Consume the cached hydration diff.
+        // This is only required for now when we still squashed the hydration diff log into hydration error.
+        // Once the all error is logged to dev overlay in order, this will go away.
+        if (hydrationErrorState.reactOutputComponentDiff) {
+            parsedHydrationErrorState.reactOutputComponentDiff = hydrationErrorState.reactOutputComponentDiff;
+        }
+    }
+    // If it's a hydration error, store the hydration error state into the error object
+    ;
+    error.details = parsedHydrationErrorState;
+}
+
+//# sourceMappingURL=attach-hydration-error-state.js.map

node_modules/next/dist/esm/client/components/errors/console-error.js

@@ -0,0 +1,24 @@
+// To distinguish from React error.digest, we use a different symbol here to determine if the error is from console.error or unhandled promise rejection.
+const digestSym = Symbol.for('next.console.error.digest');
+const consoleTypeSym = Symbol.for('next.console.error.type');
+export function createConsoleError(message, environmentName) {
+    const error = typeof message === 'string' ? Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    }) : message;
+    error[digestSym] = 'NEXT_CONSOLE_ERROR';
+    error[consoleTypeSym] = typeof message === 'string' ? 'string' : 'error';
+    if (environmentName && !error.environmentName) {
+        error.environmentName = environmentName;
+    }
+    return error;
+}
+export const isConsoleError = (error)=>{
+    return error && error[digestSym] === 'NEXT_CONSOLE_ERROR';
+};
+export const getConsoleErrorType = (error)=>{
+    return error[consoleTypeSym];
+};
+
+//# sourceMappingURL=console-error.js.map

node_modules/next/dist/esm/client/components/errors/console-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/errors/console-error.ts"],"sourcesContent":["// To distinguish from React error.digest, we use a different symbol here to determine if the error is from console.error or unhandled promise rejection.\nconst digestSym = Symbol.for('next.console.error.digest')\nconst consoleTypeSym = Symbol.for('next.console.error.type')\n\n// Represent non Error shape unhandled promise rejections or console.error errors.\n// Those errors will be captured and displayed in Error Overlay.\nexport type ConsoleError = Error & {\n  [digestSym]: 'NEXT_CONSOLE_ERROR'\n  [consoleTypeSym]: 'string' | 'error'\n  environmentName: string\n}\n\nexport function createConsoleError(\n  message: string | Error,\n  environmentName?: string | null\n): ConsoleError {\n  const error = (\n    typeof message === 'string' ? new Error(message) : message\n  ) as ConsoleError\n  error[digestSym] = 'NEXT_CONSOLE_ERROR'\n  error[consoleTypeSym] = typeof message === 'string' ? 'string' : 'error'\n\n  if (environmentName && !error.environmentName) {\n    error.environmentName = environmentName\n  }\n\n  return error\n}\n\nexport const isConsoleError = (error: any): error is ConsoleError => {\n  return error && error[digestSym] === 'NEXT_CONSOLE_ERROR'\n}\n\nexport const getConsoleErrorType = (error: ConsoleError) => {\n  return error[consoleTypeSym]\n}\n"],"names":["digestSym","Symbol","for","consoleTypeSym","createConsoleError","message","environmentName","error","Error","isConsoleError","getConsoleErrorType"],"mappings":"AAAA,yJAAyJ;AACzJ,MAAMA,YAAYC,OAAOC,GAAG,CAAC;AAC7B,MAAMC,iBAAiBF,OAAOC,GAAG,CAAC;AAUlC,OAAO,SAASE,mBACdC,OAAuB,EACvBC,eAA+B;IAE/B,MAAMC,QACJ,OAAOF,YAAY,WAAW,qBAAkB,CAAlB,IAAIG,MAAMH,UAAV,qBAAA;eAAA;oBAAA;sBAAA;IAAiB,KAAIA;IAErDE,KAAK,CAACP,UAAU,GAAG;IACnBO,KAAK,CAACJ,eAAe,GAAG,OAAOE,YAAY,WAAW,WAAW;IAEjE,IAAIC,mBAAmB,CAACC,MAAMD,eAAe,EAAE;QAC7CC,MAAMD,eAAe,GAAGA;IAC1B;IAEA,OAAOC;AACT;AAEA,OAAO,MAAME,iBAAiB,CAACF;IAC7B,OAAOA,SAASA,KAAK,CAACP,UAAU,KAAK;AACvC,EAAC;AAED,OAAO,MAAMU,sBAAsB,CAACH;IAClC,OAAOA,KAAK,CAACJ,eAAe;AAC9B,EAAC"}

node_modules/next/dist/esm/client/components/errors/enqueue-client-error.js

@@ -0,0 +1,11 @@
+// Dedupe the two consecutive errors: If the previous one is same as current one, ignore the current one.
+export function enqueueConsecutiveDedupedError(queue, error) {
+    const previousError = queue[queue.length - 1];
+    // Compare the error stack to dedupe the consecutive errors
+    if (previousError && previousError.stack === error.stack) {
+        return;
+    }
+    queue.push(error);
+}
+
+//# sourceMappingURL=enqueue-client-error.js.map

node_modules/next/dist/esm/client/components/errors/enqueue-client-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/errors/enqueue-client-error.ts"],"sourcesContent":["// Dedupe the two consecutive errors: If the previous one is same as current one, ignore the current one.\nexport function enqueueConsecutiveDedupedError(\n  queue: Array<Error>,\n  error: Error\n) {\n  const previousError = queue[queue.length - 1]\n  // Compare the error stack to dedupe the consecutive errors\n  if (previousError && previousError.stack === error.stack) {\n    return\n  }\n  queue.push(error)\n}\n"],"names":["enqueueConsecutiveDedupedError","queue","error","previousError","length","stack","push"],"mappings":"AAAA,yGAAyG;AACzG,OAAO,SAASA,+BACdC,KAAmB,EACnBC,KAAY;IAEZ,MAAMC,gBAAgBF,KAAK,CAACA,MAAMG,MAAM,GAAG,EAAE;IAC7C,2DAA2D;IAC3D,IAAID,iBAAiBA,cAAcE,KAAK,KAAKH,MAAMG,KAAK,EAAE;QACxD;IACF;IACAJ,MAAMK,IAAI,CAACJ;AACb"}

node_modules/next/dist/esm/client/components/errors/hydration-error-info.js

@@ -0,0 +1,140 @@
+import { getHydrationErrorStackInfo, testReactHydrationWarning } from '../is-hydration-error';
+export const hydrationErrorState = {};
+// https://github.com/facebook/react/blob/main/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js used as a reference
+const htmlTagsWarnings = new Set([
+    'Warning: In HTML, %s cannot be a child of <%s>.%s\nThis will cause a hydration error.%s',
+    'Warning: In HTML, %s cannot be a descendant of <%s>.\nThis will cause a hydration error.%s',
+    'Warning: In HTML, text nodes cannot be a child of <%s>.\nThis will cause a hydration error.',
+    "Warning: In HTML, whitespace text nodes cannot be a child of <%s>. Make sure you don't have any extra whitespace between tags on each line of your source code.\nThis will cause a hydration error.",
+    'Warning: Expected server HTML to contain a matching <%s> in <%s>.%s',
+    'Warning: Did not expect server HTML to contain a <%s> in <%s>.%s'
+]);
+const textAndTagsMismatchWarnings = new Set([
+    'Warning: Expected server HTML to contain a matching text node for "%s" in <%s>.%s',
+    'Warning: Did not expect server HTML to contain the text node "%s" in <%s>.%s'
+]);
+export const getHydrationWarningType = (message)=>{
+    if (typeof message !== 'string') {
+        // TODO: Doesn't make sense to treat no message as a hydration error message.
+        // We should bail out somewhere earlier.
+        return 'text';
+    }
+    const normalizedMessage = message.startsWith('Warning: ') ? message : "Warning: " + message;
+    if (isHtmlTagsWarning(normalizedMessage)) return 'tag';
+    if (isTextInTagsMismatchWarning(normalizedMessage)) return 'text-in-tag';
+    return 'text';
+};
+const isHtmlTagsWarning = (message)=>htmlTagsWarnings.has(message);
+const isTextInTagsMismatchWarning = (msg)=>textAndTagsMismatchWarnings.has(msg);
+export const getReactHydrationDiffSegments = (msg)=>{
+    if (msg) {
+        const { message, diff } = getHydrationErrorStackInfo(msg);
+        if (message) return [
+            message,
+            diff
+        ];
+    }
+    return undefined;
+};
+/**
+ * Patch console.error to capture hydration errors.
+ * If any of the knownHydrationWarnings are logged, store the message and component stack.
+ * When the hydration runtime error is thrown, the message and component stack are added to the error.
+ * This results in a more helpful error message in the error overlay.
+ */ export function storeHydrationErrorStateFromConsoleArgs() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    let [msg, firstContent, secondContent, ...rest] = args;
+    if (testReactHydrationWarning(msg)) {
+        // Some hydration warnings has 4 arguments, some has 3, fallback to the last argument
+        // when the 3rd argument is not the component stack but an empty string
+        const isReact18 = msg.startsWith('Warning: ');
+        // For some warnings, there's only 1 argument for template.
+        // The second argument is the diff or component stack.
+        if (args.length === 3) {
+            secondContent = '';
+        }
+        const warning = [
+            // remove the last %s from the message
+            msg,
+            firstContent,
+            secondContent
+        ];
+        const lastArg = (rest[rest.length - 1] || '').trim();
+        if (!isReact18) {
+            hydrationErrorState.reactOutputComponentDiff = lastArg;
+        } else {
+            hydrationErrorState.reactOutputComponentDiff = generateHydrationDiffReact18(msg, firstContent, secondContent, lastArg);
+        }
+        hydrationErrorState.warning = warning;
+        hydrationErrorState.serverContent = firstContent;
+        hydrationErrorState.clientContent = secondContent;
+    }
+}
+/*
+ * Some hydration errors in React 18 does not have the diff in the error message.
+ * Instead it has the error stack trace which is component stack that we can leverage.
+ * Will parse the diff from the error stack trace
+ *  e.g.
+ *  Warning: Expected server HTML to contain a matching <div> in <p>.
+ *    at div
+ *    at p
+ *    at div
+ *    at div
+ *    at Page
+ *  output:
+ *    <Page>
+ *      <div>
+ *        <p>
+ *  >       <div>
+ *
+ */ function generateHydrationDiffReact18(message, firstContent, secondContent, lastArg) {
+    const componentStack = lastArg;
+    let firstIndex = -1;
+    let secondIndex = -1;
+    const hydrationWarningType = getHydrationWarningType(message);
+    // at div\n at Foo\n at Bar (....)\n -> [div, Foo]
+    const components = componentStack.split('\n')// .reverse()
+    .map((line, index)=>{
+        // `<space>at <component> (<location>)` -> `at <component> (<location>)`
+        line = line.trim();
+        // extract `<space>at <component>` to `<<component>>`
+        // e.g. `  at Foo` -> `<Foo>`
+        const [, component, location] = /at (\w+)( \((.*)\))?/.exec(line) || [];
+        // If there's no location then it's user-land stack frame
+        if (!location) {
+            if (component === firstContent && firstIndex === -1) {
+                firstIndex = index;
+            } else if (component === secondContent && secondIndex === -1) {
+                secondIndex = index;
+            }
+        }
+        return location ? '' : component;
+    }).filter(Boolean).reverse();
+    let diff = '';
+    for(let i = 0; i < components.length; i++){
+        const component = components[i];
+        const matchFirstContent = hydrationWarningType === 'tag' && i === components.length - firstIndex - 1;
+        const matchSecondContent = hydrationWarningType === 'tag' && i === components.length - secondIndex - 1;
+        if (matchFirstContent || matchSecondContent) {
+            const spaces = ' '.repeat(Math.max(i * 2 - 2, 0) + 2);
+            diff += "> " + spaces + "<" + component + ">\n";
+        } else {
+            const spaces = ' '.repeat(i * 2 + 2);
+            diff += spaces + "<" + component + ">\n";
+        }
+    }
+    if (hydrationWarningType === 'text') {
+        const spaces = ' '.repeat(components.length * 2);
+        diff += "+ " + spaces + '"' + firstContent + '"\n';
+        diff += "- " + spaces + '"' + secondContent + '"\n';
+    } else if (hydrationWarningType === 'text-in-tag') {
+        const spaces = ' '.repeat(components.length * 2);
+        diff += "> " + spaces + "<" + secondContent + ">\n";
+        diff += ">   " + spaces + '"' + firstContent + '"\n';
+    }
+    return diff;
+}
+
+//# sourceMappingURL=hydration-error-info.js.map

node_modules/next/dist/esm/client/components/errors/runtime-error-handler.js

@@ -0,0 +1,5 @@
+export const RuntimeErrorHandler = {
+    hadRuntimeError: false
+};
+
+//# sourceMappingURL=runtime-error-handler.js.map

node_modules/next/dist/esm/client/components/errors/runtime-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/errors/runtime-error-handler.ts"],"sourcesContent":["export const RuntimeErrorHandler = {\n  hadRuntimeError: false,\n}\n"],"names":["RuntimeErrorHandler","hadRuntimeError"],"mappings":"AAAA,OAAO,MAAMA,sBAAsB;IACjCC,iBAAiB;AACnB,EAAC"}

node_modules/next/dist/esm/client/components/errors/stitched-error.js

@@ -0,0 +1,43 @@
+import React from 'react';
+import isError from '../../../lib/is-error';
+import { copyNextErrorCode } from '../../../lib/error-telemetry-utils';
+const REACT_ERROR_STACK_BOTTOM_FRAME = 'react-stack-bottom-frame';
+const REACT_ERROR_STACK_BOTTOM_FRAME_REGEX = new RegExp("(at " + REACT_ERROR_STACK_BOTTOM_FRAME + " )|(" + REACT_ERROR_STACK_BOTTOM_FRAME + "\\@)");
+export function getReactStitchedError(err) {
+    const isErrorInstance = isError(err);
+    const originStack = isErrorInstance ? err.stack || '' : '';
+    const originMessage = isErrorInstance ? err.message : '';
+    const stackLines = originStack.split('\n');
+    const indexOfSplit = stackLines.findIndex((line)=>REACT_ERROR_STACK_BOTTOM_FRAME_REGEX.test(line));
+    const isOriginalReactError = indexOfSplit >= 0 // has the react-stack-bottom-frame
+    ;
+    let newStack = isOriginalReactError ? stackLines.slice(0, indexOfSplit).join('\n') : originStack;
+    const newError = Object.defineProperty(new Error(originMessage), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+    // Copy all enumerable properties, e.g. digest
+    Object.assign(newError, err);
+    copyNextErrorCode(err, newError);
+    newError.stack = newStack;
+    // Avoid duplicate overriding stack frames
+    appendOwnerStack(newError);
+    return newError;
+}
+function appendOwnerStack(error) {
+    if (!React.captureOwnerStack) {
+        return;
+    }
+    let stack = error.stack || '';
+    // This module is only bundled in development mode so this is safe.
+    const ownerStack = React.captureOwnerStack();
+    // Avoid duplicate overriding stack frames
+    if (ownerStack && stack.endsWith(ownerStack) === false) {
+        stack += ownerStack;
+        // Override stack
+        error.stack = stack;
+    }
+}
+
+//# sourceMappingURL=stitched-error.js.map

node_modules/next/dist/esm/client/components/errors/stitched-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/errors/stitched-error.ts"],"sourcesContent":["import React from 'react'\nimport isError from '../../../lib/is-error'\nimport { copyNextErrorCode } from '../../../lib/error-telemetry-utils'\n\nconst REACT_ERROR_STACK_BOTTOM_FRAME = 'react-stack-bottom-frame'\nconst REACT_ERROR_STACK_BOTTOM_FRAME_REGEX = new RegExp(\n  `(at ${REACT_ERROR_STACK_BOTTOM_FRAME} )|(${REACT_ERROR_STACK_BOTTOM_FRAME}\\\\@)`\n)\n\nexport function getReactStitchedError<T = unknown>(err: T): Error | T {\n  const isErrorInstance = isError(err)\n  const originStack = isErrorInstance ? err.stack || '' : ''\n  const originMessage = isErrorInstance ? err.message : ''\n  const stackLines = originStack.split('\\n')\n  const indexOfSplit = stackLines.findIndex((line) =>\n    REACT_ERROR_STACK_BOTTOM_FRAME_REGEX.test(line)\n  )\n  const isOriginalReactError = indexOfSplit >= 0 // has the react-stack-bottom-frame\n  let newStack = isOriginalReactError\n    ? stackLines.slice(0, indexOfSplit).join('\\n')\n    : originStack\n\n  const newError = new Error(originMessage)\n  // Copy all enumerable properties, e.g. digest\n  Object.assign(newError, err)\n  copyNextErrorCode(err, newError)\n  newError.stack = newStack\n\n  // Avoid duplicate overriding stack frames\n  appendOwnerStack(newError)\n\n  return newError\n}\n\nfunction appendOwnerStack(error: Error) {\n  if (!React.captureOwnerStack) {\n    return\n  }\n  let stack = error.stack || ''\n  // This module is only bundled in development mode so this is safe.\n  const ownerStack = React.captureOwnerStack()\n  // Avoid duplicate overriding stack frames\n  if (ownerStack && stack.endsWith(ownerStack) === false) {\n    stack += ownerStack\n    // Override stack\n    error.stack = stack\n  }\n}\n"],"names":["React","isError","copyNextErrorCode","REACT_ERROR_STACK_BOTTOM_FRAME","REACT_ERROR_STACK_BOTTOM_FRAME_REGEX","RegExp","getReactStitchedError","err","isErrorInstance","originStack","stack","originMessage","message","stackLines","split","indexOfSplit","findIndex","line","test","isOriginalReactError","newStack","slice","join","newError","Error","Object","assign","appendOwnerStack","error","captureOwnerStack","ownerStack","endsWith"],"mappings":"AAAA,OAAOA,WAAW,QAAO;AACzB,OAAOC,aAAa,wBAAuB;AAC3C,SAASC,iBAAiB,QAAQ,qCAAoC;AAEtE,MAAMC,iCAAiC;AACvC,MAAMC,uCAAuC,IAAIC,OAC/C,AAAC,SAAMF,iCAA+B,SAAMA,iCAA+B;AAG7E,OAAO,SAASG,sBAAmCC,GAAM;IACvD,MAAMC,kBAAkBP,QAAQM;IAChC,MAAME,cAAcD,kBAAkBD,IAAIG,KAAK,IAAI,KAAK;IACxD,MAAMC,gBAAgBH,kBAAkBD,IAAIK,OAAO,GAAG;IACtD,MAAMC,aAAaJ,YAAYK,KAAK,CAAC;IACrC,MAAMC,eAAeF,WAAWG,SAAS,CAAC,CAACC,OACzCb,qCAAqCc,IAAI,CAACD;IAE5C,MAAME,uBAAuBJ,gBAAgB,EAAE,mCAAmC;;IAClF,IAAIK,WAAWD,uBACXN,WAAWQ,KAAK,CAAC,GAAGN,cAAcO,IAAI,CAAC,QACvCb;IAEJ,MAAMc,WAAW,qBAAwB,CAAxB,IAAIC,MAAMb,gBAAV,qBAAA;eAAA;oBAAA;sBAAA;IAAuB;IACxC,8CAA8C;IAC9Cc,OAAOC,MAAM,CAACH,UAAUhB;IACxBL,kBAAkBK,KAAKgB;IACvBA,SAASb,KAAK,GAAGU;IAEjB,0CAA0C;IAC1CO,iBAAiBJ;IAEjB,OAAOA;AACT;AAEA,SAASI,iBAAiBC,KAAY;IACpC,IAAI,CAAC5B,MAAM6B,iBAAiB,EAAE;QAC5B;IACF;IACA,IAAInB,QAAQkB,MAAMlB,KAAK,IAAI;IAC3B,mEAAmE;IACnE,MAAMoB,aAAa9B,MAAM6B,iBAAiB;IAC1C,0CAA0C;IAC1C,IAAIC,cAAcpB,MAAMqB,QAAQ,CAACD,gBAAgB,OAAO;QACtDpB,SAASoB;QACT,iBAAiB;QACjBF,MAAMlB,KAAK,GAAGA;IAChB;AACF"}

node_modules/next/dist/esm/client/components/errors/use-error-handler.js

@@ -0,0 +1,121 @@
+import { useEffect } from 'react';
+import { attachHydrationErrorState } from './attach-hydration-error-state';
+import { isNextRouterError } from '../is-next-router-error';
+import { storeHydrationErrorStateFromConsoleArgs } from './hydration-error-info';
+import { formatConsoleArgs, parseConsoleArgs } from '../../lib/console';
+import isError from '../../../lib/is-error';
+import { createConsoleError } from './console-error';
+import { enqueueConsecutiveDedupedError } from './enqueue-client-error';
+import { getReactStitchedError } from '../errors/stitched-error';
+const queueMicroTask = globalThis.queueMicrotask || ((cb)=>Promise.resolve().then(cb));
+const errorQueue = [];
+const errorHandlers = [];
+const rejectionQueue = [];
+const rejectionHandlers = [];
+export function handleConsoleError(originError, consoleErrorArgs) {
+    let error;
+    const { environmentName } = parseConsoleArgs(consoleErrorArgs);
+    if (isError(originError)) {
+        error = createConsoleError(originError, environmentName);
+    } else {
+        error = createConsoleError(formatConsoleArgs(consoleErrorArgs), environmentName);
+    }
+    error = getReactStitchedError(error);
+    storeHydrationErrorStateFromConsoleArgs(...consoleErrorArgs);
+    attachHydrationErrorState(error);
+    enqueueConsecutiveDedupedError(errorQueue, error);
+    for (const handler of errorHandlers){
+        // Delayed the error being passed to React Dev Overlay,
+        // avoid the state being synchronously updated in the component.
+        queueMicroTask(()=>{
+            handler(error);
+        });
+    }
+}
+export function handleClientError(originError) {
+    let error;
+    if (isError(originError)) {
+        error = originError;
+    } else {
+        // If it's not an error, format the args into an error
+        const formattedErrorMessage = originError + '';
+        error = Object.defineProperty(new Error(formattedErrorMessage), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    error = getReactStitchedError(error);
+    attachHydrationErrorState(error);
+    enqueueConsecutiveDedupedError(errorQueue, error);
+    for (const handler of errorHandlers){
+        // Delayed the error being passed to React Dev Overlay,
+        // avoid the state being synchronously updated in the component.
+        queueMicroTask(()=>{
+            handler(error);
+        });
+    }
+}
+export function useErrorHandler(handleOnUnhandledError, handleOnUnhandledRejection) {
+    useEffect(()=>{
+        // Handle queued errors.
+        errorQueue.forEach(handleOnUnhandledError);
+        rejectionQueue.forEach(handleOnUnhandledRejection);
+        // Listen to new errors.
+        errorHandlers.push(handleOnUnhandledError);
+        rejectionHandlers.push(handleOnUnhandledRejection);
+        return ()=>{
+            // Remove listeners.
+            errorHandlers.splice(errorHandlers.indexOf(handleOnUnhandledError), 1);
+            rejectionHandlers.splice(rejectionHandlers.indexOf(handleOnUnhandledRejection), 1);
+            // Reset error queues.
+            errorQueue.splice(0, errorQueue.length);
+            rejectionQueue.splice(0, rejectionQueue.length);
+        };
+    }, [
+        handleOnUnhandledError,
+        handleOnUnhandledRejection
+    ]);
+}
+function onUnhandledError(event) {
+    if (isNextRouterError(event.error)) {
+        event.preventDefault();
+        return false;
+    }
+    // When there's an error property present, we log the error to error overlay.
+    // Otherwise we don't do anything as it's not logging in the console either.
+    if (event.error) {
+        handleClientError(event.error);
+    }
+}
+function onUnhandledRejection(ev) {
+    const reason = ev == null ? void 0 : ev.reason;
+    if (isNextRouterError(reason)) {
+        ev.preventDefault();
+        return;
+    }
+    let error = reason;
+    if (error && !isError(error)) {
+        error = Object.defineProperty(new Error(error + ''), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    rejectionQueue.push(error);
+    for (const handler of rejectionHandlers){
+        handler(error);
+    }
+}
+export function handleGlobalErrors() {
+    if (typeof window !== 'undefined') {
+        try {
+            // Increase the number of stack frames on the client
+            Error.stackTraceLimit = 50;
+        } catch (e) {}
+        window.addEventListener('error', onUnhandledError);
+        window.addEventListener('unhandledrejection', onUnhandledRejection);
+    }
+}
+
+//# sourceMappingURL=use-error-handler.js.map

node_modules/next/dist/esm/client/components/forbidden-error.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HTTPAccessErrorFallback } from './http-access-fallback/error-fallback';
+export default function Forbidden() {
+    return /*#__PURE__*/ _jsx(HTTPAccessErrorFallback, {
+        status: 403,
+        message: "This page could not be accessed."
+    });
+}
+
+//# sourceMappingURL=forbidden-error.js.map

node_modules/next/dist/esm/client/components/forbidden-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/forbidden-error.tsx"],"sourcesContent":["import { HTTPAccessErrorFallback } from './http-access-fallback/error-fallback'\n\nexport default function Forbidden() {\n  return (\n    <HTTPAccessErrorFallback\n      status={403}\n      message=\"This page could not be accessed.\"\n    />\n  )\n}\n"],"names":["HTTPAccessErrorFallback","Forbidden","status","message"],"mappings":";AAAA,SAASA,uBAAuB,QAAQ,wCAAuC;AAE/E,eAAe,SAASC;IACtB,qBACE,KAACD;QACCE,QAAQ;QACRC,SAAQ;;AAGd"}

node_modules/next/dist/esm/client/components/forbidden.js

@@ -0,0 +1,33 @@
+import { HTTP_ERROR_FALLBACK_ERROR_CODE } from './http-access-fallback/http-access-fallback';
+// TODO: Add `forbidden` docs
+/**
+ * @experimental
+ * This function allows you to render the [forbidden.js file](https://nextjs.org/docs/app/api-reference/file-conventions/forbidden)
+ * within a route segment as well as inject a tag.
+ *
+ * `forbidden()` can be used in
+ * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
+ * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
+ * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
+ *
+ * Read more: [Next.js Docs: `forbidden`](https://nextjs.org/docs/app/api-reference/functions/forbidden)
+ */ const DIGEST = "" + HTTP_ERROR_FALLBACK_ERROR_CODE + ";403";
+export function forbidden() {
+    if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
+        throw Object.defineProperty(new Error("`forbidden()` is experimental and only allowed to be enabled when `experimental.authInterrupts` is enabled."), "__NEXT_ERROR_CODE", {
+            value: "E488",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // eslint-disable-next-line no-throw-literal
+    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+    error.digest = DIGEST;
+    throw error;
+}
+
+//# sourceMappingURL=forbidden.js.map

node_modules/next/dist/esm/client/components/forbidden.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/forbidden.ts"],"sourcesContent":["import {\n  HTTP_ERROR_FALLBACK_ERROR_CODE,\n  type HTTPAccessFallbackError,\n} from './http-access-fallback/http-access-fallback'\n\n// TODO: Add `forbidden` docs\n/**\n * @experimental\n * This function allows you to render the [forbidden.js file](https://nextjs.org/docs/app/api-reference/file-conventions/forbidden)\n * within a route segment as well as inject a tag.\n *\n * `forbidden()` can be used in\n * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),\n * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and\n * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).\n *\n * Read more: [Next.js Docs: `forbidden`](https://nextjs.org/docs/app/api-reference/functions/forbidden)\n */\n\nconst DIGEST = `${HTTP_ERROR_FALLBACK_ERROR_CODE};403`\n\nexport function forbidden(): never {\n  if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {\n    throw new Error(\n      `\\`forbidden()\\` is experimental and only allowed to be enabled when \\`experimental.authInterrupts\\` is enabled.`\n    )\n  }\n\n  // eslint-disable-next-line no-throw-literal\n  const error = new Error(DIGEST) as HTTPAccessFallbackError\n  ;(error as HTTPAccessFallbackError).digest = DIGEST\n  throw error\n}\n"],"names":["HTTP_ERROR_FALLBACK_ERROR_CODE","DIGEST","forbidden","process","env","__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS","Error","error","digest"],"mappings":"AAAA,SACEA,8BAA8B,QAEzB,8CAA6C;AAEpD,6BAA6B;AAC7B;;;;;;;;;;;CAWC,GAED,MAAMC,SAAS,AAAC,KAAED,iCAA+B;AAEjD,OAAO,SAASE;IACd,IAAI,CAACC,QAAQC,GAAG,CAACC,mCAAmC,EAAE;QACpD,MAAM,qBAEL,CAFK,IAAIC,MACP,gHADG,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,4CAA4C;IAC5C,MAAMC,QAAQ,qBAAiB,CAAjB,IAAID,MAAML,SAAV,qBAAA;eAAA;oBAAA;sBAAA;IAAgB;IAC5BM,MAAkCC,MAAM,GAAGP;IAC7C,MAAMM;AACR"}

node_modules/next/dist/esm/client/components/globals/handle-global-errors.js

@@ -0,0 +1,4 @@
+import { handleGlobalErrors } from '../errors/use-error-handler';
+handleGlobalErrors();
+
+//# sourceMappingURL=handle-global-errors.js.map

node_modules/next/dist/esm/client/components/globals/handle-global-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/handle-global-errors.ts"],"sourcesContent":["import { handleGlobalErrors } from '../errors/use-error-handler'\n\nhandleGlobalErrors()\n"],"names":["handleGlobalErrors"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,8BAA6B;AAEhEA"}

node_modules/next/dist/esm/client/components/globals/intercept-console-error.js

@@ -0,0 +1,41 @@
+import isError from '../../../lib/is-error';
+import { isNextRouterError } from '../is-next-router-error';
+import { handleConsoleError } from '../errors/use-error-handler';
+import { parseConsoleArgs } from '../../lib/console';
+export const originConsoleError = globalThis.console.error;
+// Patch console.error to collect information about hydration errors
+export function patchConsoleError() {
+    // Ensure it's only patched once
+    if (typeof window === 'undefined') {
+        return;
+    }
+    window.console.error = function error() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        let maybeError;
+        if (process.env.NODE_ENV !== 'production') {
+            const { error: replayedError } = parseConsoleArgs(args);
+            if (replayedError) {
+                maybeError = replayedError;
+            } else if (isError(args[0])) {
+                maybeError = args[0];
+            } else {
+                // See https://github.com/facebook/react/blob/d50323eb845c5fde0d720cae888bf35dedd05506/packages/react-reconciler/src/ReactFiberErrorLogger.js#L78
+                maybeError = args[1];
+            }
+        } else {
+            maybeError = args[0];
+        }
+        if (!isNextRouterError(maybeError)) {
+            if (process.env.NODE_ENV !== 'production') {
+                handleConsoleError(// replayed errors have their own complex format string that should be used,
+                // but if we pass the error directly, `handleClientError` will ignore it
+                maybeError, args);
+            }
+            originConsoleError.apply(window.console, args);
+        }
+    };
+}
+
+//# sourceMappingURL=intercept-console-error.js.map

node_modules/next/dist/esm/client/components/globals/intercept-console-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/intercept-console-error.ts"],"sourcesContent":["import isError from '../../../lib/is-error'\nimport { isNextRouterError } from '../is-next-router-error'\nimport { handleConsoleError } from '../errors/use-error-handler'\nimport { parseConsoleArgs } from '../../lib/console'\n\nexport const originConsoleError = globalThis.console.error\n\n// Patch console.error to collect information about hydration errors\nexport function patchConsoleError() {\n  // Ensure it's only patched once\n  if (typeof window === 'undefined') {\n    return\n  }\n  window.console.error = function error(...args: any[]) {\n    let maybeError: unknown\n    if (process.env.NODE_ENV !== 'production') {\n      const { error: replayedError } = parseConsoleArgs(args)\n      if (replayedError) {\n        maybeError = replayedError\n      } else if (isError(args[0])) {\n        maybeError = args[0]\n      } else {\n        // See https://github.com/facebook/react/blob/d50323eb845c5fde0d720cae888bf35dedd05506/packages/react-reconciler/src/ReactFiberErrorLogger.js#L78\n        maybeError = args[1]\n      }\n    } else {\n      maybeError = args[0]\n    }\n\n    if (!isNextRouterError(maybeError)) {\n      if (process.env.NODE_ENV !== 'production') {\n        handleConsoleError(\n          // replayed errors have their own complex format string that should be used,\n          // but if we pass the error directly, `handleClientError` will ignore it\n          maybeError,\n          args\n        )\n      }\n\n      originConsoleError.apply(window.console, args)\n    }\n  }\n}\n"],"names":["isError","isNextRouterError","handleConsoleError","parseConsoleArgs","originConsoleError","globalThis","console","error","patchConsoleError","window","args","maybeError","process","env","NODE_ENV","replayedError","apply"],"mappings":"AAAA,OAAOA,aAAa,wBAAuB;AAC3C,SAASC,iBAAiB,QAAQ,0BAAyB;AAC3D,SAASC,kBAAkB,QAAQ,8BAA6B;AAChE,SAASC,gBAAgB,QAAQ,oBAAmB;AAEpD,OAAO,MAAMC,qBAAqBC,WAAWC,OAAO,CAACC,KAAK,CAAA;AAE1D,oEAAoE;AACpE,OAAO,SAASC;IACd,gCAAgC;IAChC,IAAI,OAAOC,WAAW,aAAa;QACjC;IACF;IACAA,OAAOH,OAAO,CAACC,KAAK,GAAG,SAASA;QAAM,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGG,OAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA;YAAGA,KAAH,QAAA,SAAA,CAAA,KAAc;;QAClD,IAAIC;QACJ,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,MAAM,EAAEP,OAAOQ,aAAa,EAAE,GAAGZ,iBAAiBO;YAClD,IAAIK,eAAe;gBACjBJ,aAAaI;YACf,OAAO,IAAIf,QAAQU,IAAI,CAAC,EAAE,GAAG;gBAC3BC,aAAaD,IAAI,CAAC,EAAE;YACtB,OAAO;gBACL,iJAAiJ;gBACjJC,aAAaD,IAAI,CAAC,EAAE;YACtB;QACF,OAAO;YACLC,aAAaD,IAAI,CAAC,EAAE;QACtB;QAEA,IAAI,CAACT,kBAAkBU,aAAa;YAClC,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzCZ,mBACE,4EAA4E;gBAC5E,wEAAwE;gBACxES,YACAD;YAEJ;YAEAN,mBAAmBY,KAAK,CAACP,OAAOH,OAAO,EAAEI;QAC3C;IACF;AACF"}

node_modules/next/dist/esm/client/components/globals/patch-console.js

@@ -0,0 +1,4 @@
+import { patchConsoleError } from './intercept-console-error';
+patchConsoleError();
+
+//# sourceMappingURL=patch-console.js.map

node_modules/next/dist/esm/client/components/globals/patch-console.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/patch-console.ts"],"sourcesContent":["import { patchConsoleError } from './intercept-console-error'\n\npatchConsoleError()\n"],"names":["patchConsoleError"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,4BAA2B;AAE7DA"}

node_modules/next/dist/esm/client/components/hooks-server-context.js

@@ -0,0 +1,14 @@
+const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
+export class DynamicServerError extends Error {
+    constructor(description){
+        super("Dynamic server usage: " + description), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+    }
+}
+export function isDynamicServerError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
+        return false;
+    }
+    return err.digest === DYNAMIC_ERROR_CODE;
+}
+
+//# sourceMappingURL=hooks-server-context.js.map

node_modules/next/dist/esm/client/components/hooks-server-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/hooks-server-context.ts"],"sourcesContent":["const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE'\n\nexport class DynamicServerError extends Error {\n  digest: typeof DYNAMIC_ERROR_CODE = DYNAMIC_ERROR_CODE\n\n  constructor(public readonly description: string) {\n    super(`Dynamic server usage: ${description}`)\n  }\n}\n\nexport function isDynamicServerError(err: unknown): err is DynamicServerError {\n  if (\n    typeof err !== 'object' ||\n    err === null ||\n    !('digest' in err) ||\n    typeof err.digest !== 'string'\n  ) {\n    return false\n  }\n\n  return err.digest === DYNAMIC_ERROR_CODE\n}\n"],"names":["DYNAMIC_ERROR_CODE","DynamicServerError","Error","constructor","description","digest","isDynamicServerError","err"],"mappings":"AAAA,MAAMA,qBAAqB;AAE3B,OAAO,MAAMC,2BAA2BC;IAGtCC,YAAY,AAAgBC,WAAmB,CAAE;QAC/C,KAAK,CAAC,AAAC,2BAAwBA,mBADLA,cAAAA,kBAF5BC,SAAoCL;IAIpC;AACF;AAEA,OAAO,SAASM,qBAAqBC,GAAY;IAC/C,IACE,OAAOA,QAAQ,YACfA,QAAQ,QACR,CAAE,CAAA,YAAYA,GAAE,KAChB,OAAOA,IAAIF,MAAM,KAAK,UACtB;QACA,OAAO;IACT;IAEA,OAAOE,IAAIF,MAAM,KAAKL;AACxB"}

node_modules/next/dist/esm/client/components/http-access-fallback/error-boundary.js

@@ -0,0 +1,118 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * HTTPAccessFallbackBoundary is a boundary that catches errors and renders a
+ * fallback component for HTTP errors.
+ *
+ * It receives the status code, and determine if it should render fallbacks for few HTTP 4xx errors.
+ *
+ * e.g. 404
+ * 404 represents not found, and the fallback component pair contains the component and its styles.
+ *
+ */ import React, { useContext } from 'react';
+import { useUntrackedPathname } from '../navigation-untracked';
+import { HTTPAccessErrorStatus, getAccessFallbackHTTPStatus, getAccessFallbackErrorTypeByStatus, isHTTPAccessFallbackError } from './http-access-fallback';
+import { warnOnce } from '../../../shared/lib/utils/warn-once';
+import { MissingSlotContext } from '../../../shared/lib/app-router-context.shared-runtime';
+class HTTPAccessFallbackErrorBoundary extends React.Component {
+    componentDidCatch() {
+        if (process.env.NODE_ENV === 'development' && this.props.missingSlots && this.props.missingSlots.size > 0 && // A missing children slot is the typical not-found case, so no need to warn
+        !this.props.missingSlots.has('children')) {
+            let warningMessage = 'No default component was found for a parallel route rendered on this page. Falling back to nearest NotFound boundary.\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/routing/parallel-routes#defaultjs\n\n';
+            const formattedSlots = Array.from(this.props.missingSlots).sort((a, b)=>a.localeCompare(b)).map((slot)=>"@" + slot).join(', ');
+            warningMessage += 'Missing slots: ' + formattedSlots;
+            warnOnce(warningMessage);
+        }
+    }
+    static getDerivedStateFromError(error) {
+        if (isHTTPAccessFallbackError(error)) {
+            const httpStatus = getAccessFallbackHTTPStatus(error);
+            return {
+                triggeredStatus: httpStatus
+            };
+        }
+        // Re-throw if error is not for 404
+        throw error;
+    }
+    static getDerivedStateFromProps(props, state) {
+        /**
+     * Handles reset of the error boundary when a navigation happens.
+     * Ensures the error boundary does not stay enabled when navigating to a new page.
+     * Approach of setState in render is safe as it checks the previous pathname and then overrides
+     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
+     */ if (props.pathname !== state.previousPathname && state.triggeredStatus) {
+            return {
+                triggeredStatus: undefined,
+                previousPathname: props.pathname
+            };
+        }
+        return {
+            triggeredStatus: state.triggeredStatus,
+            previousPathname: props.pathname
+        };
+    }
+    render() {
+        const { notFound, forbidden, unauthorized, children } = this.props;
+        const { triggeredStatus } = this.state;
+        const errorComponents = {
+            [HTTPAccessErrorStatus.NOT_FOUND]: notFound,
+            [HTTPAccessErrorStatus.FORBIDDEN]: forbidden,
+            [HTTPAccessErrorStatus.UNAUTHORIZED]: unauthorized
+        };
+        if (triggeredStatus) {
+            const isNotFound = triggeredStatus === HTTPAccessErrorStatus.NOT_FOUND && notFound;
+            const isForbidden = triggeredStatus === HTTPAccessErrorStatus.FORBIDDEN && forbidden;
+            const isUnauthorized = triggeredStatus === HTTPAccessErrorStatus.UNAUTHORIZED && unauthorized;
+            // If there's no matched boundary in this layer, keep throwing the error by rendering the children
+            if (!(isNotFound || isForbidden || isUnauthorized)) {
+                return children;
+            }
+            return /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx("meta", {
+                        name: "robots",
+                        content: "noindex"
+                    }),
+                    process.env.NODE_ENV === 'development' && /*#__PURE__*/ _jsx("meta", {
+                        name: "boundary-next-error",
+                        content: getAccessFallbackErrorTypeByStatus(triggeredStatus)
+                    }),
+                    errorComponents[triggeredStatus]
+                ]
+            });
+        }
+        return children;
+    }
+    constructor(props){
+        super(props);
+        this.state = {
+            triggeredStatus: undefined,
+            previousPathname: props.pathname
+        };
+    }
+}
+export function HTTPAccessFallbackBoundary(param) {
+    let { notFound, forbidden, unauthorized, children } = param;
+    // When we're rendering the missing params shell, this will return null. This
+    // is because we won't be rendering any not found boundaries or error
+    // boundaries for the missing params shell. When this runs on the client
+    // (where these error can occur), we will get the correct pathname.
+    const pathname = useUntrackedPathname();
+    const missingSlots = useContext(MissingSlotContext);
+    const hasErrorFallback = !!(notFound || forbidden || unauthorized);
+    if (hasErrorFallback) {
+        return /*#__PURE__*/ _jsx(HTTPAccessFallbackErrorBoundary, {
+            pathname: pathname,
+            notFound: notFound,
+            forbidden: forbidden,
+            unauthorized: unauthorized,
+            missingSlots: missingSlots,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsx(_Fragment, {
+        children: children
+    });
+}
+
+//# sourceMappingURL=error-boundary.js.map

node_modules/next/dist/esm/client/components/http-access-fallback/error-fallback.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+const styles = {
+    error: {
+        // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52
+        fontFamily: 'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+        height: '100vh',
+        textAlign: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center'
+    },
+    desc: {
+        display: 'inline-block'
+    },
+    h1: {
+        display: 'inline-block',
+        margin: '0 20px 0 0',
+        padding: '0 23px 0 0',
+        fontSize: 24,
+        fontWeight: 500,
+        verticalAlign: 'top',
+        lineHeight: '49px'
+    },
+    h2: {
+        fontSize: 14,
+        fontWeight: 400,
+        lineHeight: '49px',
+        margin: 0
+    }
+};
+export function HTTPAccessErrorFallback(param) {
+    let { status, message } = param;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx("title", {
+                children: status + ": " + message
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                style: styles.error,
+                children: /*#__PURE__*/ _jsxs("div", {
+                    children: [
+                        /*#__PURE__*/ _jsx("style", {
+                            dangerouslySetInnerHTML: {
+                                /* Minified CSS from
+                body { margin: 0; color: #000; background: #fff; }
+                .next-error-h1 {
+                  border-right: 1px solid rgba(0, 0, 0, .3);
+                }
+
+                @media (prefers-color-scheme: dark) {
+                  body { color: #fff; background: #000; }
+                  .next-error-h1 {
+                    border-right: 1px solid rgba(255, 255, 255, .3);
+                  }
+                }
+              */ __html: "body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"
+                            }
+                        }),
+                        /*#__PURE__*/ _jsx("h1", {
+                            className: "next-error-h1",
+                            style: styles.h1,
+                            children: status
+                        }),
+                        /*#__PURE__*/ _jsx("div", {
+                            style: styles.desc,
+                            children: /*#__PURE__*/ _jsx("h2", {
+                                style: styles.h2,
+                                children: message
+                            })
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=error-fallback.js.map

node_modules/next/dist/esm/client/components/http-access-fallback/error-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/http-access-fallback/error-fallback.tsx"],"sourcesContent":["import React from 'react'\n\nconst styles: Record<string, React.CSSProperties> = {\n  error: {\n    // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52\n    fontFamily:\n      'system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"',\n    height: '100vh',\n    textAlign: 'center',\n    display: 'flex',\n    flexDirection: 'column',\n    alignItems: 'center',\n    justifyContent: 'center',\n  },\n\n  desc: {\n    display: 'inline-block',\n  },\n\n  h1: {\n    display: 'inline-block',\n    margin: '0 20px 0 0',\n    padding: '0 23px 0 0',\n    fontSize: 24,\n    fontWeight: 500,\n    verticalAlign: 'top',\n    lineHeight: '49px',\n  },\n\n  h2: {\n    fontSize: 14,\n    fontWeight: 400,\n    lineHeight: '49px',\n    margin: 0,\n  },\n}\n\nexport function HTTPAccessErrorFallback({\n  status,\n  message,\n}: {\n  status: number\n  message: string\n}) {\n  return (\n    <>\n      {/* <head> */}\n      <title>{`${status}: ${message}`}</title>\n      {/* </head> */}\n      <div style={styles.error}>\n        <div>\n          <style\n            dangerouslySetInnerHTML={{\n              /* Minified CSS from\n                body { margin: 0; color: #000; background: #fff; }\n                .next-error-h1 {\n                  border-right: 1px solid rgba(0, 0, 0, .3);\n                }\n\n                @media (prefers-color-scheme: dark) {\n                  body { color: #fff; background: #000; }\n                  .next-error-h1 {\n                    border-right: 1px solid rgba(255, 255, 255, .3);\n                  }\n                }\n              */\n              __html: `body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}`,\n            }}\n          />\n          <h1 className=\"next-error-h1\" style={styles.h1}>\n            {status}\n          </h1>\n          <div style={styles.desc}>\n            <h2 style={styles.h2}>{message}</h2>\n          </div>\n        </div>\n      </div>\n    </>\n  )\n}\n"],"names":["React","styles","error","fontFamily","height","textAlign","display","flexDirection","alignItems","justifyContent","desc","h1","margin","padding","fontSize","fontWeight","verticalAlign","lineHeight","h2","HTTPAccessErrorFallback","status","message","title","div","style","dangerouslySetInnerHTML","__html","className"],"mappings":";AAAA,OAAOA,WAAW,QAAO;AAEzB,MAAMC,SAA8C;IAClDC,OAAO;QACL,0FAA0F;QAC1FC,YACE;QACFC,QAAQ;QACRC,WAAW;QACXC,SAAS;QACTC,eAAe;QACfC,YAAY;QACZC,gBAAgB;IAClB;IAEAC,MAAM;QACJJ,SAAS;IACX;IAEAK,IAAI;QACFL,SAAS;QACTM,QAAQ;QACRC,SAAS;QACTC,UAAU;QACVC,YAAY;QACZC,eAAe;QACfC,YAAY;IACd;IAEAC,IAAI;QACFJ,UAAU;QACVC,YAAY;QACZE,YAAY;QACZL,QAAQ;IACV;AACF;AAEA,OAAO,SAASO,wBAAwB,KAMvC;IANuC,IAAA,EACtCC,MAAM,EACNC,OAAO,EAIR,GANuC;IAOtC,qBACE;;0BAEE,KAACC;0BAAO,AAAGF,SAAO,OAAIC;;0BAEtB,KAACE;gBAAIC,OAAOvB,OAAOC,KAAK;0BACtB,cAAA,MAACqB;;sCACC,KAACC;4BACCC,yBAAyB;gCACvB;;;;;;;;;;;;cAYA,GACAC,QAAS;4BACX;;sCAEF,KAACf;4BAAGgB,WAAU;4BAAgBH,OAAOvB,OAAOU,EAAE;sCAC3CS;;sCAEH,KAACG;4BAAIC,OAAOvB,OAAOS,IAAI;sCACrB,cAAA,KAACQ;gCAAGM,OAAOvB,OAAOiB,EAAE;0CAAGG;;;;;;;;AAMnC"}

node_modules/next/dist/esm/client/components/http-access-fallback/http-access-fallback.js

@@ -0,0 +1,38 @@
+export const HTTPAccessErrorStatus = {
+    NOT_FOUND: 404,
+    FORBIDDEN: 403,
+    UNAUTHORIZED: 401
+};
+const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
+export const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK';
+/**
+ * Checks an error to determine if it's an error generated by
+ * the HTTP navigation APIs `notFound()`, `forbidden()` or `unauthorized()`.
+ *
+ * @param error the error that may reference a HTTP access error
+ * @returns true if the error is a HTTP access error
+ */ export function isHTTPAccessFallbackError(error) {
+    if (typeof error !== 'object' || error === null || !('digest' in error) || typeof error.digest !== 'string') {
+        return false;
+    }
+    const [prefix, httpStatus] = error.digest.split(';');
+    return prefix === HTTP_ERROR_FALLBACK_ERROR_CODE && ALLOWED_CODES.has(Number(httpStatus));
+}
+export function getAccessFallbackHTTPStatus(error) {
+    const httpStatus = error.digest.split(';')[1];
+    return Number(httpStatus);
+}
+export function getAccessFallbackErrorTypeByStatus(status) {
+    switch(status){
+        case 401:
+            return 'unauthorized';
+        case 403:
+            return 'forbidden';
+        case 404:
+            return 'not-found';
+        default:
+            return;
+    }
+}
+
+//# sourceMappingURL=http-access-fallback.js.map

node_modules/next/dist/esm/client/components/http-access-fallback/http-access-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/http-access-fallback/http-access-fallback.ts"],"sourcesContent":["export const HTTPAccessErrorStatus = {\n  NOT_FOUND: 404,\n  FORBIDDEN: 403,\n  UNAUTHORIZED: 401,\n}\n\nconst ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus))\n\nexport const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK'\n\nexport type HTTPAccessFallbackError = Error & {\n  digest: `${typeof HTTP_ERROR_FALLBACK_ERROR_CODE};${string}`\n}\n\n/**\n * Checks an error to determine if it's an error generated by\n * the HTTP navigation APIs `notFound()`, `forbidden()` or `unauthorized()`.\n *\n * @param error the error that may reference a HTTP access error\n * @returns true if the error is a HTTP access error\n */\nexport function isHTTPAccessFallbackError(\n  error: unknown\n): error is HTTPAccessFallbackError {\n  if (\n    typeof error !== 'object' ||\n    error === null ||\n    !('digest' in error) ||\n    typeof error.digest !== 'string'\n  ) {\n    return false\n  }\n  const [prefix, httpStatus] = error.digest.split(';')\n\n  return (\n    prefix === HTTP_ERROR_FALLBACK_ERROR_CODE &&\n    ALLOWED_CODES.has(Number(httpStatus))\n  )\n}\n\nexport function getAccessFallbackHTTPStatus(\n  error: HTTPAccessFallbackError\n): number {\n  const httpStatus = error.digest.split(';')[1]\n  return Number(httpStatus)\n}\n\nexport function getAccessFallbackErrorTypeByStatus(\n  status: number\n): 'not-found' | 'forbidden' | 'unauthorized' | undefined {\n  switch (status) {\n    case 401:\n      return 'unauthorized'\n    case 403:\n      return 'forbidden'\n    case 404:\n      return 'not-found'\n    default:\n      return\n  }\n}\n"],"names":["HTTPAccessErrorStatus","NOT_FOUND","FORBIDDEN","UNAUTHORIZED","ALLOWED_CODES","Set","Object","values","HTTP_ERROR_FALLBACK_ERROR_CODE","isHTTPAccessFallbackError","error","digest","prefix","httpStatus","split","has","Number","getAccessFallbackHTTPStatus","getAccessFallbackErrorTypeByStatus","status"],"mappings":"AAAA,OAAO,MAAMA,wBAAwB;IACnCC,WAAW;IACXC,WAAW;IACXC,cAAc;AAChB,EAAC;AAED,MAAMC,gBAAgB,IAAIC,IAAIC,OAAOC,MAAM,CAACP;AAE5C,OAAO,MAAMQ,iCAAiC,2BAA0B;AAMxE;;;;;;CAMC,GACD,OAAO,SAASC,0BACdC,KAAc;IAEd,IACE,OAAOA,UAAU,YACjBA,UAAU,QACV,CAAE,CAAA,YAAYA,KAAI,KAClB,OAAOA,MAAMC,MAAM,KAAK,UACxB;QACA,OAAO;IACT;IACA,MAAM,CAACC,QAAQC,WAAW,GAAGH,MAAMC,MAAM,CAACG,KAAK,CAAC;IAEhD,OACEF,WAAWJ,kCACXJ,cAAcW,GAAG,CAACC,OAAOH;AAE7B;AAEA,OAAO,SAASI,4BACdP,KAA8B;IAE9B,MAAMG,aAAaH,MAAMC,MAAM,CAACG,KAAK,CAAC,IAAI,CAAC,EAAE;IAC7C,OAAOE,OAAOH;AAChB;AAEA,OAAO,SAASK,mCACdC,MAAc;IAEd,OAAQA;QACN,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT;YACE;IACJ;AACF"}

node_modules/next/dist/esm/client/components/is-hydration-error.js

@@ -0,0 +1,88 @@
+import isError from '../../lib/is-error';
+const hydrationErrorRegex = /hydration failed|while hydrating|content does not match|did not match|HTML didn't match|text didn't match/i;
+const reactUnifiedMismatchWarning = "Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:";
+const reactHydrationStartMessages = [
+    reactUnifiedMismatchWarning,
+    "Hydration failed because the server rendered text didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:",
+    "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:"
+];
+export const REACT_HYDRATION_ERROR_LINK = 'https://react.dev/link/hydration-mismatch';
+export const NEXTJS_HYDRATION_ERROR_LINK = 'https://nextjs.org/docs/messages/react-hydration-error';
+export const getDefaultHydrationErrorMessage = ()=>{
+    return reactUnifiedMismatchWarning;
+};
+export function isHydrationError(error) {
+    return isError(error) && hydrationErrorRegex.test(error.message);
+}
+export function isReactHydrationErrorMessage(msg) {
+    return reactHydrationStartMessages.some((prefix)=>msg.startsWith(prefix));
+}
+const hydrationWarningRegexes = [
+    /^In HTML, (.+?) cannot be a child of <(.+?)>\.(.*)\nThis will cause a hydration error\.(.*)/,
+    /^In HTML, (.+?) cannot be a descendant of <(.+?)>\.\nThis will cause a hydration error\.(.*)/,
+    /^In HTML, text nodes cannot be a child of <(.+?)>\.\nThis will cause a hydration error\./,
+    /^In HTML, whitespace text nodes cannot be a child of <(.+?)>\. Make sure you don't have any extra whitespace between tags on each line of your source code\.\nThis will cause a hydration error\./,
+    /^Expected server HTML to contain a matching <(.+?)> in <(.+?)>\.(.*)/,
+    /^Did not expect server HTML to contain a <(.+?)> in <(.+?)>\.(.*)/,
+    /^Expected server HTML to contain a matching text node for "(.+?)" in <(.+?)>\.(.*)/,
+    /^Did not expect server HTML to contain the text node "(.+?)" in <(.+?)>\.(.*)/,
+    /^Text content did not match\. Server: "(.+?)" Client: "(.+?)"(.*)/
+];
+export function testReactHydrationWarning(msg) {
+    if (typeof msg !== 'string' || !msg) return false;
+    // React 18 has the `Warning: ` prefix.
+    // React 19 does not.
+    if (msg.startsWith('Warning: ')) {
+        msg = msg.slice('Warning: '.length);
+    }
+    return hydrationWarningRegexes.some((regex)=>regex.test(msg));
+}
+export function getHydrationErrorStackInfo(rawMessage) {
+    rawMessage = rawMessage.replace(/^Error: /, '');
+    rawMessage = rawMessage.replace('Warning: ', '');
+    const isReactHydrationWarning = testReactHydrationWarning(rawMessage);
+    if (!isReactHydrationErrorMessage(rawMessage) && !isReactHydrationWarning) {
+        return {
+            message: null,
+            stack: rawMessage,
+            diff: ''
+        };
+    }
+    if (isReactHydrationWarning) {
+        const [message, diffLog] = rawMessage.split('\n\n');
+        return {
+            message: message.trim(),
+            stack: '',
+            diff: (diffLog || '').trim()
+        };
+    }
+    const firstLineBreak = rawMessage.indexOf('\n');
+    rawMessage = rawMessage.slice(firstLineBreak + 1).trim();
+    const [message, trailing] = rawMessage.split("" + REACT_HYDRATION_ERROR_LINK);
+    const trimmedMessage = message.trim();
+    // React built-in hydration diff starts with a newline, checking if length is > 1
+    if (trailing && trailing.length > 1) {
+        const stacks = [];
+        const diffs = [];
+        trailing.split('\n').forEach((line)=>{
+            if (line.trim() === '') return;
+            if (line.trim().startsWith('at ')) {
+                stacks.push(line);
+            } else {
+                diffs.push(line);
+            }
+        });
+        return {
+            message: trimmedMessage,
+            diff: diffs.join('\n'),
+            stack: stacks.join('\n')
+        };
+    } else {
+        return {
+            message: trimmedMessage,
+            stack: trailing
+        };
+    }
+}
+
+//# sourceMappingURL=is-hydration-error.js.map

node_modules/next/dist/esm/client/components/is-next-router-error.js

@@ -0,0 +1,11 @@
+import { isHTTPAccessFallbackError } from './http-access-fallback/http-access-fallback';
+import { isRedirectError } from './redirect-error';
+/**
+ * Returns true if the error is a navigation signal error. These errors are
+ * thrown by user code to perform navigation operations and interrupt the React
+ * render.
+ */ export function isNextRouterError(error) {
+    return isRedirectError(error) || isHTTPAccessFallbackError(error);
+}
+
+//# sourceMappingURL=is-next-router-error.js.map

node_modules/next/dist/esm/client/components/is-next-router-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/is-next-router-error.ts"],"sourcesContent":["import {\n  isHTTPAccessFallbackError,\n  type HTTPAccessFallbackError,\n} from './http-access-fallback/http-access-fallback'\nimport { isRedirectError, type RedirectError } from './redirect-error'\n\n/**\n * Returns true if the error is a navigation signal error. These errors are\n * thrown by user code to perform navigation operations and interrupt the React\n * render.\n */\nexport function isNextRouterError(\n  error: unknown\n): error is RedirectError | HTTPAccessFallbackError {\n  return isRedirectError(error) || isHTTPAccessFallbackError(error)\n}\n"],"names":["isHTTPAccessFallbackError","isRedirectError","isNextRouterError","error"],"mappings":"AAAA,SACEA,yBAAyB,QAEpB,8CAA6C;AACpD,SAASC,eAAe,QAA4B,mBAAkB;AAEtE;;;;CAIC,GACD,OAAO,SAASC,kBACdC,KAAc;IAEd,OAAOF,gBAAgBE,UAAUH,0BAA0BG;AAC7D"}

node_modules/next/dist/esm/client/components/layout-router.js

@@ -0,0 +1,469 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ACTION_SERVER_PATCH } from './router-reducer/router-reducer-types';
+import React, { useContext, use, startTransition, Suspense, useDeferredValue } from 'react';
+import ReactDOM from 'react-dom';
+import { LayoutRouterContext, GlobalLayoutRouterContext, TemplateContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { fetchServerResponse } from './router-reducer/fetch-server-response';
+import { unresolvedThenable } from './unresolved-thenable';
+import { ErrorBoundary } from './error-boundary';
+import { matchSegment } from './match-segments';
+import { handleSmoothScroll } from '../../shared/lib/router/utils/handle-smooth-scroll';
+import { RedirectBoundary } from './redirect-boundary';
+import { HTTPAccessFallbackBoundary } from './http-access-fallback/error-boundary';
+import { createRouterCacheKey } from './router-reducer/create-router-cache-key';
+import { hasInterceptionRouteInCurrentTree } from './router-reducer/reducers/has-interception-route-in-current-tree';
+import { dispatchAppRouterAction } from './use-action-queue';
+/**
+ * Add refetch marker to router state at the point of the current layout segment.
+ * This ensures the response returned is not further down than the current layout segment.
+ */ function walkAddRefetch(segmentPathToWalk, treeToRecreate) {
+    if (segmentPathToWalk) {
+        const [segment, parallelRouteKey] = segmentPathToWalk;
+        const isLast = segmentPathToWalk.length === 2;
+        if (matchSegment(treeToRecreate[0], segment)) {
+            if (treeToRecreate[1].hasOwnProperty(parallelRouteKey)) {
+                if (isLast) {
+                    const subTree = walkAddRefetch(undefined, treeToRecreate[1][parallelRouteKey]);
+                    return [
+                        treeToRecreate[0],
+                        {
+                            ...treeToRecreate[1],
+                            [parallelRouteKey]: [
+                                subTree[0],
+                                subTree[1],
+                                subTree[2],
+                                'refetch'
+                            ]
+                        }
+                    ];
+                }
+                return [
+                    treeToRecreate[0],
+                    {
+                        ...treeToRecreate[1],
+                        [parallelRouteKey]: walkAddRefetch(segmentPathToWalk.slice(2), treeToRecreate[1][parallelRouteKey])
+                    }
+                ];
+            }
+        }
+    }
+    return treeToRecreate;
+}
+const __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+// TODO-APP: Replace with new React API for finding dom nodes without a `ref` when available
+/**
+ * Wraps ReactDOM.findDOMNode with additional logic to hide React Strict Mode warning
+ */ function findDOMNode(instance) {
+    // Tree-shake for server bundle
+    if (typeof window === 'undefined') return null;
+    // __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode is null during module init.
+    // We need to lazily reference it.
+    const internal_reactDOMfindDOMNode = __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode;
+    return internal_reactDOMfindDOMNode(instance);
+}
+const rectProperties = [
+    'bottom',
+    'height',
+    'left',
+    'right',
+    'top',
+    'width',
+    'x',
+    'y'
+];
+/**
+ * Check if a HTMLElement is hidden or fixed/sticky position
+ */ function shouldSkipElement(element) {
+    // we ignore fixed or sticky positioned elements since they'll likely pass the "in-viewport" check
+    // and will result in a situation we bail on scroll because of something like a fixed nav,
+    // even though the actual page content is offscreen
+    if ([
+        'sticky',
+        'fixed'
+    ].includes(getComputedStyle(element).position)) {
+        if (process.env.NODE_ENV === 'development') {
+            console.warn('Skipping auto-scroll behavior due to `position: sticky` or `position: fixed` on element:', element);
+        }
+        return true;
+    }
+    // Uses `getBoundingClientRect` to check if the element is hidden instead of `offsetParent`
+    // because `offsetParent` doesn't consider document/body
+    const rect = element.getBoundingClientRect();
+    return rectProperties.every((item)=>rect[item] === 0);
+}
+/**
+ * Check if the top corner of the HTMLElement is in the viewport.
+ */ function topOfElementInViewport(element, viewportHeight) {
+    const rect = element.getBoundingClientRect();
+    return rect.top >= 0 && rect.top <= viewportHeight;
+}
+/**
+ * Find the DOM node for a hash fragment.
+ * If `top` the page has to scroll to the top of the page. This mirrors the browser's behavior.
+ * If the hash fragment is an id, the page has to scroll to the element with that id.
+ * If the hash fragment is a name, the page has to scroll to the first element with that name.
+ */ function getHashFragmentDomNode(hashFragment) {
+    // If the hash fragment is `top` the page has to scroll to the top of the page.
+    if (hashFragment === 'top') {
+        return document.body;
+    }
+    var _document_getElementById;
+    // If the hash fragment is an id, the page has to scroll to the element with that id.
+    return (_document_getElementById = document.getElementById(hashFragment)) != null ? _document_getElementById : // If the hash fragment is a name, the page has to scroll to the first element with that name.
+    document.getElementsByName(hashFragment)[0];
+}
+class InnerScrollAndFocusHandler extends React.Component {
+    componentDidMount() {
+        this.handlePotentialScroll();
+    }
+    componentDidUpdate() {
+        // Because this property is overwritten in handlePotentialScroll it's fine to always run it when true as it'll be set to false for subsequent renders.
+        if (this.props.focusAndScrollRef.apply) {
+            this.handlePotentialScroll();
+        }
+    }
+    render() {
+        return this.props.children;
+    }
+    constructor(...args){
+        super(...args), this.handlePotentialScroll = ()=>{
+            // Handle scroll and focus, it's only applied once in the first useEffect that triggers that changed.
+            const { focusAndScrollRef, segmentPath } = this.props;
+            if (focusAndScrollRef.apply) {
+                // segmentPaths is an array of segment paths that should be scrolled to
+                // if the current segment path is not in the array, the scroll is not applied
+                // unless the array is empty, in which case the scroll is always applied
+                if (focusAndScrollRef.segmentPaths.length !== 0 && !focusAndScrollRef.segmentPaths.some((scrollRefSegmentPath)=>segmentPath.every((segment, index)=>matchSegment(segment, scrollRefSegmentPath[index])))) {
+                    return;
+                }
+                let domNode = null;
+                const hashFragment = focusAndScrollRef.hashFragment;
+                if (hashFragment) {
+                    domNode = getHashFragmentDomNode(hashFragment);
+                }
+                // `findDOMNode` is tricky because it returns just the first child if the component is a fragment.
+                // This already caused a bug where the first child was a <link/> in head.
+                if (!domNode) {
+                    domNode = findDOMNode(this);
+                }
+                // If there is no DOM node this layout-router level is skipped. It'll be handled higher-up in the tree.
+                if (!(domNode instanceof Element)) {
+                    return;
+                }
+                // Verify if the element is a HTMLElement and if we want to consider it for scroll behavior.
+                // If the element is skipped, try to select the next sibling and try again.
+                while(!(domNode instanceof HTMLElement) || shouldSkipElement(domNode)){
+                    if (process.env.NODE_ENV !== 'production') {
+                        var _domNode_parentElement;
+                        if (((_domNode_parentElement = domNode.parentElement) == null ? void 0 : _domNode_parentElement.localName) === 'head') {
+                        // TODO: We enter this state when metadata was rendered as part of the page or via Next.js.
+                        // This is always a bug in Next.js and caused by React hoisting metadata.
+                        // We need to replace `findDOMNode` in favor of Fragment Refs (when available) so that we can skip over metadata.
+                        }
+                    }
+                    // No siblings found that match the criteria are found, so handle scroll higher up in the tree instead.
+                    if (domNode.nextElementSibling === null) {
+                        return;
+                    }
+                    domNode = domNode.nextElementSibling;
+                }
+                // State is mutated to ensure that the focus and scroll is applied only once.
+                focusAndScrollRef.apply = false;
+                focusAndScrollRef.hashFragment = null;
+                focusAndScrollRef.segmentPaths = [];
+                handleSmoothScroll(()=>{
+                    // In case of hash scroll, we only need to scroll the element into view
+                    if (hashFragment) {
+                        ;
+                        domNode.scrollIntoView();
+                        return;
+                    }
+                    // Store the current viewport height because reading `clientHeight` causes a reflow,
+                    // and it won't change during this function.
+                    const htmlElement = document.documentElement;
+                    const viewportHeight = htmlElement.clientHeight;
+                    // If the element's top edge is already in the viewport, exit early.
+                    if (topOfElementInViewport(domNode, viewportHeight)) {
+                        return;
+                    }
+                    // Otherwise, try scrolling go the top of the document to be backward compatible with pages
+                    // scrollIntoView() called on `<html/>` element scrolls horizontally on chrome and firefox (that shouldn't happen)
+                    // We could use it to scroll horizontally following RTL but that also seems to be broken - it will always scroll left
+                    // scrollLeft = 0 also seems to ignore RTL and manually checking for RTL is too much hassle so we will scroll just vertically
+                    htmlElement.scrollTop = 0;
+                    // Scroll to domNode if domNode is not in viewport when scrolled to top of document
+                    if (!topOfElementInViewport(domNode, viewportHeight)) {
+                        // Scroll into view doesn't scroll horizontally by default when not needed
+                        ;
+                        domNode.scrollIntoView();
+                    }
+                }, {
+                    // We will force layout by querying domNode position
+                    dontForceLayout: true,
+                    onlyHashChange: focusAndScrollRef.onlyHashChange
+                });
+                // Mutate after scrolling so that it can be read by `handleSmoothScroll`
+                focusAndScrollRef.onlyHashChange = false;
+                // Set focus on the element
+                domNode.focus();
+            }
+        };
+    }
+}
+function ScrollAndFocusHandler(param) {
+    let { segmentPath, children } = param;
+    const context = useContext(GlobalLayoutRouterContext);
+    if (!context) {
+        throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
+            value: "E473",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return /*#__PURE__*/ _jsx(InnerScrollAndFocusHandler, {
+        segmentPath: segmentPath,
+        focusAndScrollRef: context.focusAndScrollRef,
+        children: children
+    });
+}
+/**
+ * InnerLayoutRouter handles rendering the provided segment based on the cache.
+ */ function InnerLayoutRouter(param) {
+    let { tree, segmentPath, cacheNode, url } = param;
+    const context = useContext(GlobalLayoutRouterContext);
+    if (!context) {
+        throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
+            value: "E473",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { tree: fullTree } = context;
+    // `rsc` represents the renderable node for this segment.
+    // If this segment has a `prefetchRsc`, it's the statically prefetched data.
+    // We should use that on initial render instead of `rsc`. Then we'll switch
+    // to `rsc` when the dynamic response streams in.
+    //
+    // If no prefetch data is available, then we go straight to rendering `rsc`.
+    const resolvedPrefetchRsc = cacheNode.prefetchRsc !== null ? cacheNode.prefetchRsc : cacheNode.rsc;
+    // We use `useDeferredValue` to handle switching between the prefetched and
+    // final values. The second argument is returned on initial render, then it
+    // re-renders with the first argument.
+    const rsc = useDeferredValue(cacheNode.rsc, resolvedPrefetchRsc);
+    // `rsc` is either a React node or a promise for a React node, except we
+    // special case `null` to represent that this segment's data is missing. If
+    // it's a promise, we need to unwrap it so we can determine whether or not the
+    // data is missing.
+    const resolvedRsc = typeof rsc === 'object' && rsc !== null && typeof rsc.then === 'function' ? use(rsc) : rsc;
+    if (!resolvedRsc) {
+        // The data for this segment is not available, and there's no pending
+        // navigation that will be able to fulfill it. We need to fetch more from
+        // the server and patch the cache.
+        // Check if there's already a pending request.
+        let lazyData = cacheNode.lazyData;
+        if (lazyData === null) {
+            /**
+       * Router state with refetch marker added
+       */ // TODO-APP: remove ''
+            const refetchTree = walkAddRefetch([
+                '',
+                ...segmentPath
+            ], fullTree);
+            const includeNextUrl = hasInterceptionRouteInCurrentTree(fullTree);
+            const navigatedAt = Date.now();
+            cacheNode.lazyData = lazyData = fetchServerResponse(new URL(url, location.origin), {
+                flightRouterState: refetchTree,
+                nextUrl: includeNextUrl ? context.nextUrl : null
+            }).then((serverResponse)=>{
+                startTransition(()=>{
+                    dispatchAppRouterAction({
+                        type: ACTION_SERVER_PATCH,
+                        previousTree: fullTree,
+                        serverResponse,
+                        navigatedAt
+                    });
+                });
+                return serverResponse;
+            });
+            // Suspend while waiting for lazyData to resolve
+            use(lazyData);
+        }
+        // Suspend infinitely as `changeByServerResponse` will cause a different part of the tree to be rendered.
+        // A falsey `resolvedRsc` indicates missing data -- we should not commit that branch, and we need to wait for the data to arrive.
+        use(unresolvedThenable);
+    }
+    // If we get to this point, then we know we have something we can render.
+    const subtree = // The layout router context narrows down tree and childNodes at each level.
+    /*#__PURE__*/ _jsx(LayoutRouterContext.Provider, {
+        value: {
+            parentTree: tree,
+            parentCacheNode: cacheNode,
+            parentSegmentPath: segmentPath,
+            // TODO-APP: overriding of url for parallel routes
+            url: url
+        },
+        children: resolvedRsc
+    });
+    // Ensure root layout is not wrapped in a div as the root layout renders `<html>`
+    return subtree;
+}
+/**
+ * Renders suspense boundary with the provided "loading" property as the fallback.
+ * If no loading property is provided it renders the children without a suspense boundary.
+ */ function LoadingBoundary(param) {
+    let { loading, children } = param;
+    // If loading is a promise, unwrap it. This happens in cases where we haven't
+    // yet received the loading data from the server — which includes whether or
+    // not this layout has a loading component at all.
+    //
+    // It's OK to suspend here instead of inside the fallback because this
+    // promise will resolve simultaneously with the data for the segment itself.
+    // So it will never suspend for longer than it would have if we didn't use
+    // a Suspense fallback at all.
+    let loadingModuleData;
+    if (typeof loading === 'object' && loading !== null && typeof loading.then === 'function') {
+        const promiseForLoading = loading;
+        loadingModuleData = use(promiseForLoading);
+    } else {
+        loadingModuleData = loading;
+    }
+    if (loadingModuleData) {
+        const loadingRsc = loadingModuleData[0];
+        const loadingStyles = loadingModuleData[1];
+        const loadingScripts = loadingModuleData[2];
+        return /*#__PURE__*/ _jsx(Suspense, {
+            fallback: /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    loadingStyles,
+                    loadingScripts,
+                    loadingRsc
+                ]
+            }),
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsx(_Fragment, {
+        children: children
+    });
+}
+/**
+ * OuterLayoutRouter handles the current segment as well as <Offscreen> rendering of other segments.
+ * It can be rendered next to each other with a different `parallelRouterKey`, allowing for Parallel routes.
+ */ export default function OuterLayoutRouter(param) {
+    let { parallelRouterKey, error, errorStyles, errorScripts, templateStyles, templateScripts, template, notFound, forbidden, unauthorized } = param;
+    const context = useContext(LayoutRouterContext);
+    if (!context) {
+        throw Object.defineProperty(new Error('invariant expected layout router to be mounted'), "__NEXT_ERROR_CODE", {
+            value: "E56",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { parentTree, parentCacheNode, parentSegmentPath, url } = context;
+    // Get the CacheNode for this segment by reading it from the parent segment's
+    // child map.
+    const parentParallelRoutes = parentCacheNode.parallelRoutes;
+    let segmentMap = parentParallelRoutes.get(parallelRouterKey);
+    // If the parallel router cache node does not exist yet, create it.
+    // This writes to the cache when there is no item in the cache yet. It never *overwrites* existing cache items which is why it's safe in concurrent mode.
+    if (!segmentMap) {
+        segmentMap = new Map();
+        parentParallelRoutes.set(parallelRouterKey, segmentMap);
+    }
+    // Get the active segment in the tree
+    // The reason arrays are used in the data format is that these are transferred from the server to the browser so it's optimized to save bytes.
+    const parentTreeSegment = parentTree[0];
+    const tree = parentTree[1][parallelRouterKey];
+    const treeSegment = tree[0];
+    const segmentPath = parentSegmentPath === null ? // path. This has led to a bunch of special cases scattered throughout
+    // the code. We should clean this up.
+    [
+        parallelRouterKey
+    ] : parentSegmentPath.concat([
+        parentTreeSegment,
+        parallelRouterKey
+    ]);
+    // The "state" key of a segment is the one passed to React — it represents the
+    // identity of the UI tree. Whenever the state key changes, the tree is
+    // recreated and the state is reset. In the App Router model, search params do
+    // not cause state to be lost, so two segments with the same segment path but
+    // different search params should have the same state key.
+    //
+    // The "cache" key of a segment, however, *does* include the search params, if
+    // it's possible that the segment accessed the search params on the server.
+    // (This only applies to page segments; layout segments cannot access search
+    // params on the server.)
+    const cacheKey = createRouterCacheKey(treeSegment);
+    const stateKey = createRouterCacheKey(treeSegment, true) // no search params
+    ;
+    // Read segment path from the parallel router cache node.
+    let cacheNode = segmentMap.get(cacheKey);
+    if (cacheNode === undefined) {
+        // When data is not available during rendering client-side we need to fetch
+        // it from the server.
+        const newLazyCacheNode = {
+            lazyData: null,
+            rsc: null,
+            prefetchRsc: null,
+            head: null,
+            prefetchHead: null,
+            parallelRoutes: new Map(),
+            loading: null,
+            navigatedAt: -1
+        };
+        // Flight data fetch kicked off during render and put into the cache.
+        cacheNode = newLazyCacheNode;
+        segmentMap.set(cacheKey, newLazyCacheNode);
+    }
+    /*
+    - Error boundary
+      - Only renders error boundary if error component is provided.
+      - Rendered for each segment to ensure they have their own error state.
+    - Loading boundary
+      - Only renders suspense boundary if loading components is provided.
+      - Rendered for each segment to ensure they have their own loading state.
+      - Passed to the router during rendering to ensure it can be immediately rendered when suspending on a Flight fetch.
+  */ // TODO: The loading module data for a segment is stored on the parent, then
+    // applied to each of that parent segment's parallel route slots. In the
+    // simple case where there's only one parallel route (the `children` slot),
+    // this is no different from if the loading module data where stored on the
+    // child directly. But I'm not sure this actually makes sense when there are
+    // multiple parallel routes. It's not a huge issue because you always have
+    // the option to define a narrower loading boundary for a particular slot. But
+    // this sort of smells like an implementation accident to me.
+    const loadingModuleData = parentCacheNode.loading;
+    return /*#__PURE__*/ _jsxs(TemplateContext.Provider, {
+        value: /*#__PURE__*/ _jsx(ScrollAndFocusHandler, {
+            segmentPath: segmentPath,
+            children: /*#__PURE__*/ _jsx(ErrorBoundary, {
+                errorComponent: error,
+                errorStyles: errorStyles,
+                errorScripts: errorScripts,
+                children: /*#__PURE__*/ _jsx(LoadingBoundary, {
+                    loading: loadingModuleData,
+                    children: /*#__PURE__*/ _jsx(HTTPAccessFallbackBoundary, {
+                        notFound: notFound,
+                        forbidden: forbidden,
+                        unauthorized: unauthorized,
+                        children: /*#__PURE__*/ _jsx(RedirectBoundary, {
+                            children: /*#__PURE__*/ _jsx(InnerLayoutRouter, {
+                                url: url,
+                                tree: tree,
+                                cacheNode: cacheNode,
+                                segmentPath: segmentPath
+                            })
+                        })
+                    })
+                })
+            })
+        }),
+        children: [
+            templateStyles,
+            templateScripts,
+            template
+        ]
+    }, stateKey);
+}
+
+//# sourceMappingURL=layout-router.js.map

node_modules/next/dist/esm/client/components/links.js

@@ -0,0 +1,282 @@
+import { getCurrentAppRouterState } from './app-router-instance';
+import { createPrefetchURL } from './app-router';
+import { PrefetchKind } from './router-reducer/router-reducer-types';
+import { getCurrentCacheVersion } from './segment-cache';
+import { createCacheKey } from './segment-cache';
+import { PrefetchPriority, schedulePrefetchTask as scheduleSegmentPrefetchTask, cancelPrefetchTask, reschedulePrefetchTask } from './segment-cache';
+import { startTransition } from 'react';
+// Tracks the most recently navigated link instance. When null, indicates
+// the current navigation was not initiated by a link click.
+let linkForMostRecentNavigation = null;
+// Status object indicating link is pending
+export const PENDING_LINK_STATUS = {
+    pending: true
+};
+// Status object indicating link is idle
+export const IDLE_LINK_STATUS = {
+    pending: false
+};
+// Updates the loading state when navigating between links
+// - Resets the previous link's loading state
+// - Sets the new link's loading state
+// - Updates tracking of current navigation
+export function setLinkForCurrentNavigation(link) {
+    startTransition(()=>{
+        linkForMostRecentNavigation == null ? void 0 : linkForMostRecentNavigation.setOptimisticLinkStatus(IDLE_LINK_STATUS);
+        link == null ? void 0 : link.setOptimisticLinkStatus(PENDING_LINK_STATUS);
+        linkForMostRecentNavigation = link;
+    });
+}
+// Unmounts the current link instance from navigation tracking
+export function unmountLinkForCurrentNavigation(link) {
+    if (linkForMostRecentNavigation === link) {
+        linkForMostRecentNavigation = null;
+    }
+}
+// Use a WeakMap to associate a Link instance with its DOM element. This is
+// used by the IntersectionObserver to track the link's visibility.
+const prefetchable = typeof WeakMap === 'function' ? new WeakMap() : new Map();
+// A Set of the currently visible links. We re-prefetch visible links after a
+// cache invalidation, or when the current URL changes. It's a separate data
+// structure from the WeakMap above because only the visible links need to
+// be enumerated.
+const prefetchableAndVisible = new Set();
+// A single IntersectionObserver instance shared by all <Link> components.
+const observer = typeof IntersectionObserver === 'function' ? new IntersectionObserver(handleIntersect, {
+    rootMargin: '200px'
+}) : null;
+function observeVisibility(element, instance) {
+    const existingInstance = prefetchable.get(element);
+    if (existingInstance !== undefined) {
+        // This shouldn't happen because each <Link> component should have its own
+        // anchor tag instance, but it's defensive coding to avoid a memory leak in
+        // case there's a logical error somewhere else.
+        unmountPrefetchableInstance(element);
+    }
+    // Only track prefetchable links that have a valid prefetch URL
+    prefetchable.set(element, instance);
+    if (observer !== null) {
+        observer.observe(element);
+    }
+}
+function coercePrefetchableUrl(href) {
+    try {
+        return createPrefetchURL(href);
+    } catch (e) {
+        // createPrefetchURL sometimes throws an error if an invalid URL is
+        // provided, though I'm not sure if it's actually necessary.
+        // TODO: Consider removing the throw from the inner function, or change it
+        // to reportError. Or maybe the error isn't even necessary for automatic
+        // prefetches, just navigations.
+        const reportErrorFn = typeof reportError === 'function' ? reportError : console.error;
+        reportErrorFn("Cannot prefetch '" + href + "' because it cannot be converted to a URL.");
+        return null;
+    }
+}
+export function mountLinkInstance(element, href, router, kind, prefetchEnabled, setOptimisticLinkStatus) {
+    if (prefetchEnabled) {
+        const prefetchURL = coercePrefetchableUrl(href);
+        if (prefetchURL !== null) {
+            const instance = {
+                router,
+                kind,
+                isVisible: false,
+                wasHoveredOrTouched: false,
+                prefetchTask: null,
+                cacheVersion: -1,
+                prefetchHref: prefetchURL.href,
+                setOptimisticLinkStatus
+            };
+            // We only observe the link's visibility if it's prefetchable. For
+            // example, this excludes links to external URLs.
+            observeVisibility(element, instance);
+            return instance;
+        }
+    }
+    // If the link is not prefetchable, we still create an instance so we can
+    // track its optimistic state (i.e. useLinkStatus).
+    const instance = {
+        router,
+        kind,
+        isVisible: false,
+        wasHoveredOrTouched: false,
+        prefetchTask: null,
+        cacheVersion: -1,
+        prefetchHref: null,
+        setOptimisticLinkStatus
+    };
+    return instance;
+}
+export function mountFormInstance(element, href, router, kind) {
+    const prefetchURL = coercePrefetchableUrl(href);
+    if (prefetchURL === null) {
+        // This href is not prefetchable, so we don't track it.
+        // TODO: We currently observe/unobserve a form every time its href changes.
+        // For Links, this isn't a big deal because the href doesn't usually change,
+        // but for forms it's extremely common. We should optimize this.
+        return;
+    }
+    const instance = {
+        router,
+        kind,
+        isVisible: false,
+        wasHoveredOrTouched: false,
+        prefetchTask: null,
+        cacheVersion: -1,
+        prefetchHref: prefetchURL.href,
+        setOptimisticLinkStatus: null
+    };
+    observeVisibility(element, instance);
+}
+export function unmountPrefetchableInstance(element) {
+    const instance = prefetchable.get(element);
+    if (instance !== undefined) {
+        prefetchable.delete(element);
+        prefetchableAndVisible.delete(instance);
+        const prefetchTask = instance.prefetchTask;
+        if (prefetchTask !== null) {
+            cancelPrefetchTask(prefetchTask);
+        }
+    }
+    if (observer !== null) {
+        observer.unobserve(element);
+    }
+}
+function handleIntersect(entries) {
+    for (const entry of entries){
+        // Some extremely old browsers or polyfills don't reliably support
+        // isIntersecting so we check intersectionRatio instead. (Do we care? Not
+        // really. But whatever this is fine.)
+        const isVisible = entry.intersectionRatio > 0;
+        onLinkVisibilityChanged(entry.target, isVisible);
+    }
+}
+export function onLinkVisibilityChanged(element, isVisible) {
+    if (process.env.NODE_ENV !== 'production') {
+        // Prefetching on viewport is disabled in development for performance
+        // reasons, because it requires compiling the target page.
+        // TODO: Investigate re-enabling this.
+        return;
+    }
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    instance.isVisible = isVisible;
+    if (isVisible) {
+        prefetchableAndVisible.add(instance);
+    } else {
+        prefetchableAndVisible.delete(instance);
+    }
+    rescheduleLinkPrefetch(instance);
+}
+export function onNavigationIntent(element, unstable_upgradeToDynamicPrefetch) {
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    // Prefetch the link on hover/touchstart.
+    if (instance !== undefined) {
+        instance.wasHoveredOrTouched = true;
+        if (process.env.__NEXT_DYNAMIC_ON_HOVER && unstable_upgradeToDynamicPrefetch) {
+            // Switch to a full, dynamic prefetch
+            instance.kind = PrefetchKind.FULL;
+        }
+        rescheduleLinkPrefetch(instance);
+    }
+}
+function rescheduleLinkPrefetch(instance) {
+    const existingPrefetchTask = instance.prefetchTask;
+    if (!instance.isVisible) {
+        // Cancel any in-progress prefetch task. (If it already finished then this
+        // is a no-op.)
+        if (existingPrefetchTask !== null) {
+            cancelPrefetchTask(existingPrefetchTask);
+        }
+        // We don't need to reset the prefetchTask to null upon cancellation; an
+        // old task object can be rescheduled with reschedulePrefetchTask. This is a
+        // micro-optimization but also makes the code simpler (don't need to
+        // worry about whether an old task object is stale).
+        return;
+    }
+    if (!process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
+        // The old prefetch implementation does not have different priority levels.
+        // Just schedule a new prefetch task.
+        prefetchWithOldCacheImplementation(instance);
+        return;
+    }
+    // In the Segment Cache implementation, we assign a higher priority level to
+    // links that were at one point hovered or touched. Since the queue is last-
+    // in-first-out, the highest priority Link is whichever one was hovered last.
+    //
+    // We also increase the relative priority of links whenever they re-enter the
+    // viewport, as if they were being scheduled for the first time.
+    const priority = instance.wasHoveredOrTouched ? PrefetchPriority.Intent : PrefetchPriority.Default;
+    const appRouterState = getCurrentAppRouterState();
+    if (appRouterState !== null) {
+        const treeAtTimeOfPrefetch = appRouterState.tree;
+        if (existingPrefetchTask === null) {
+            // Initiate a prefetch task.
+            const nextUrl = appRouterState.nextUrl;
+            const cacheKey = createCacheKey(instance.prefetchHref, nextUrl);
+            instance.prefetchTask = scheduleSegmentPrefetchTask(cacheKey, treeAtTimeOfPrefetch, instance.kind === PrefetchKind.FULL, priority);
+        } else {
+            // We already have an old task object that we can reschedule. This is
+            // effectively the same as canceling the old task and creating a new one.
+            reschedulePrefetchTask(existingPrefetchTask, treeAtTimeOfPrefetch, instance.kind === PrefetchKind.FULL, priority);
+        }
+        // Keep track of the cache version at the time the prefetch was requested.
+        // This is used to check if the prefetch is stale.
+        instance.cacheVersion = getCurrentCacheVersion();
+    }
+}
+export function pingVisibleLinks(nextUrl, tree) {
+    // For each currently visible link, cancel the existing prefetch task (if it
+    // exists) and schedule a new one. This is effectively the same as if all the
+    // visible links left and then re-entered the viewport.
+    //
+    // This is called when the Next-Url or the base tree changes, since those
+    // may affect the result of a prefetch task. It's also called after a
+    // cache invalidation.
+    const currentCacheVersion = getCurrentCacheVersion();
+    for (const instance of prefetchableAndVisible){
+        const task = instance.prefetchTask;
+        if (task !== null && instance.cacheVersion === currentCacheVersion && task.key.nextUrl === nextUrl && task.treeAtTimeOfPrefetch === tree) {
+            continue;
+        }
+        // Something changed. Cancel the existing prefetch task and schedule a
+        // new one.
+        if (task !== null) {
+            cancelPrefetchTask(task);
+        }
+        const cacheKey = createCacheKey(instance.prefetchHref, nextUrl);
+        const priority = instance.wasHoveredOrTouched ? PrefetchPriority.Intent : PrefetchPriority.Default;
+        instance.prefetchTask = scheduleSegmentPrefetchTask(cacheKey, tree, instance.kind === PrefetchKind.FULL, priority);
+        instance.cacheVersion = getCurrentCacheVersion();
+    }
+}
+function prefetchWithOldCacheImplementation(instance) {
+    // This is the path used when the Segment Cache is not enabled.
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const doPrefetch = async ()=>{
+        // note that `appRouter.prefetch()` is currently sync,
+        // so we have to wrap this call in an async function to be able to catch() errors below.
+        return instance.router.prefetch(instance.prefetchHref, {
+            kind: instance.kind
+        });
+    };
+    // Prefetch the 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
+    doPrefetch().catch((err)=>{
+        if (process.env.NODE_ENV !== 'production') {
+            // rethrow to show invalid URL errors
+            throw err;
+        }
+    });
+}
+
+//# sourceMappingURL=links.js.map

node_modules/next/dist/esm/client/components/match-segments.js

@@ -0,0 +1,16 @@
+export const matchSegment = (existingSegment, segment)=>{
+    // segment is either Array or string
+    if (typeof existingSegment === 'string') {
+        if (typeof segment === 'string') {
+            // Common case: segment is just a string
+            return existingSegment === segment;
+        }
+        return false;
+    }
+    if (typeof segment === 'string') {
+        return false;
+    }
+    return existingSegment[0] === segment[0] && existingSegment[1] === segment[1];
+};
+
+//# sourceMappingURL=match-segments.js.map

node_modules/next/dist/esm/client/components/match-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/match-segments.ts"],"sourcesContent":["import type { Segment } from '../../server/app-render/types'\n\nexport const matchSegment = (\n  existingSegment: Segment,\n  segment: Segment\n): boolean => {\n  // segment is either Array or string\n  if (typeof existingSegment === 'string') {\n    if (typeof segment === 'string') {\n      // Common case: segment is just a string\n      return existingSegment === segment\n    }\n    return false\n  }\n\n  if (typeof segment === 'string') {\n    return false\n  }\n  return existingSegment[0] === segment[0] && existingSegment[1] === segment[1]\n}\n"],"names":["matchSegment","existingSegment","segment"],"mappings":"AAEA,OAAO,MAAMA,eAAe,CAC1BC,iBACAC;IAEA,oCAAoC;IACpC,IAAI,OAAOD,oBAAoB,UAAU;QACvC,IAAI,OAAOC,YAAY,UAAU;YAC/B,wCAAwC;YACxC,OAAOD,oBAAoBC;QAC7B;QACA,OAAO;IACT;IAEA,IAAI,OAAOA,YAAY,UAAU;QAC/B,OAAO;IACT;IACA,OAAOD,eAAe,CAAC,EAAE,KAAKC,OAAO,CAAC,EAAE,IAAID,eAAe,CAAC,EAAE,KAAKC,OAAO,CAAC,EAAE;AAC/E,EAAC"}

node_modules/next/dist/esm/client/components/metadata/async-metadata.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, use } from 'react';
+export const AsyncMetadata = typeof window === 'undefined' ? require('./server-inserted-metadata').ServerInsertMetadata : require('./browser-resolved-metadata').BrowserResolvedMetadata;
+function MetadataOutlet(param) {
+    let { promise } = param;
+    const { error, digest } = use(promise);
+    if (error) {
+        if (digest) {
+            // The error will lose its original digest after passing from server layer to client layer；
+            // We recover the digest property here to override the React created one if original digest exists.
+            ;
+            error.digest = digest;
+        }
+        throw error;
+    }
+    return null;
+}
+export function AsyncMetadataOutlet(param) {
+    let { promise } = param;
+    return /*#__PURE__*/ _jsx(Suspense, {
+        fallback: null,
+        children: /*#__PURE__*/ _jsx(MetadataOutlet, {
+            promise: promise
+        })
+    });
+}
+
+//# sourceMappingURL=async-metadata.js.map

node_modules/next/dist/esm/client/components/metadata/async-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/metadata/async-metadata.tsx"],"sourcesContent":["'use client'\n\nimport { Suspense, use } from 'react'\nimport type { StreamingMetadataResolvedState } from './types'\n\nexport const AsyncMetadata =\n  typeof window === 'undefined'\n    ? (\n        require('./server-inserted-metadata') as typeof import('./server-inserted-metadata')\n      ).ServerInsertMetadata\n    : (\n        require('./browser-resolved-metadata') as typeof import('./browser-resolved-metadata')\n      ).BrowserResolvedMetadata\n\nfunction MetadataOutlet({\n  promise,\n}: {\n  promise: Promise<StreamingMetadataResolvedState>\n}) {\n  const { error, digest } = use(promise)\n  if (error) {\n    if (digest) {\n      // The error will lose its original digest after passing from server layer to client layer；\n      // We recover the digest property here to override the React created one if original digest exists.\n      ;(error as any).digest = digest\n    }\n    throw error\n  }\n  return null\n}\n\nexport function AsyncMetadataOutlet({\n  promise,\n}: {\n  promise: Promise<StreamingMetadataResolvedState>\n}) {\n  return (\n    <Suspense fallback={null}>\n      <MetadataOutlet promise={promise} />\n    </Suspense>\n  )\n}\n"],"names":["Suspense","use","AsyncMetadata","window","require","ServerInsertMetadata","BrowserResolvedMetadata","MetadataOutlet","promise","error","digest","AsyncMetadataOutlet","fallback"],"mappings":"AAAA;;AAEA,SAASA,QAAQ,EAAEC,GAAG,QAAQ,QAAO;AAGrC,OAAO,MAAMC,gBACX,OAAOC,WAAW,cACd,AACEC,QAAQ,8BACRC,oBAAoB,GACtB,AACED,QAAQ,+BACRE,uBAAuB,CAAA;AAE/B,SAASC,eAAe,KAIvB;IAJuB,IAAA,EACtBC,OAAO,EAGR,GAJuB;IAKtB,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,GAAGT,IAAIO;IAC9B,IAAIC,OAAO;QACT,IAAIC,QAAQ;YACV,2FAA2F;YAC3F,mGAAmG;;YACjGD,MAAcC,MAAM,GAAGA;QAC3B;QACA,MAAMD;IACR;IACA,OAAO;AACT;AAEA,OAAO,SAASE,oBAAoB,KAInC;IAJmC,IAAA,EAClCH,OAAO,EAGR,GAJmC;IAKlC,qBACE,KAACR;QAASY,UAAU;kBAClB,cAAA,KAACL;YAAeC,SAASA;;;AAG/B"}

node_modules/next/dist/esm/client/components/metadata/browser-resolved-metadata.js

@@ -0,0 +1,11 @@
+import { use } from 'react';
+export function BrowserResolvedMetadata(param) {
+    let { promise } = param;
+    const { metadata, error } = use(promise);
+    // If there's metadata error on client, discard the browser metadata
+    // and let metadata outlet deal with the error. This will avoid the duplication metadata.
+    if (error) return null;
+    return metadata;
+}
+
+//# sourceMappingURL=browser-resolved-metadata.js.map

node_modules/next/dist/esm/client/components/metadata/browser-resolved-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/metadata/browser-resolved-metadata.tsx"],"sourcesContent":["import { use } from 'react'\nimport type { StreamingMetadataResolvedState } from './types'\n\nexport function BrowserResolvedMetadata({\n  promise,\n}: {\n  promise: Promise<StreamingMetadataResolvedState>\n}) {\n  const { metadata, error } = use(promise)\n  // If there's metadata error on client, discard the browser metadata\n  // and let metadata outlet deal with the error. This will avoid the duplication metadata.\n  if (error) return null\n  return metadata\n}\n"],"names":["use","BrowserResolvedMetadata","promise","metadata","error"],"mappings":"AAAA,SAASA,GAAG,QAAQ,QAAO;AAG3B,OAAO,SAASC,wBAAwB,KAIvC;IAJuC,IAAA,EACtCC,OAAO,EAGR,GAJuC;IAKtC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGJ,IAAIE;IAChC,oEAAoE;IACpE,yFAAyF;IACzF,IAAIE,OAAO,OAAO;IAClB,OAAOD;AACT"}

node_modules/next/dist/esm/client/components/metadata/metadata-boundary.js

@@ -0,0 +1,29 @@
+'use client';
+import { METADATA_BOUNDARY_NAME, VIEWPORT_BOUNDARY_NAME, OUTLET_BOUNDARY_NAME } from '../../../lib/metadata/metadata-constants';
+// We use a namespace object to allow us to recover the name of the function
+// at runtime even when production bundling/minification is used.
+const NameSpace = {
+    [METADATA_BOUNDARY_NAME]: function(param) {
+        let { children } = param;
+        return children;
+    },
+    [VIEWPORT_BOUNDARY_NAME]: function(param) {
+        let { children } = param;
+        return children;
+    },
+    [OUTLET_BOUNDARY_NAME]: function(param) {
+        let { children } = param;
+        return children;
+    }
+};
+export const MetadataBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[METADATA_BOUNDARY_NAME.slice(0)];
+export const ViewportBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[VIEWPORT_BOUNDARY_NAME.slice(0)];
+export const OutletBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[OUTLET_BOUNDARY_NAME.slice(0)];
+
+//# sourceMappingURL=metadata-boundary.js.map

node_modules/next/dist/esm/client/components/metadata/metadata-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/metadata/metadata-boundary.tsx"],"sourcesContent":["'use client'\n\nimport {\n  METADATA_BOUNDARY_NAME,\n  VIEWPORT_BOUNDARY_NAME,\n  OUTLET_BOUNDARY_NAME,\n} from '../../../lib/metadata/metadata-constants'\n\n// We use a namespace object to allow us to recover the name of the function\n// at runtime even when production bundling/minification is used.\nconst NameSpace = {\n  [METADATA_BOUNDARY_NAME]: function ({\n    children,\n  }: {\n    children: React.ReactNode\n  }) {\n    return children\n  },\n  [VIEWPORT_BOUNDARY_NAME]: function ({\n    children,\n  }: {\n    children: React.ReactNode\n  }) {\n    return children\n  },\n  [OUTLET_BOUNDARY_NAME]: function ({\n    children,\n  }: {\n    children: React.ReactNode\n  }) {\n    return children\n  },\n}\n\nexport const MetadataBoundary =\n  // We use slice(0) to trick the bundler into not inlining/minifying the function\n  // so it retains the name inferred from the namespace object\n  NameSpace[METADATA_BOUNDARY_NAME.slice(0) as typeof METADATA_BOUNDARY_NAME]\n\nexport const ViewportBoundary =\n  // We use slice(0) to trick the bundler into not inlining/minifying the function\n  // so it retains the name inferred from the namespace object\n  NameSpace[VIEWPORT_BOUNDARY_NAME.slice(0) as typeof VIEWPORT_BOUNDARY_NAME]\n\nexport const OutletBoundary =\n  // We use slice(0) to trick the bundler into not inlining/minifying the function\n  // so it retains the name inferred from the namespace object\n  NameSpace[OUTLET_BOUNDARY_NAME.slice(0) as typeof OUTLET_BOUNDARY_NAME]\n"],"names":["METADATA_BOUNDARY_NAME","VIEWPORT_BOUNDARY_NAME","OUTLET_BOUNDARY_NAME","NameSpace","children","MetadataBoundary","slice","ViewportBoundary","OutletBoundary"],"mappings":"AAAA;AAEA,SACEA,sBAAsB,EACtBC,sBAAsB,EACtBC,oBAAoB,QACf,2CAA0C;AAEjD,4EAA4E;AAC5E,iEAAiE;AACjE,MAAMC,YAAY;IAChB,CAACH,uBAAuB,EAAE,SAAU,KAInC;QAJmC,IAAA,EAClCI,QAAQ,EAGT,GAJmC;QAKlC,OAAOA;IACT;IACA,CAACH,uBAAuB,EAAE,SAAU,KAInC;QAJmC,IAAA,EAClCG,QAAQ,EAGT,GAJmC;QAKlC,OAAOA;IACT;IACA,CAACF,qBAAqB,EAAE,SAAU,KAIjC;QAJiC,IAAA,EAChCE,QAAQ,EAGT,GAJiC;QAKhC,OAAOA;IACT;AACF;AAEA,OAAO,MAAMC,mBACX,gFAAgF;AAChF,4DAA4D;AAC5DF,SAAS,CAACH,uBAAuBM,KAAK,CAAC,GAAoC,CAAA;AAE7E,OAAO,MAAMC,mBACX,gFAAgF;AAChF,4DAA4D;AAC5DJ,SAAS,CAACF,uBAAuBK,KAAK,CAAC,GAAoC,CAAA;AAE7E,OAAO,MAAME,iBACX,gFAAgF;AAChF,4DAA4D;AAC5DL,SAAS,CAACD,qBAAqBI,KAAK,CAAC,GAAkC,CAAA"}