feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell

- Introduced blog routing using Next.js App Router
- Implemented dynamic [slug] pages for blog posts
- Added MDX-based content loading via lib/posts
- Integrated shared TopBar layout with navigation
- Established clear content, lib and component separation

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/add-locale.js

@@ -0,0 +1,9 @@
+import { normalizePathTrailingSlash } from './normalize-trailing-slash';
+export const addLocale = (path, ...args)=>{
+    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

apps/public-web/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      (\n        require('../shared/lib/router/utils/add-locale') as typeof import('../shared/lib/router/utils/add-locale')\n      ).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,CAACC,MAAM,GAAGC;IAC5C,IAAIC,QAAQC,GAAG,CAACC,mBAAmB,EAAE;QACnC,OAAON,2BACL,AACEO,QAAQ,yCACRN,SAAS,CAACC,SAASC;IAEzB;IACA,OAAOD;AACT,EAAC","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-bootstrap.js

@@ -0,0 +1,60 @@
+/**
+ * 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
+ */ import { getAssetPrefix } from './asset-prefix';
+import { setAttributesFromProps } from './set-attributes-from-props';
+const version = "16.1.4";
+window.next = {
+    version,
+    appDir: true
+};
+function loadScriptsInSequence(scripts, hydrate) {
+    if (!scripts || !scripts.length) {
+        return hydrate();
+    }
+    return scripts.reduce((promise, [src, props])=>{
+        return promise.then(()=>{
+            return new Promise((resolve, reject)=>{
+                const el = document.createElement('script');
+                if (props) {
+                    setAttributesFromProps(el, props);
+                }
+                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) {
+    const assetPrefix = getAssetPrefix();
+    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(assetPrefix);
+    });
+}
+
+//# sourceMappingURL=app-bootstrap.js.map

apps/public-web/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\nimport { getAssetPrefix } from './asset-prefix'\nimport { setAttributesFromProps } from './set-attributes-from-props'\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            setAttributesFromProps(el, props)\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: (assetPrefix: string) => void) {\n  const assetPrefix = getAssetPrefix()\n\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(assetPrefix)\n  })\n}\n"],"names":["getAssetPrefix","setAttributesFromProps","version","process","env","__NEXT_VERSION","window","next","appDir","loadScriptsInSequence","scripts","hydrate","length","reduce","promise","src","props","then","Promise","resolve","reject","el","document","createElement","onload","onerror","innerHTML","children","setTimeout","head","appendChild","catch","err","console","error","appBootstrap","assetPrefix","self","__next_s","__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING","search","URLSearchParams","location","get","warn"],"mappings":"AAAA;;;;;CAKC,GAED,SAASA,cAAc,QAAQ,iBAAgB;AAC/C,SAASC,sBAAsB,QAAQ,8BAA6B;AAEpE,MAAMC,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,SAAS,CAACC,KAAKC,MAAM;QAC5B,OAAOF,QAAQG,IAAI,CAAC;YAClB,OAAO,IAAIC,QAAc,CAACC,SAASC;gBACjC,MAAMC,KAAKC,SAASC,aAAa,CAAC;gBAElC,IAAIP,OAAO;oBACTf,uBAAuBoB,IAAIL;gBAC7B;gBAEA,IAAID,KAAK;oBACPM,GAAGN,GAAG,GAAGA;oBACTM,GAAGG,MAAM,GAAG,IAAML;oBAClBE,GAAGI,OAAO,GAAGL;gBACf,OAAO,IAAIJ,OAAO;oBAChBK,GAAGK,SAAS,GAAGV,MAAMW,QAAQ;oBAC7BC,WAAWT;gBACb;gBAEAG,SAASO,IAAI,CAACC,WAAW,CAACT;YAC5B;QACF;IACF,GAAGH,QAAQC,OAAO,IACjBY,KAAK,CAAC,CAACC;QACNC,QAAQC,KAAK,CAACF;IACd,iDAAiD;IACnD,GACCf,IAAI,CAAC;QACJN;IACF;AACJ;AAEA,OAAO,SAASwB,aAAaxB,OAAsC;IACjE,MAAMyB,cAAcpC;IAEpBS,sBAAsB,AAAC4B,KAAaC,QAAQ,EAAE;QAC5C,+DAA+D;QAC/D,kEAAkE;QAClE,uEAAuE;QACvE,wDAAwD;QACxD,IAAInC,QAAQC,GAAG,CAACmC,0CAA0C,KAAK,KAAK;YAClE,MAAMC,SAAS,IAAIC,gBAAgBnC,OAAOoC,QAAQ,CAACF,MAAM;YACzD,IACEA,OAAOG,GAAG,CAAC,qBAAqB,cAChCH,OAAOG,GAAG,CAAC,qBAAqB,KAChC;gBACAV,QAAQW,IAAI,CACV,CAAC,wCAAwC,EAAEJ,OAAOG,GAAG,CAAC,kBAAkB;gBAE1E;YACF;QACF;QAEAhC,QAAQyB;IACV;AACF","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

apps/public-web/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 { checkFormActionUrl, createFormSubmitDestinationUrl, DISALLOWED_FORM_PROPS, hasReactClientActionAttributes, hasUnsupportedSubmitterAttributes } from '../form-shared';
+import { mountFormInstance, unmountPrefetchableInstance } from '../components/links';
+import { FetchStrategy } from '../components/segment-cache/types';
+export default function Form({ replace, scroll, prefetch: prefetchProp, ref: externalRef, ...props }) {
+    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.');
+        }
+    }
+    // TODO(runtime-ppr): allow runtime prefetches in Form
+    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, // We default to PPR. We'll discover whether or not the route supports it with the initial prefetch.
+            FetchStrategy.PPR);
+        }
+        return ()=>{
+            unmountPrefetchableInstance(element);
+        };
+    }, [
+        isPrefetchEnabled,
+        actionProp,
+        router
+    ]);
+    const mergedRef = useMergedRef(observeFormVisibilityOnMount, 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, { actionHref, onSubmit, replace, scroll, router }) {
+    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

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

@@ -0,0 +1,377 @@
+'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 { 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 { FetchStrategy } from '../components/segment-cache/types';
+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) {
+    if (typeof window !== 'undefined') {
+        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();
+        if (onNavigate) {
+            let isDefaultPrevented = false;
+            onNavigate({
+                preventDefault: ()=>{
+                    isDefaultPrevented = true;
+                }
+            });
+            if (isDefaultPrevented) {
+                return;
+            }
+        }
+        const { dispatchNavigateAction } = require('../components/app-router-instance');
+        React.startTransition(()=>{
+            dispatchNavigateAction(as || href, replace ? 'replace' : 'push', scroll ?? true, linkInstanceRef.current);
+        });
+    }
+}
+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;
+    const fetchStrategy = prefetchProp !== false ? getFetchStrategyFromPrefetchProp(prefetchProp) : FetchStrategy.PPR;
+    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:
+                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 === 'legacyBehavior' || key === 'unstable_dynamicOnHover') {
+                if (props[key] != null && valType !== 'boolean') {
+                    throw createPropError({
+                        key,
+                        expected: '`boolean`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'prefetch') {
+                if (props[key] != null && valType !== 'boolean' && props[key] !== 'auto') {
+                    throw createPropError({
+                        key,
+                        expected: '`boolean | "auto"`',
+                        actual: valType
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                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 (children?.$$typeof === Symbol.for('react.lazy')) {
+            throw Object.defineProperty(new Error(`\`<Link legacyBehavior>\` received a direct child that is either a Server Component, or JSX that was loaded with React.lazy(). This is not supported. Either remove legacyBehavior, or make the direct child a Client Component that renders the Link's \`<a>\` tag.`), "__NEXT_ERROR_CODE", {
+                value: "E863",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        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?.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, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus);
+        }
+        return ()=>{
+            if (linkInstanceRef.current) {
+                unmountLinkForCurrentNavigation(linkInstanceRef.current);
+                linkInstanceRef.current = null;
+            }
+            unmountPrefetchableInstance(element);
+        };
+    }, [
+        prefetchEnabled,
+        href,
+        router,
+        fetchStrategy,
+        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 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);
+};
+function getFetchStrategyFromPrefetchProp(prefetchProp) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        if (prefetchProp === true) {
+            return FetchStrategy.Full;
+        }
+        // `null` or `"auto"`: this is the default "auto" mode, where we will prefetch partially if the link is in the viewport.
+        // This will also include invalid prop values that don't match the types specified here.
+        // (although those should've been filtered out by prop validation in dev)
+        prefetchProp;
+        return FetchStrategy.PPR;
+    } else {
+        return prefetchProp === null || prefetchProp === 'auto' ? FetchStrategy.PPR : // To preserve backwards-compatibility, anything other than `false`, `null`, or `"auto"` results in a full prefetch.
+        // (although invalid values should've been filtered out by prop validation in dev)
+        FetchStrategy.Full;
+    }
+}
+
+//# sourceMappingURL=link.js.map

apps/public-web/node_modules/next/dist/esm/client/app-dir/link.react-server.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import ClientLinkComponent, { useLinkStatus } from './link';
+export default function LinkComponent(props) {
+    const isLegacyBehavior = props.legacyBehavior;
+    const childIsHostComponent = typeof props.children === 'string' || typeof props.children === 'number' || typeof props.children?.type === 'string';
+    const childIsClientComponent = props.children?.type?.$$typeof === Symbol.for('react.client.reference');
+    if (isLegacyBehavior && !childIsHostComponent && !childIsClientComponent) {
+        if (props.children?.type?.$$typeof === Symbol.for('react.lazy')) {
+            console.error(`Using a Lazy Component as a direct child of \`<Link legacyBehavior>\` from a Server Component is not supported. If you need legacyBehavior, wrap your Lazy Component in a Client Component that renders the Link's \`<a>\` tag.`);
+        } else {
+            console.error(`Using a Server Component as a direct child of \`<Link legacyBehavior>\` is not supported. If you need legacyBehavior, wrap your Server Component in a Client Component that renders the Link's \`<a>\` tag.`);
+        }
+    }
+    return /*#__PURE__*/ _jsx(ClientLinkComponent, {
+        ...props
+    });
+}
+export { useLinkStatus };
+
+//# sourceMappingURL=link.react-server.js.map

apps/public-web/node_modules/next/dist/esm/client/app-dir/link.react-server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/app-dir/link.react-server.tsx"],"sourcesContent":["import type { ComponentProps } from 'react'\nimport ClientLinkComponent, { type LinkProps, useLinkStatus } from './link'\n\nexport default function LinkComponent(\n  props: ComponentProps<typeof ClientLinkComponent>\n) {\n  const isLegacyBehavior = props.legacyBehavior\n  const childIsHostComponent =\n    typeof props.children === 'string' ||\n    typeof props.children === 'number' ||\n    typeof (props.children as any)?.type === 'string'\n  const childIsClientComponent =\n    (props.children as any)?.type?.$$typeof ===\n    Symbol.for('react.client.reference')\n\n  if (isLegacyBehavior && !childIsHostComponent && !childIsClientComponent) {\n    if ((props.children as any)?.type?.$$typeof === Symbol.for('react.lazy')) {\n      console.error(\n        `Using a Lazy Component as a direct child of \\`<Link legacyBehavior>\\` from a Server Component is not supported. If you need legacyBehavior, wrap your Lazy Component in a Client Component that renders the Link's \\`<a>\\` tag.`\n      )\n    } else {\n      console.error(\n        `Using a Server Component as a direct child of \\`<Link legacyBehavior>\\` is not supported. If you need legacyBehavior, wrap your Server Component in a Client Component that renders the Link's \\`<a>\\` tag.`\n      )\n    }\n  }\n\n  return <ClientLinkComponent {...props} />\n}\n\nexport { type LinkProps, useLinkStatus }\n"],"names":["ClientLinkComponent","useLinkStatus","LinkComponent","props","isLegacyBehavior","legacyBehavior","childIsHostComponent","children","type","childIsClientComponent","$$typeof","Symbol","for","console","error"],"mappings":";AACA,OAAOA,uBAAuCC,aAAa,QAAQ,SAAQ;AAE3E,eAAe,SAASC,cACtBC,KAAiD;IAEjD,MAAMC,mBAAmBD,MAAME,cAAc;IAC7C,MAAMC,uBACJ,OAAOH,MAAMI,QAAQ,KAAK,YAC1B,OAAOJ,MAAMI,QAAQ,KAAK,YAC1B,OAAQJ,MAAMI,QAAQ,EAAUC,SAAS;IAC3C,MAAMC,yBACJ,AAACN,MAAMI,QAAQ,EAAUC,MAAME,aAC/BC,OAAOC,GAAG,CAAC;IAEb,IAAIR,oBAAoB,CAACE,wBAAwB,CAACG,wBAAwB;QACxE,IAAI,AAACN,MAAMI,QAAQ,EAAUC,MAAME,aAAaC,OAAOC,GAAG,CAAC,eAAe;YACxEC,QAAQC,KAAK,CACX,CAAC,+NAA+N,CAAC;QAErO,OAAO;YACLD,QAAQC,KAAK,CACX,CAAC,2MAA2M,CAAC;QAEjN;IACF;IAEA,qBAAO,KAACd;QAAqB,GAAGG,KAAK;;AACvC;AAEA,SAAyBF,aAAa,GAAE","ignoreList":[0]}

apps/public-web/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

apps/public-web/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,GAAGJ,SAAS,oBAAoB,CAAC;AAElD,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,GAAGL,SAAS,IAAI,CAAC;IAC1B;IAEA,MAAMM,MAAM,IAAIC,IAAIV,UAAUK,SAASC,QAAQ,CAACC,MAAM;IACtDE,IAAIE,YAAY,CAACC,GAAG,CAAC,YAAYT;IAEjC,OAAOM,IAAII,IAAI;AACjB,IACAC,UAAS","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-globals.js

@@ -0,0 +1,8 @@
+// imports polyfill from `@next/polyfill-module` after build.
+import '../build/polyfills/polyfill-module';
+// Only setup devtools in development
+if (process.env.NODE_ENV !== 'production') {
+    require('../next-devtools/userspace/app/app-dev-overlay-setup');
+}
+
+//# sourceMappingURL=app-globals.js.map

apps/public-web/node_modules/next/dist/esm/client/app-globals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/app-globals.ts"],"sourcesContent":["// imports polyfill from `@next/polyfill-module` after build.\nimport '../build/polyfills/polyfill-module'\n\n// Only setup devtools in development\nif (process.env.NODE_ENV !== 'production') {\n  require('../next-devtools/userspace/app/app-dev-overlay-setup') as typeof import('../next-devtools/userspace/app/app-dev-overlay-setup')\n}\n"],"names":["process","env","NODE_ENV","require"],"mappings":"AAAA,6DAA6D;AAC7D,OAAO,qCAAoC;AAE3C,qCAAqC;AACrC,IAAIA,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCC,QAAQ;AACV","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-index.js

@@ -0,0 +1,254 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './app-globals';
+import ReactDOMClient from 'react-dom/client';
+import React from 'react';
+// TODO: Explicitly import from client.browser
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { createFromReadableStream as createFromReadableStreamBrowser, createFromFetch as createFromFetchBrowser } 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';
+import { createInitialRSCPayloadFromFallbackPrerender } from './flight-data-helpers';
+/// <reference types="react-dom/experimental" />
+const createFromReadableStream = createFromReadableStreamBrowser;
+const createFromFetch = createFromFetchBrowser;
+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 || [];
+// Consume all buffered chunks and clear the global data array right after to release memory.
+// Otherwise it will be retained indefinitely.
+nextServerDataLoadingGlobal.forEach(nextServerDataCallback);
+nextServerDataLoadingGlobal.length = 0;
+// Patch its push method so subsequent chunks are handled (but not actually pushed to the array).
+nextServerDataLoadingGlobal.push = nextServerDataCallback;
+const readable = new ReadableStream({
+    start (controller) {
+        nextServerDataRegisterWriter(controller);
+    }
+});
+if (process.env.NODE_ENV !== 'production') {
+    // @ts-expect-error
+    readable.name = 'hydration';
+}
+let debugChannel;
+if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL && typeof window !== 'undefined') {
+    const { createDebugChannel } = require('./dev/debug-channel');
+    debugChannel = createDebugChannel(undefined);
+}
+const clientResumeFetch = // @ts-expect-error
+window.__NEXT_CLIENT_RESUME;
+let initialServerResponse;
+if (clientResumeFetch) {
+    initialServerResponse = Promise.resolve(createFromFetch(clientResumeFetch, {
+        callServer,
+        findSourceMapURL,
+        debugChannel
+    })).then(async (fallbackInitialRSCPayload)=>createInitialRSCPayloadFromFallbackPrerender(await clientResumeFetch, fallbackInitialRSCPayload));
+} else {
+    initialServerResponse = createFromReadableStream(readable, {
+        callServer,
+        findSourceMapURL,
+        debugChannel,
+        startTime: 0
+    });
+}
+function ServerRoot({ initialRSCPayload, actionQueue, webSocket, staticIndicatorState }) {
+    const router = /*#__PURE__*/ _jsx(AppRouter, {
+        actionQueue: actionQueue,
+        globalErrorState: initialRSCPayload.G,
+        webSocket: webSocket,
+        staticIndicatorState: staticIndicatorState
+    });
+    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({ children }) {
+    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?.();
+        }, []);
+    }
+    return children;
+}
+const enableTransitionIndicator = process.env.__NEXT_TRANSITION_INDICATOR;
+function noDefaultTransitionIndicator() {
+    return ()=>{};
+}
+const reactRootOptions = {
+    onDefaultTransitionIndicator: enableTransitionIndicator ? undefined : noDefaultTransitionIndicator,
+    onRecoverableError,
+    onCaughtError,
+    onUncaughtError
+};
+export async function hydrate(instrumentationHooks, assetPrefix) {
+    let staticIndicatorState;
+    let webSocket;
+    if (process.env.NODE_ENV !== 'production') {
+        const { createWebSocket } = require('./dev/hot-reloader/app/web-socket');
+        staticIndicatorState = {
+            pathname: null,
+            appIsrManifest: null
+        };
+        webSocket = createWebSocket(assetPrefix, staticIndicatorState);
+    }
+    const initialRSCPayload = await initialServerResponse;
+    // setAppBuildId should be called only once, during JS initialization
+    // and before any components have hydrated.
+    setAppBuildId(initialRSCPayload.b);
+    const initialTimestamp = Date.now();
+    const actionQueue = createMutableActionQueue(createInitialRouterState({
+        navigatedAt: initialTimestamp,
+        initialFlightData: initialRSCPayload.f,
+        initialCanonicalUrlParts: initialRSCPayload.c,
+        initialRenderedSearch: initialRSCPayload.q,
+        location: window.location
+    }), instrumentationHooks);
+    const reactEl = /*#__PURE__*/ _jsx(StrictModeIfEnabled, {
+        children: /*#__PURE__*/ _jsx(HeadManagerContext.Provider, {
+            value: {
+                appDir: true
+            },
+            children: /*#__PURE__*/ _jsx(Root, {
+                children: /*#__PURE__*/ _jsx(ServerRoot, {
+                    initialRSCPayload: initialRSCPayload,
+                    actionQueue: actionQueue,
+                    webSocket: webSocket,
+                    staticIndicatorState: staticIndicatorState
+                })
+            })
+        })
+    });
+    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 { RootLevelDevOverlayElement } = require('../next-devtools/userspace/app/client-entry');
+            // Note this won't cause hydration mismatch because we are doing CSR w/o hydration
+            element = /*#__PURE__*/ _jsx(RootLevelDevOverlayElement, {
+                children: 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

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

@@ -0,0 +1,59 @@
+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') {
+                            const link = node;
+                            if (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){
+                                            if (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

apps/public-web/node_modules/next/dist/esm/client/app-next-dev.js

@@ -0,0 +1,19 @@
+// TODO-APP: hydration warning
+import './app-webpack';
+import { renderAppDevOverlay } from 'next/dist/compiled/next-devtools';
+import { appBootstrap } from './app-bootstrap';
+import { getOwnerStack } from '../next-devtools/userspace/app/errors/stitched-error';
+import { isRecoverableError } from './react-client-callbacks/on-recoverable-error';
+// eslint-disable-next-line @next/internal/typechecked-require
+const instrumentationHooks = require('../lib/require-instrumentation-client');
+appBootstrap((assetPrefix)=>{
+    const { hydrate } = require('./app-index');
+    try {
+        hydrate(instrumentationHooks, assetPrefix);
+    } finally{
+        const enableCacheIndicator = process.env.__NEXT_CACHE_COMPONENTS;
+        renderAppDevOverlay(getOwnerStack, isRecoverableError, enableCacheIndicator);
+    }
+});
+
+//# sourceMappingURL=app-next-dev.js.map

apps/public-web/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 { renderAppDevOverlay } from 'next/dist/compiled/next-devtools'\nimport { appBootstrap } from './app-bootstrap'\nimport { getOwnerStack } from '../next-devtools/userspace/app/errors/stitched-error'\nimport { isRecoverableError } from './react-client-callbacks/on-recoverable-error'\n\n// eslint-disable-next-line @next/internal/typechecked-require\nconst instrumentationHooks = require('../lib/require-instrumentation-client')\n\nappBootstrap((assetPrefix) => {\n  const { hydrate } = require('./app-index') as typeof import('./app-index')\n  try {\n    hydrate(instrumentationHooks, assetPrefix)\n  } finally {\n    const enableCacheIndicator = process.env.__NEXT_CACHE_COMPONENTS\n    renderAppDevOverlay(getOwnerStack, isRecoverableError, enableCacheIndicator)\n  }\n})\n"],"names":["renderAppDevOverlay","appBootstrap","getOwnerStack","isRecoverableError","instrumentationHooks","require","assetPrefix","hydrate","enableCacheIndicator","process","env","__NEXT_CACHE_COMPONENTS"],"mappings":"AAAA,8BAA8B;AAE9B,OAAO,gBAAe;AAEtB,SAASA,mBAAmB,QAAQ,mCAAkC;AACtE,SAASC,YAAY,QAAQ,kBAAiB;AAC9C,SAASC,aAAa,QAAQ,uDAAsD;AACpF,SAASC,kBAAkB,QAAQ,gDAA+C;AAElF,8DAA8D;AAC9D,MAAMC,uBAAuBC,QAAQ;AAErCJ,aAAa,CAACK;IACZ,MAAM,EAAEC,OAAO,EAAE,GAAGF,QAAQ;IAC5B,IAAI;QACFE,QAAQH,sBAAsBE;IAChC,SAAU;QACR,MAAME,uBAAuBC,QAAQC,GAAG,CAACC,uBAAuB;QAChEX,oBAAoBE,eAAeC,oBAAoBK;IACzD;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-next-turbopack.js

@@ -0,0 +1,21 @@
+import { appBootstrap } from './app-bootstrap';
+import { isRecoverableError } from './react-client-callbacks/on-recoverable-error';
+window.next.turbopack = true;
+self.__webpack_hash__ = '';
+// eslint-disable-next-line @next/internal/typechecked-require
+const instrumentationHooks = require('../lib/require-instrumentation-client');
+appBootstrap((assetPrefix)=>{
+    const { hydrate } = require('./app-index');
+    try {
+        hydrate(instrumentationHooks, assetPrefix);
+    } finally{
+        if (process.env.NODE_ENV !== 'production') {
+            const enableCacheIndicator = process.env.__NEXT_CACHE_COMPONENTS;
+            const { getOwnerStack } = require('../next-devtools/userspace/app/errors/stitched-error');
+            const { renderAppDevOverlay } = require('next/dist/compiled/next-devtools');
+            renderAppDevOverlay(getOwnerStack, isRecoverableError, enableCacheIndicator);
+        }
+    }
+});
+
+//# sourceMappingURL=app-next-turbopack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/app-next-turbopack.ts"],"sourcesContent":["import { appBootstrap } from './app-bootstrap'\nimport { isRecoverableError } from './react-client-callbacks/on-recoverable-error'\n\nwindow.next.turbopack = true\n;(self as any).__webpack_hash__ = ''\n\n// eslint-disable-next-line @next/internal/typechecked-require\nconst instrumentationHooks = require('../lib/require-instrumentation-client')\n\nappBootstrap((assetPrefix) => {\n  const { hydrate } = require('./app-index') as typeof import('./app-index')\n  try {\n    hydrate(instrumentationHooks, assetPrefix)\n  } finally {\n    if (process.env.NODE_ENV !== 'production') {\n      const enableCacheIndicator = process.env.__NEXT_CACHE_COMPONENTS\n      const { getOwnerStack } =\n        require('../next-devtools/userspace/app/errors/stitched-error') as typeof import('../next-devtools/userspace/app/errors/stitched-error')\n      const { renderAppDevOverlay } =\n        require('next/dist/compiled/next-devtools') as typeof import('next/dist/compiled/next-devtools')\n      renderAppDevOverlay(\n        getOwnerStack,\n        isRecoverableError,\n        enableCacheIndicator\n      )\n    }\n  }\n})\n"],"names":["appBootstrap","isRecoverableError","window","next","turbopack","self","__webpack_hash__","instrumentationHooks","require","assetPrefix","hydrate","process","env","NODE_ENV","enableCacheIndicator","__NEXT_CACHE_COMPONENTS","getOwnerStack","renderAppDevOverlay"],"mappings":"AAAA,SAASA,YAAY,QAAQ,kBAAiB;AAC9C,SAASC,kBAAkB,QAAQ,gDAA+C;AAElFC,OAAOC,IAAI,CAACC,SAAS,GAAG;AACtBC,KAAaC,gBAAgB,GAAG;AAElC,8DAA8D;AAC9D,MAAMC,uBAAuBC,QAAQ;AAErCR,aAAa,CAACS;IACZ,MAAM,EAAEC,OAAO,EAAE,GAAGF,QAAQ;IAC5B,IAAI;QACFE,QAAQH,sBAAsBE;IAChC,SAAU;QACR,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,MAAMC,uBAAuBH,QAAQC,GAAG,CAACG,uBAAuB;YAChE,MAAM,EAAEC,aAAa,EAAE,GACrBR,QAAQ;YACV,MAAM,EAAES,mBAAmB,EAAE,GAC3BT,QAAQ;YACVS,oBACED,eACAf,oBACAa;QAEJ;IACF;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-next.js

@@ -0,0 +1,17 @@
+// 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 = // eslint-disable-next-line @next/internal/typechecked-require -- not a module
+require('../lib/require-instrumentation-client');
+appBootstrap((assetPrefix)=>{
+    const { hydrate } = require('./app-index');
+    // Include app-router and layout-router in the main chunk
+    // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?
+    require('next/dist/client/components/app-router');
+    // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?
+    require('next/dist/client/components/layout-router');
+    hydrate(instrumentationHooks, assetPrefix);
+});
+
+//# sourceMappingURL=app-next.js.map

apps/public-web/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 =\n  // eslint-disable-next-line @next/internal/typechecked-require -- not a module\n  require('../lib/require-instrumentation-client')\n\nappBootstrap((assetPrefix) => {\n  const { hydrate } = require('./app-index') as typeof import('./app-index')\n  // Include app-router and layout-router in the main chunk\n  // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?\n  require('next/dist/client/components/app-router')\n  // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?\n  require('next/dist/client/components/layout-router')\n  hydrate(instrumentationHooks, assetPrefix)\n})\n"],"names":["appBootstrap","instrumentationHooks","require","assetPrefix","hydrate"],"mappings":"AAAA,4EAA4E;AAC5E,sCAAsC;AACtC,OAAO,gBAAe;AACtB,SAASA,YAAY,QAAQ,kBAAiB;AAE9C,MAAMC,uBACJ,8EAA8E;AAC9EC,QAAQ;AAEVF,aAAa,CAACG;IACZ,MAAM,EAAEC,OAAO,EAAE,GAAGF,QAAQ;IAC5B,yDAAyD;IACzD,2FAA2F;IAC3FA,QAAQ;IACR,2FAA2F;IAC3FA,QAAQ;IACRE,QAAQH,sBAAsBE;AAChC","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/app-webpack.js

@@ -0,0 +1,28 @@
+// Override chunk URL mapping in the webpack runtime
+// https://github.com/webpack/webpack/blob/2738eebc7880835d88c727d364ad37f3ec557593/lib/RuntimeGlobals.js#L204
+import { getDeploymentIdQueryOrEmptyString } from '../shared/lib/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();
+    const getChunkScriptFilename = __webpack_require__.u;
+    __webpack_require__.u = (...args)=>// We encode the chunk filename because our static server matches against and encoded
+        // filename path.
+        encodeURIPath(getChunkScriptFilename(...args)) + suffix;
+    const getChunkCssFilename = __webpack_require__.k;
+    __webpack_require__.k = (...args)=>getChunkCssFilename(...args) + suffix;
+    const getMiniCssFilename = __webpack_require__.miniCssF;
+    __webpack_require__.miniCssF = (...args)=>getMiniCssFilename(...args) + suffix;
+} else {
+    const getChunkScriptFilename = __webpack_require__.u;
+    __webpack_require__.u = (...args)=>// 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

apps/public-web/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 '../shared/lib/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  const getChunkScriptFilename = __webpack_require__.u\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  const getChunkCssFilename = __webpack_require__.k\n  __webpack_require__.k = (...args: any[]) =>\n    getChunkCssFilename(...args) + suffix\n\n  const getMiniCssFilename = __webpack_require__.miniCssF\n  __webpack_require__.miniCssF = (...args: any[]) =>\n    getMiniCssFilename(...args) + suffix\n} else {\n  const getChunkScriptFilename = __webpack_require__.u\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,8BAA6B;AAC/E,SAASC,aAAa,QAAQ,gCAA+B;AAI7D,8EAA8E;AAC9E,8EAA8E;AAC9E,IAAIC,QAAQC,GAAG,CAACC,kBAAkB,EAAE;IAClC,MAAMC,SAASL;IACf,MAAMM,yBAAyBC,oBAAoBC,CAAC;IACpDD,oBAAoBC,CAAC,GAAG,CAAC,GAAGC,OAC1B,qFAAqF;QACrF,iBAAiB;QACjBR,cAAcK,0BAA0BG,SAASJ;IAEnD,MAAMK,sBAAsBH,oBAAoBI,CAAC;IACjDJ,oBAAoBI,CAAC,GAAG,CAAC,GAAGF,OAC1BC,uBAAuBD,QAAQJ;IAEjC,MAAMO,qBAAqBL,oBAAoBM,QAAQ;IACvDN,oBAAoBM,QAAQ,GAAG,CAAC,GAAGJ,OACjCG,sBAAsBH,QAAQJ;AAClC,OAAO;IACL,MAAMC,yBAAyBC,oBAAoBC,CAAC;IACpDD,oBAAoBC,CAAC,GAAG,CAAC,GAAGC,OAC1B,qFAAqF;QACrF,iBAAiB;QACjBR,cAAcK,0BAA0BG;AAE1C,0EAA0E;AAC1E,2DAA2D;AAE3D,iFAAiF;AACjF,gEAAgE;AAClE","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/asset-prefix.js

@@ -0,0 +1,23 @@
+import { InvariantError } from '../shared/lib/invariant-error';
+export function getAssetPrefix() {
+    const currentScript = document.currentScript;
+    if (!(currentScript instanceof HTMLScriptElement)) {
+        throw Object.defineProperty(new InvariantError(`Expected document.currentScript to be a <script> element. Received ${currentScript} instead.`), "__NEXT_ERROR_CODE", {
+            value: "E783",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { pathname } = new URL(currentScript.src);
+    const nextIndex = pathname.indexOf('/_next/');
+    if (nextIndex === -1) {
+        throw Object.defineProperty(new InvariantError(`Expected document.currentScript src to contain '/_next/'. Received ${currentScript.src} instead.`), "__NEXT_ERROR_CODE", {
+            value: "E784",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return pathname.slice(0, nextIndex);
+}
+
+//# sourceMappingURL=asset-prefix.js.map

apps/public-web/node_modules/next/dist/esm/client/asset-prefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/asset-prefix.ts"],"sourcesContent":["import { InvariantError } from '../shared/lib/invariant-error'\n\nexport function getAssetPrefix() {\n  const currentScript = document.currentScript\n\n  if (!(currentScript instanceof HTMLScriptElement)) {\n    throw new InvariantError(\n      `Expected document.currentScript to be a <script> element. Received ${currentScript} instead.`\n    )\n  }\n\n  const { pathname } = new URL(currentScript.src)\n  const nextIndex = pathname.indexOf('/_next/')\n\n  if (nextIndex === -1) {\n    throw new InvariantError(\n      `Expected document.currentScript src to contain '/_next/'. Received ${currentScript.src} instead.`\n    )\n  }\n\n  return pathname.slice(0, nextIndex)\n}\n"],"names":["InvariantError","getAssetPrefix","currentScript","document","HTMLScriptElement","pathname","URL","src","nextIndex","indexOf","slice"],"mappings":"AAAA,SAASA,cAAc,QAAQ,gCAA+B;AAE9D,OAAO,SAASC;IACd,MAAMC,gBAAgBC,SAASD,aAAa;IAE5C,IAAI,CAAEA,CAAAA,yBAAyBE,iBAAgB,GAAI;QACjD,MAAM,qBAEL,CAFK,IAAIJ,eACR,CAAC,mEAAmE,EAAEE,cAAc,SAAS,CAAC,GAD1F,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,MAAM,EAAEG,QAAQ,EAAE,GAAG,IAAIC,IAAIJ,cAAcK,GAAG;IAC9C,MAAMC,YAAYH,SAASI,OAAO,CAAC;IAEnC,IAAID,cAAc,CAAC,GAAG;QACpB,MAAM,qBAEL,CAFK,IAAIR,eACR,CAAC,mEAAmE,EAAEE,cAAcK,GAAG,CAAC,SAAS,CAAC,GAD9F,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,OAAOF,SAASK,KAAK,CAAC,GAAGF;AAC3B","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

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

@@ -0,0 +1,62 @@
+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() {
+    const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0];
+    if (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({ tree }) {
+    const [portalNode, setPortalNode] = useState(null);
+    useEffect(()=>{
+        const announcer = getAnnouncerNode();
+        setPortalNode(announcer);
+        return ()=>{
+            const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0];
+            if (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

apps/public-web/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 '../../shared/lib/app-router-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;IACP,MAAMC,oBAAoBC,SAASC,iBAAiB,CAACL,eAAe,CAAC,EAAE;IACvE,IAAIG,mBAAmBG,YAAYC,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,EAAEC,IAAI,EAA+B;IACtE,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,WAAWkB,aAAa;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","ignoreList":[0]}

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

@@ -0,0 +1,36 @@
+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';
+export const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found';
+export const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id';
+export const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id';
+// TODO: Should this include nextjs in the name, like the others?
+export const NEXT_ACTION_REVALIDATED_HEADER = 'x-action-revalidated';
+
+//# sourceMappingURL=app-router-headers.js.map

apps/public-web/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\nexport const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found' as const\nexport const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id' as const\nexport const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id' as const\n\n// TODO: Should this include nextjs in the name, like the others?\nexport const NEXT_ACTION_REVALIDATED_HEADER = 'x-action-revalidated' 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","NEXT_ACTION_NOT_FOUND_HEADER","NEXT_REQUEST_ID_HEADER","NEXT_HTML_REQUEST_ID_HEADER","NEXT_ACTION_REVALIDATED_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;AACrE,OAAO,MAAMC,+BAA+B,4BAAoC;AAChF,OAAO,MAAMC,yBAAyB,sBAA8B;AACpE,OAAO,MAAMC,8BAA8B,2BAAmC;AAE9E,iEAAiE;AACjE,OAAO,MAAMC,iCAAiC,uBAA+B","ignoreList":[0]}

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

@@ -0,0 +1,283 @@
+import { ACTION_REFRESH, ACTION_SERVER_ACTION, ACTION_NAVIGATE, ACTION_RESTORE, ACTION_HMR_REFRESH, PrefetchKind } 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 { FetchStrategy } from './segment-cache/types';
+import { prefetch as prefetchWithSegmentCache } from './segment-cache/prefetch';
+import { dispatchAppRouterAction } from './use-action-queue';
+import { addBasePath } from '../add-base-path';
+import { isExternalURL } from './app-router-utils';
+import { setLinkForCurrentNavigation } from './links';
+function runRemainingActions(actionQueue, setState) {
+    if (actionQueue.pending !== null) {
+        actionQueue.pending = actionQueue.pending.next;
+        if (actionQueue.pending !== null) {
+            runAction({
+                actionQueue,
+                action: actionQueue.pending,
+                setState
+            });
+        }
+    } else {
+        // Check for refresh when pending is already null
+        // This handles the case where a discarded server action completes
+        // after the navigation has already finished and the queue is empty
+        if (actionQueue.needsRefresh) {
+            actionQueue.needsRefresh = false;
+            actionQueue.dispatch({
+                type: ACTION_REFRESH
+            }, setState);
+        }
+    }
+}
+async function runAction({ actionQueue, action, setState }) {
+    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) {
+            // Check if the discarded server action revalidated data
+            if (action.payload.type === ACTION_SERVER_ACTION && action.payload.didRevalidate) {
+                // The server action was discarded but it revalidated data,
+                // mark that we need to refresh after all actions complete
+                actionQueue.needsRefresh = true;
+            }
+            // Still need to run remaining actions even for discarded actions
+            // to potentially trigger the refresh
+            runRemainingActions(actionQueue, setState);
+            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;
+        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
+    });
+}
+export function dispatchTraverseAction(href, historyState) {
+    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
+    if (onRouterTransitionStart !== null) {
+        onRouterTransitionStart(href, 'traverse');
+    }
+    dispatchAppRouterAction({
+        type: ACTION_RESTORE,
+        url: new URL(href),
+        historyState
+    });
+}
+/**
+ * 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: // Unlike the old implementation, the Segment Cache doesn't store its
+    // 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();
+        const prefetchKind = options?.kind ?? PrefetchKind.AUTO;
+        // We don't currently offer a way to issue a runtime prefetch via `router.prefetch()`.
+        // This will be possible when we update its API to not take a PrefetchKind.
+        let fetchStrategy;
+        switch(prefetchKind){
+            case PrefetchKind.AUTO:
+                {
+                    // We default to PPR. We'll discover whether or not the route supports it with the initial prefetch.
+                    fetchStrategy = FetchStrategy.PPR;
+                    break;
+                }
+            case PrefetchKind.FULL:
+                {
+                    fetchStrategy = FetchStrategy.Full;
+                    break;
+                }
+            default:
+                {
+                    prefetchKind;
+                    // Despite typescript thinking that this can't happen,
+                    // we might get an unexpected value from user code.
+                    // We don't know what they want, but we know they want a prefetch,
+                    // so use the default.
+                    fetchStrategy = FetchStrategy.PPR;
+                }
+        }
+        prefetchWithSegmentCache(href, actionQueue.state.nextUrl, actionQueue.state.tree, fetchStrategy, options?.onInvalidate ?? null);
+    },
+    replace: (href, options)=>{
+        startTransition(()=>{
+            dispatchNavigateAction(href, 'replace', options?.scroll ?? true, null);
+        });
+    },
+    push: (href, options)=>{
+        startTransition(()=>{
+            dispatchNavigateAction(href, 'push', options?.scroll ?? true, null);
+        });
+    },
+    refresh: ()=>{
+        startTransition(()=>{
+            dispatchAppRouterAction({
+                type: ACTION_REFRESH
+            });
+        });
+    },
+    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
+                });
+            });
+        }
+    }
+};
+// 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

apps/public-web/node_modules/next/dist/esm/client/components/app-router-utils.js

@@ -0,0 +1,40 @@
+import { isBot } from '../../shared/lib/router/utils/is-bot';
+import { addBasePath } from '../add-base-path';
+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;
+}
+
+//# sourceMappingURL=app-router-utils.js.map

apps/public-web/node_modules/next/dist/esm/client/components/app-router-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/app-router-utils.ts"],"sourcesContent":["import { isBot } from '../../shared/lib/router/utils/is-bot'\nimport { addBasePath } from '../add-base-path'\n\nexport function isExternalURL(url: URL) {\n  return url.origin !== window.location.origin\n}\n\n/**\n * Given a link href, constructs the URL that should be prefetched. Returns null\n * in cases where prefetching should be disabled, like external URLs, or\n * during development.\n * @param href The href passed to <Link>, router.prefetch(), or similar\n * @returns A URL object to prefetch, or null if prefetching should be disabled\n */\nexport function createPrefetchURL(href: string): URL | null {\n  // Don't prefetch for bots as they don't navigate.\n  if (isBot(window.navigator.userAgent)) {\n    return null\n  }\n\n  let url: URL\n  try {\n    url = new URL(addBasePath(href), window.location.href)\n  } catch (_) {\n    // TODO: Does this need to throw or can we just console.error instead? Does\n    // anyone rely on this throwing? (Seems unlikely.)\n    throw new Error(\n      `Cannot prefetch '${href}' because it cannot be converted to a URL.`\n    )\n  }\n\n  // Don't prefetch during development (improves compilation performance)\n  if (process.env.NODE_ENV === 'development') {\n    return null\n  }\n\n  // External urls can't be prefetched in the same way.\n  if (isExternalURL(url)) {\n    return null\n  }\n\n  return url\n}\n"],"names":["isBot","addBasePath","isExternalURL","url","origin","window","location","createPrefetchURL","href","navigator","userAgent","URL","_","Error","process","env","NODE_ENV"],"mappings":"AAAA,SAASA,KAAK,QAAQ,uCAAsC;AAC5D,SAASC,WAAW,QAAQ,mBAAkB;AAE9C,OAAO,SAASC,cAAcC,GAAQ;IACpC,OAAOA,IAAIC,MAAM,KAAKC,OAAOC,QAAQ,CAACF,MAAM;AAC9C;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,kBAAkBC,IAAY;IAC5C,kDAAkD;IAClD,IAAIR,MAAMK,OAAOI,SAAS,CAACC,SAAS,GAAG;QACrC,OAAO;IACT;IAEA,IAAIP;IACJ,IAAI;QACFA,MAAM,IAAIQ,IAAIV,YAAYO,OAAOH,OAAOC,QAAQ,CAACE,IAAI;IACvD,EAAE,OAAOI,GAAG;QACV,2EAA2E;QAC3E,kDAAkD;QAClD,MAAM,qBAEL,CAFK,IAAIC,MACR,CAAC,iBAAiB,EAAEL,KAAK,0CAA0C,CAAC,GADhE,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,uEAAuE;IACvE,IAAIM,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,OAAO;IACT;IAEA,qDAAqD;IACrD,IAAId,cAAcC,MAAM;QACtB,OAAO;IACT;IAEA,OAAOA;AACT","ignoreList":[0]}

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

@@ -0,0 +1,477 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { 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, NavigationPromisesContext } from '../../shared/lib/hooks-client-context.shared-runtime';
+import { dispatchAppRouterAction, useActionQueue } from './use-action-queue';
+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';
+import RootErrorBoundary from './errors/root-error-boundary';
+import DefaultGlobalError from './builtin/global-error';
+import { RootLayoutBoundary } from '../../lib/framework/boundary-components';
+import { getDeploymentIdQueryOrEmptyString } from '../../shared/lib/deployment-id';
+const globalMutable = {};
+function HistoryUpdater({ appRouterState }) {
+    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, renderedSearch } = appRouterState;
+        const appHistoryState = {
+            tree,
+            renderedSearch
+        };
+        // TODO: Use Navigation API if available
+        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: appHistoryState
+        };
+        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.
+        pingVisibleLinks(appRouterState.nextUrl, appRouterState.tree);
+    }, [
+        appRouterState.nextUrl,
+        appRouterState.tree
+    ]);
+    return null;
+}
+function copyNextJsInternalHistoryState(data) {
+    if (data == null) data = {};
+    const currentState = window.history.state;
+    const __NA = currentState?.__NA;
+    if (__NA) {
+        data.__NA = __NA;
+    }
+    const __PRIVATE_NEXTJS_INTERNALS_TREE = currentState?.__PRIVATE_NEXTJS_INTERNALS_TREE;
+    if (__PRIVATE_NEXTJS_INTERNALS_TREE) {
+        data.__PRIVATE_NEXTJS_INTERNALS_TREE = __PRIVATE_NEXTJS_INTERNALS_TREE;
+    }
+    return data;
+}
+function Head({ headCacheNode }) {
+    // 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({ actionQueue, globalError, webSocket, staticIndicatorState }) {
+    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') {
+        const { cache, 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,
+                tree
+            };
+        }, [
+            cache,
+            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) {
+            if (!event.persisted || !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),
+                historyState: 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?
+        // NOTE: This is intentionally using `throw` instead of `use` because we're
+        // inside an externally mutable condition (pushRef.mpaNavigation), which
+        // violates the rules of hooks.
+        throw 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)=>{
+            const href = window.location.href;
+            const appHistoryState = window.history.state?.__PRIVATE_NEXTJS_INTERNALS_TREE;
+            startTransition(()=>{
+                dispatchAppRouterAction({
+                    type: ACTION_RESTORE,
+                    url: new URL(url ?? href, href),
+                    historyState: appHistoryState
+                });
+            });
+        };
+        /**
+     * 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) {
+            // TODO: Warn when Navigation API is available (navigation.navigate() should be used)
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if (data?.__NA || 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) {
+            // TODO: Warn when Navigation API is available (navigation.navigate() should be used)
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if (data?.__NA || 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, previousNextUrl } = state;
+    const matchingHead = useMemo(()=>{
+        return findHeadInCache(cache, tree[1]);
+    }, [
+        cache,
+        tree
+    ]);
+    // Add memoized pathParams for useParams.
+    const pathParams = useMemo(()=>{
+        return getSelectedParams(tree);
+    }, [
+        tree
+    ]);
+    // Create instrumented promises for navigation hooks (dev-only)
+    // These are specially instrumented promises to show in the Suspense DevTools
+    // Promises are cached outside of render to survive suspense retries.
+    let instrumentedNavigationPromises = null;
+    if (process.env.NODE_ENV !== 'production') {
+        const { createRootNavigationPromises } = require('./navigation-devtools');
+        instrumentedNavigationPromises = createRootNavigationPromises(tree, pathname, searchParams, pathParams);
+    }
+    const layoutRouterContext = useMemo(()=>{
+        return {
+            parentTree: tree,
+            parentCacheNode: cache,
+            parentSegmentPath: null,
+            parentParams: {},
+            // This is the <Activity> "name" that shows up in the Suspense DevTools.
+            // It represents the root of the app.
+            debugNameContext: '/',
+            // Root node always has `url`
+            // Provided in AppTreeContext to ensure it can be overwritten in layout-router
+            url: canonicalUrl,
+            // Root segment is always active
+            isActive: true
+        };
+    }, [
+        tree,
+        cache,
+        canonicalUrl
+    ]);
+    const globalLayoutRouterContext = useMemo(()=>{
+        return {
+            tree,
+            focusAndScrollRef,
+            nextUrl,
+            previousNextUrl
+        };
+    }, [
+        tree,
+        focusAndScrollRef,
+        nextUrl,
+        previousNextUrl
+    ]);
+    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, headKeyWithoutSearchParams] = matchingHead;
+        head = /*#__PURE__*/ _jsx(Head, {
+            headCacheNode: headCacheNode
+        }, // Necessary for PPR: omit search params from the key to match prerendered keys
+        typeof window === 'undefined' ? headKeyWithoutSearchParams : headKey);
+    } else {
+        head = null;
+    }
+    let content = /*#__PURE__*/ _jsxs(RedirectBoundary, {
+        children: [
+            head,
+            /*#__PURE__*/ _jsx(RootLayoutBoundary, {
+                children: 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('../dev/hot-reloader/app/hot-reloader-app').default;
+        content = /*#__PURE__*/ _jsx(HotReloader, {
+            globalError: globalError,
+            webSocket: webSocket,
+            staticIndicatorState: staticIndicatorState,
+            children: content
+        });
+    } else {
+        content = /*#__PURE__*/ _jsx(RootErrorBoundary, {
+            errorComponent: globalError[0],
+            errorStyles: globalError[1],
+            children: content
+        });
+    }
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(HistoryUpdater, {
+                appRouterState: state
+            }),
+            /*#__PURE__*/ _jsx(RuntimeStyles, {}),
+            /*#__PURE__*/ _jsx(NavigationPromisesContext.Provider, {
+                value: instrumentedNavigationPromises,
+                children: /*#__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({ actionQueue, globalErrorState, webSocket, staticIndicatorState }) {
+    useNavFailureHandler();
+    const router = /*#__PURE__*/ _jsx(Router, {
+        actionQueue: actionQueue,
+        globalError: globalErrorState,
+        webSocket: webSocket,
+        staticIndicatorState: staticIndicatorState
+    });
+    // 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.
+    return /*#__PURE__*/ _jsx(RootErrorBoundary, {
+        errorComponent: DefaultGlobalError,
+        children: router
+    });
+}
+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 = getDeploymentIdQueryOrEmptyString();
+    return [
+        ...runtimeStyles
+    ].map((href, i)=>/*#__PURE__*/ _jsx("link", {
+            rel: "stylesheet",
+            href: `${href}${dplId}`,
+            // @ts-ignore
+            precedence: "next"
+        }, i));
+}
+
+//# sourceMappingURL=app-router.js.map

apps/public-web/node_modules/next/dist/esm/client/components/bfcache.js

@@ -0,0 +1,93 @@
+import { useState } from 'react';
+// When the flag is disabled, only track the currently active tree
+const MAX_BF_CACHE_ENTRIES = process.env.__NEXT_CACHE_COMPONENTS ? 3 : 1;
+/**
+ * Keeps track of the most recent N trees (FlightRouterStates) that were active
+ * at a certain segment level. E.g. for a segment "/a/b/[param]", this hook
+ * tracks the last N param values that the router rendered for N.
+ *
+ * The result of this hook precisely determines the number and order of
+ * trees that are rendered in parallel at their segment level.
+ *
+ * The purpose of this cache is to we can preserve the React and DOM state of
+ * some number of inactive trees, by rendering them in an <Activity> boundary.
+ * That means it would not make sense for the the lifetime of the cache to be
+ * any longer than the lifetime of the React tree; e.g. if the hook were
+ * unmounted, then the React tree would be, too. So, we use React state to
+ * manage it.
+ *
+ * Note that we don't store the RSC data for the cache entries in this hook —
+ * the data for inactive segments is stored in the parent CacheNode, which
+ * *does* have a longer lifetime than the React tree. This hook only determines
+ * which of those trees should have their *state* preserved, by <Activity>.
+ */ export function useRouterBFCache(activeTree, activeStateKey) {
+    // The currently active entry. The entries form a linked list, sorted in
+    // order of most recently active. This allows us to reuse parts of the list
+    // without cloning, unless there's a reordering or removal.
+    // TODO: Once we start tracking back/forward history at each route level,
+    // we should use the history order instead. In other words, when traversing
+    // to an existing entry as a result of a popstate event, we should maintain
+    // the existing order instead of moving it to the front of the list. I think
+    // an initial implementation of this could be to pass an incrementing id
+    // to history.pushState/replaceState, then use that here for ordering.
+    const [prevActiveEntry, setPrevActiveEntry] = useState(()=>{
+        const initialEntry = {
+            tree: activeTree,
+            stateKey: activeStateKey,
+            next: null
+        };
+        return initialEntry;
+    });
+    if (prevActiveEntry.tree === activeTree) {
+        // Fast path. The active tree hasn't changed, so we can reuse the
+        // existing state.
+        return prevActiveEntry;
+    }
+    // The route tree changed. Note that this doesn't mean that the tree changed
+    // *at this level* — the change may be due to a child route. Either way, we
+    // need to either add or update the router tree in the bfcache.
+    //
+    // The rest of the code looks more complicated than it actually is because we
+    // can't mutate the state in place; we have to copy-on-write.
+    // Create a new entry for the active cache key. This is the head of the new
+    // linked list.
+    const newActiveEntry = {
+        tree: activeTree,
+        stateKey: activeStateKey,
+        next: null
+    };
+    // We need to append the old list onto the new list. If the head of the new
+    // list was already present in the cache, then we'll need to clone everything
+    // that came before it. Then we can reuse the rest.
+    let n = 1;
+    let oldEntry = prevActiveEntry;
+    let clonedEntry = newActiveEntry;
+    while(oldEntry !== null && n < MAX_BF_CACHE_ENTRIES){
+        if (oldEntry.stateKey === activeStateKey) {
+            // Fast path. This entry in the old list that corresponds to the key that
+            // is now active. We've already placed a clone of this entry at the front
+            // of the new list. We can reuse the rest of the old list without cloning.
+            // NOTE: We don't need to worry about eviction in this case because we
+            // haven't increased the size of the cache, and we assume the max size
+            // is constant across renders. If we were to change it to a dynamic limit,
+            // then the implementation would need to account for that.
+            clonedEntry.next = oldEntry.next;
+            break;
+        } else {
+            // Clone the entry and append it to the list.
+            n++;
+            const entry = {
+                tree: oldEntry.tree,
+                stateKey: oldEntry.stateKey,
+                next: null
+            };
+            clonedEntry.next = entry;
+            clonedEntry = entry;
+        }
+        oldEntry = oldEntry.next;
+    }
+    setPrevActiveEntry(newActiveEntry);
+    return newActiveEntry;
+}
+
+//# sourceMappingURL=bfcache.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/app-error.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } 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: {
+        lineHeight: '48px'
+    },
+    h1: {
+        display: 'inline-block',
+        margin: '0 20px 0 0',
+        paddingRight: 23,
+        fontSize: 24,
+        fontWeight: 500,
+        verticalAlign: 'top'
+    },
+    h2: {
+        fontSize: 14,
+        fontWeight: 400,
+        lineHeight: '28px'
+    },
+    wrap: {
+        display: 'inline-block'
+    }
+};
+/* CSS minified 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);
+  }
+}
+*/ const themeCss = `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)}}`;
+function AppError() {
+    const errorMessage = 'Internal Server Error.';
+    const title = `500: ${errorMessage}`;
+    return /*#__PURE__*/ _jsxs("html", {
+        id: "__next_error__",
+        children: [
+            /*#__PURE__*/ _jsx("head", {
+                children: /*#__PURE__*/ _jsx("title", {
+                    children: title
+                })
+            }),
+            /*#__PURE__*/ _jsx("body", {
+                children: /*#__PURE__*/ _jsx("div", {
+                    style: styles.error,
+                    children: /*#__PURE__*/ _jsxs("div", {
+                        style: styles.desc,
+                        children: [
+                            /*#__PURE__*/ _jsx("style", {
+                                dangerouslySetInnerHTML: {
+                                    __html: themeCss
+                                }
+                            }),
+                            /*#__PURE__*/ _jsx("h1", {
+                                className: "next-error-h1",
+                                style: styles.h1,
+                                children: "500"
+                            }),
+                            /*#__PURE__*/ _jsx("div", {
+                                style: styles.wrap,
+                                children: /*#__PURE__*/ _jsx("h2", {
+                                    style: styles.h2,
+                                    children: errorMessage
+                                })
+                            })
+                        ]
+                    })
+                })
+            })
+        ]
+    });
+}
+export default AppError;
+
+//# sourceMappingURL=app-error.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/app-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/app-error.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  desc: {\n    lineHeight: '48px',\n  },\n  h1: {\n    display: 'inline-block',\n    margin: '0 20px 0 0',\n    paddingRight: 23,\n    fontSize: 24,\n    fontWeight: 500,\n    verticalAlign: 'top',\n  },\n  h2: {\n    fontSize: 14,\n    fontWeight: 400,\n    lineHeight: '28px',\n  },\n  wrap: {\n    display: 'inline-block',\n  },\n} as const\n\n/* CSS minified from\nbody { margin: 0; color: #000; background: #fff; }\n.next-error-h1 {\n  border-right: 1px solid rgba(0, 0, 0, .3);\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*/\nconst themeCss = `body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}\n@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}`\n\nfunction AppError() {\n  const errorMessage = 'Internal Server Error.'\n  const title = `500: ${errorMessage}`\n  return (\n    <html id=\"__next_error__\">\n      <head>\n        <title>{title}</title>\n      </head>\n      <body>\n        <div style={styles.error}>\n          <div style={styles.desc}>\n            <style\n              dangerouslySetInnerHTML={{\n                __html: themeCss,\n              }}\n            />\n            <h1 className=\"next-error-h1\" style={styles.h1}>\n              500\n            </h1>\n            <div style={styles.wrap}>\n              <h2 style={styles.h2}>{errorMessage}</h2>\n            </div>\n          </div>\n        </div>\n      </body>\n    </html>\n  )\n}\n\nexport default AppError\n"],"names":["React","styles","error","fontFamily","height","textAlign","display","flexDirection","alignItems","justifyContent","desc","lineHeight","h1","margin","paddingRight","fontSize","fontWeight","verticalAlign","h2","wrap","themeCss","AppError","errorMessage","title","html","id","head","body","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;IACAC,MAAM;QACJC,YAAY;IACd;IACAC,IAAI;QACFN,SAAS;QACTO,QAAQ;QACRC,cAAc;QACdC,UAAU;QACVC,YAAY;QACZC,eAAe;IACjB;IACAC,IAAI;QACFH,UAAU;QACVC,YAAY;QACZL,YAAY;IACd;IACAQ,MAAM;QACJb,SAAS;IACX;AACF;AAEA;;;;;;;;;;;AAWA,GACA,MAAMc,WAAW,CAAC;+HAC6G,CAAC;AAEhI,SAASC;IACP,MAAMC,eAAe;IACrB,MAAMC,QAAQ,CAAC,KAAK,EAAED,cAAc;IACpC,qBACE,MAACE;QAAKC,IAAG;;0BACP,KAACC;0BACC,cAAA,KAACH;8BAAOA;;;0BAEV,KAACI;0BACC,cAAA,KAACC;oBAAIC,OAAO5B,OAAOC,KAAK;8BACtB,cAAA,MAAC0B;wBAAIC,OAAO5B,OAAOS,IAAI;;0CACrB,KAACmB;gCACCC,yBAAyB;oCACvBC,QAAQX;gCACV;;0CAEF,KAACR;gCAAGoB,WAAU;gCAAgBH,OAAO5B,OAAOW,EAAE;0CAAE;;0CAGhD,KAACgB;gCAAIC,OAAO5B,OAAOkB,IAAI;0CACrB,cAAA,KAACD;oCAAGW,OAAO5B,OAAOiB,EAAE;8CAAGI;;;;;;;;;AAOrC;AAEA,eAAeD,SAAQ","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/default-null.js

@@ -0,0 +1,6 @@
+export const PARALLEL_ROUTE_DEFAULT_NULL_PATH = 'next/dist/client/components/builtin/default-null.js';
+export default function ParallelRouteDefaultNull() {
+    return null;
+}
+
+//# sourceMappingURL=default-null.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/default-null.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/default-null.tsx"],"sourcesContent":["export const PARALLEL_ROUTE_DEFAULT_NULL_PATH =\n  'next/dist/client/components/builtin/default-null.js'\n\nexport default function ParallelRouteDefaultNull() {\n  return null\n}\n"],"names":["PARALLEL_ROUTE_DEFAULT_NULL_PATH","ParallelRouteDefaultNull"],"mappings":"AAAA,OAAO,MAAMA,mCACX,sDAAqD;AAEvD,eAAe,SAASC;IACtB,OAAO;AACT","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/default.js

@@ -0,0 +1,7 @@
+import { notFound } from '../not-found';
+export const PARALLEL_ROUTE_DEFAULT_PATH = 'next/dist/client/components/builtin/default.js';
+export default function ParallelRouteDefault() {
+    notFound();
+}
+
+//# sourceMappingURL=default.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/default.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/default.tsx"],"sourcesContent":["import { notFound } from '../not-found'\n\nexport const PARALLEL_ROUTE_DEFAULT_PATH =\n  'next/dist/client/components/builtin/default.js'\n\nexport default function ParallelRouteDefault() {\n  notFound()\n}\n"],"names":["notFound","PARALLEL_ROUTE_DEFAULT_PATH","ParallelRouteDefault"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,eAAc;AAEvC,OAAO,MAAMC,8BACX,iDAAgD;AAElD,eAAe,SAASC;IACtBF;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/empty-stub.js

@@ -0,0 +1,5 @@
+export default function Empty() {
+    return null;
+}
+
+//# sourceMappingURL=empty-stub.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/empty-stub.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/empty-stub.tsx"],"sourcesContent":["export default function Empty() {\n  return null\n}\n"],"names":["Empty"],"mappings":"AAAA,eAAe,SAASA;IACtB,OAAO;AACT","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/forbidden.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.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/forbidden.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/forbidden.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,yCAAwC;AAEhF,eAAe,SAASC;IACtB,qBACE,KAACD;QACCE,QAAQ;QACRC,SAAQ;;AAGd","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/global-error.js

@@ -0,0 +1,66 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { HandleISRError } from '../handle-isr-error';
+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'
+    }
+};
+function DefaultGlobalError({ error }) {
+    const digest = 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 DefaultGlobalError;
+
+//# sourceMappingURL=global-error.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/global-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/global-error.tsx"],"sourcesContent":["'use client'\n\nimport { HandleISRError } from '../handle-isr-error'\n\nconst styles = {\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  text: {\n    fontSize: '14px',\n    fontWeight: 400,\n    lineHeight: '28px',\n    margin: '0 8px',\n  },\n} as const\n\nexport type GlobalErrorComponent = React.ComponentType<{\n  error: any\n}>\nfunction DefaultGlobalError({ error }: { error: any }) {\n  const digest: string | undefined = error?.digest\n  return (\n    <html id=\"__next_error__\">\n      <head></head>\n      <body>\n        <HandleISRError error={error} />\n        <div style={styles.error}>\n          <div>\n            <h2 style={styles.text}>\n              Application error: a {digest ? 'server' : 'client'}-side exception\n              has occurred while loading {window.location.hostname} (see the{' '}\n              {digest ? 'server logs' : 'browser console'} for more\n              information).\n            </h2>\n            {digest ? <p style={styles.text}>{`Digest: ${digest}`}</p> : null}\n          </div>\n        </div>\n      </body>\n    </html>\n  )\n}\n\n// Exported so that the import signature in the loaders can be identical to user\n// supplied custom global error signatures.\nexport default DefaultGlobalError\n"],"names":["HandleISRError","styles","error","fontFamily","height","textAlign","display","flexDirection","alignItems","justifyContent","text","fontSize","fontWeight","lineHeight","margin","DefaultGlobalError","digest","html","id","head","body","div","style","h2","window","location","hostname","p"],"mappings":"AAAA;;AAEA,SAASA,cAAc,QAAQ,sBAAqB;AAEpD,MAAMC,SAAS;IACbC,OAAO;QACL,0FAA0F;QAC1FC,YACE;QACFC,QAAQ;QACRC,WAAW;QACXC,SAAS;QACTC,eAAe;QACfC,YAAY;QACZC,gBAAgB;IAClB;IACAC,MAAM;QACJC,UAAU;QACVC,YAAY;QACZC,YAAY;QACZC,QAAQ;IACV;AACF;AAKA,SAASC,mBAAmB,EAAEb,KAAK,EAAkB;IACnD,MAAMc,SAA6Bd,OAAOc;IAC1C,qBACE,MAACC;QAAKC,IAAG;;0BACP,KAACC;0BACD,MAACC;;kCACC,KAACpB;wBAAeE,OAAOA;;kCACvB,KAACmB;wBAAIC,OAAOrB,OAAOC,KAAK;kCACtB,cAAA,MAACmB;;8CACC,MAACE;oCAAGD,OAAOrB,OAAOS,IAAI;;wCAAE;wCACAM,SAAS,WAAW;wCAAS;wCACvBQ,OAAOC,QAAQ,CAACC,QAAQ;wCAAC;wCAAU;wCAC9DV,SAAS,gBAAgB;wCAAkB;;;gCAG7CA,uBAAS,KAACW;oCAAEL,OAAOrB,OAAOS,IAAI;8CAAG,CAAC,QAAQ,EAAEM,QAAQ;qCAAQ;;;;;;;;AAMzE;AAEA,gFAAgF;AAChF,2CAA2C;AAC3C,eAAeD,mBAAkB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/global-not-found.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HTTPAccessErrorFallback } from '../http-access-fallback/error-fallback';
+function GlobalNotFound() {
+    return /*#__PURE__*/ _jsx("html", {
+        children: /*#__PURE__*/ _jsx("body", {
+            children: /*#__PURE__*/ _jsx(HTTPAccessErrorFallback, {
+                status: 404,
+                message: 'This page could not be found.'
+            })
+        })
+    });
+}
+export default GlobalNotFound;
+
+//# sourceMappingURL=global-not-found.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/global-not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/global-not-found.tsx"],"sourcesContent":["import { HTTPAccessErrorFallback } from '../http-access-fallback/error-fallback'\n\nfunction GlobalNotFound() {\n  return (\n    <html>\n      <body>\n        <HTTPAccessErrorFallback\n          status={404}\n          message={'This page could not be found.'}\n        />\n      </body>\n    </html>\n  )\n}\n\nexport default GlobalNotFound\n"],"names":["HTTPAccessErrorFallback","GlobalNotFound","html","body","status","message"],"mappings":";AAAA,SAASA,uBAAuB,QAAQ,yCAAwC;AAEhF,SAASC;IACP,qBACE,KAACC;kBACC,cAAA,KAACC;sBACC,cAAA,KAACH;gBACCI,QAAQ;gBACRC,SAAS;;;;AAKnB;AAEA,eAAeJ,eAAc","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/layout.js

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

apps/public-web/node_modules/next/dist/esm/client/components/builtin/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/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,EACpCC,QAAQ,EAGT;IACC,qBACE,KAACC;kBACC,cAAA,KAACC;sBAAMF;;;AAGb","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/builtin/not-found.js

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

apps/public-web/node_modules/next/dist/esm/client/components/builtin/not-found.js.map

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

apps/public-web/node_modules/next/dist/esm/client/components/builtin/unauthorized.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HTTPAccessErrorFallback } from '../http-access-fallback/error-fallback';
+export default function Unauthorized() {
+    return /*#__PURE__*/ _jsx(HTTPAccessErrorFallback, {
+        status: 401,
+        message: "You're not authorized to access this page."
+    });
+}
+
+//# sourceMappingURL=unauthorized.js.map

apps/public-web/node_modules/next/dist/esm/client/components/builtin/unauthorized.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/builtin/unauthorized.tsx"],"sourcesContent":["import { HTTPAccessErrorFallback } from '../http-access-fallback/error-fallback'\n\nexport default function Unauthorized() {\n  return (\n    <HTTPAccessErrorFallback\n      status={401}\n      message=\"You're not authorized to access this page.\"\n    />\n  )\n}\n"],"names":["HTTPAccessErrorFallback","Unauthorized","status","message"],"mappings":";AAAA,SAASA,uBAAuB,QAAQ,yCAAwC;AAEhF,eAAe,SAASC;IACtB,qBACE,KAACD;QACCE,QAAQ;QACRC,SAAQ;;AAGd","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/client-page.js

@@ -0,0 +1,67 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { InvariantError } from '../../shared/lib/invariant-error';
+import { LayoutRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { use } from 'react';
+import { urlSearchParamsToParsedUrlQuery } from '../route-params';
+import { SearchParamsContext } from '../../shared/lib/hooks-client-context.shared-runtime';
+/**
+ * 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({ Component, serverProvidedParams }) {
+    let searchParams;
+    let params;
+    if (serverProvidedParams !== null) {
+        searchParams = serverProvidedParams.searchParams;
+        params = serverProvidedParams.params;
+    } else {
+        // When Cache Components is enabled, the server does not pass the params as
+        // props; they are parsed on the client and passed via context.
+        const layoutRouterContext = use(LayoutRouterContext);
+        params = layoutRouterContext !== null ? layoutRouterContext.parentParams : {};
+        // This is an intentional behavior change: when Cache Components is enabled,
+        // client segments receive the "canonical" search params, not the
+        // rewritten ones. Users should either call useSearchParams directly or pass
+        // the rewritten ones in from a Server Component.
+        // TODO: Log a deprecation error when this object is accessed
+        searchParams = urlSearchParamsToParsedUrlQuery(use(SearchParamsContext));
+    }
+    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

apps/public-web/node_modules/next/dist/esm/client/components/client-segment.js

@@ -0,0 +1,52 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { InvariantError } from '../../shared/lib/invariant-error';
+import { LayoutRouterContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { use } from 'react';
+/**
+ * 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 cacheComponents is enabled. It is up to the caller to decide if the promises are needed.
+ */ export function ClientSegmentRoot({ Component, slots, serverProvidedParams }) {
+    let params;
+    if (serverProvidedParams !== null) {
+        params = serverProvidedParams.params;
+    } else {
+        // When Cache Components is enabled, the server does not pass the params
+        // as props; they are parsed on the client and passed via context.
+        const layoutRouterContext = use(LayoutRouterContext);
+        params = layoutRouterContext !== null ? layoutRouterContext.parentParams : {};
+    }
+    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

apps/public-web/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'\nimport { LayoutRouterContext } from '../../shared/lib/app-router-context.shared-runtime'\nimport { use } from 'react'\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 cacheComponents is enabled. It is up to the caller to decide if the promises are needed.\n */\nexport function ClientSegmentRoot({\n  Component,\n  slots,\n  serverProvidedParams,\n}: {\n  Component: React.ComponentType<any>\n  slots: { [key: string]: React.ReactNode }\n  serverProvidedParams: null | {\n    params: Params\n    promises: Array<Promise<any>> | null\n  }\n}) {\n  let params: Params\n  if (serverProvidedParams !== null) {\n    params = serverProvidedParams.params\n  } else {\n    // When Cache Components is enabled, the server does not pass the params\n    // as props; they are parsed on the client and passed via context.\n    const layoutRouterContext = use(LayoutRouterContext)\n    params =\n      layoutRouterContext !== null ? layoutRouterContext.parentParams : {}\n  }\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","LayoutRouterContext","use","ClientSegmentRoot","Component","slots","serverProvidedParams","params","layoutRouterContext","parentParams","window","workAsyncStorage","require","clientParams","store","getStore","createParamsFromClient","createRenderParamsFromClient"],"mappings":"AAAA;;AAEA,SAASA,cAAc,QAAQ,mCAAkC;AAGjE,SAASC,mBAAmB,QAAQ,qDAAoD;AACxF,SAASC,GAAG,QAAQ,QAAO;AAE3B;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkB,EAChCC,SAAS,EACTC,KAAK,EACLC,oBAAoB,EAQrB;IACC,IAAIC;IACJ,IAAID,yBAAyB,MAAM;QACjCC,SAASD,qBAAqBC,MAAM;IACtC,OAAO;QACL,wEAAwE;QACxE,kEAAkE;QAClE,MAAMC,sBAAsBN,IAAID;QAChCM,SACEC,wBAAwB,OAAOA,oBAAoBC,YAAY,GAAG,CAAC;IACvE;IAEA,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,IAAId,eACR,uGADI,qBAAA;uBAAA;4BAAA;8BAAA;YAEN;QACF;QAEA,MAAM,EAAEgB,sBAAsB,EAAE,GAC9BJ,QAAQ;QACVC,eAAeG,uBAAuBT,QAAQO;QAE9C,qBAAO,KAACV;YAAW,GAAGC,KAAK;YAAEE,QAAQM;;IACvC,OAAO;QACL,MAAM,EAAEI,4BAA4B,EAAE,GACpCL,QAAQ;QACV,MAAMC,eAAeI,6BAA6BV;QAClD,qBAAO,KAACH;YAAW,GAAGC,KAAK;YAAEE,QAAQM;;IACvC;AACF","ignoreList":[0]}

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

@@ -0,0 +1,24 @@
+'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({ children }) {
+    return /*#__PURE__*/ _jsx(HTTPAccessFallbackBoundary, {
+        notFound: /*#__PURE__*/ _jsx(NotAllowedRootHTTPFallbackError, {}),
+        children: children
+    });
+}
+
+//# sourceMappingURL=dev-root-http-access-fallback-boundary.js.map

apps/public-web/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,EAChDC,QAAQ,EAGT;IACC,qBACE,KAACL;QAA2BM,wBAAU,KAACH;kBACpCE;;AAGP","ignoreList":[0]}

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

@@ -0,0 +1,111 @@
+'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';
+import { HandleISRError } from './handle-isr-error';
+import { isBot } from '../../shared/lib/router/utils/is-bot';
+const isBotUserAgent = typeof window !== 'undefined' && isBot(window.navigator.userAgent);
+export class ErrorBoundaryHandler extends React.Component {
+    constructor(props){
+        super(props), this.reset = ()=>{
+            this.setState({
+                error: null
+            });
+        };
+        this.state = {
+            error: null,
+            previousPathname: this.props.pathname
+        };
+    }
+    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() {
+        //When it's bot request, segment level error boundary will keep rendering the children,
+        // the final error will be caught by the root error boundary and determine wether need to apply graceful degrade.
+        if (this.state.error && !isBotUserAgent) {
+            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;
+    }
+}
+/**
+ * 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({ errorComponent, errorStyles, errorScripts, children }) {
+    // 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

apps/public-web/node_modules/next/dist/esm/client/components/errors/graceful-degrade-boundary.js

@@ -0,0 +1,58 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Component, createRef } from 'react';
+function getDomNodeAttributes(node) {
+    const result = {};
+    for(let i = 0; i < node.attributes.length; i++){
+        const attr = node.attributes[i];
+        result[attr.name] = attr.value;
+    }
+    return result;
+}
+export class GracefulDegradeBoundary extends Component {
+    constructor(props){
+        super(props);
+        this.state = {
+            hasError: false
+        };
+        this.rootHtml = '';
+        this.htmlAttributes = {};
+        this.htmlRef = /*#__PURE__*/ createRef();
+    }
+    static getDerivedStateFromError(_) {
+        return {
+            hasError: true
+        };
+    }
+    componentDidMount() {
+        const htmlNode = this.htmlRef.current;
+        if (this.state.hasError && htmlNode) {
+            // Reapply the cached HTML attributes to the root element
+            Object.entries(this.htmlAttributes).forEach(([key, value])=>{
+                htmlNode.setAttribute(key, value);
+            });
+        }
+    }
+    render() {
+        const { hasError } = this.state;
+        // Cache the root HTML content on the first render
+        if (typeof window !== 'undefined' && !this.rootHtml) {
+            this.rootHtml = document.documentElement.innerHTML;
+            this.htmlAttributes = getDomNodeAttributes(document.documentElement);
+        }
+        if (hasError) {
+            // Render the current HTML content without hydration
+            return /*#__PURE__*/ _jsx("html", {
+                ref: this.htmlRef,
+                suppressHydrationWarning: true,
+                dangerouslySetInnerHTML: {
+                    __html: this.rootHtml
+                }
+            });
+        }
+        return this.props.children;
+    }
+}
+export default GracefulDegradeBoundary;
+
+//# sourceMappingURL=graceful-degrade-boundary.js.map

apps/public-web/node_modules/next/dist/esm/client/components/errors/graceful-degrade-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/errors/graceful-degrade-boundary.tsx"],"sourcesContent":["'use client'\n\nimport { Component, createRef, type ReactNode } from 'react'\n\ninterface ErrorBoundaryProps {\n  children: ReactNode\n}\n\ninterface ErrorBoundaryState {\n  hasError: boolean\n}\n\nfunction getDomNodeAttributes(node: HTMLElement): Record<string, string> {\n  const result: Record<string, string> = {}\n  for (let i = 0; i < node.attributes.length; i++) {\n    const attr = node.attributes[i]\n    result[attr.name] = attr.value\n  }\n  return result\n}\n\nexport class GracefulDegradeBoundary extends Component<\n  ErrorBoundaryProps,\n  ErrorBoundaryState\n> {\n  private rootHtml: string\n  private htmlAttributes: Record<string, string>\n  private htmlRef: React.RefObject<HTMLHtmlElement | null>\n\n  constructor(props: ErrorBoundaryProps) {\n    super(props)\n    this.state = { hasError: false }\n    this.rootHtml = ''\n    this.htmlAttributes = {}\n    this.htmlRef = createRef<HTMLHtmlElement>()\n  }\n\n  static getDerivedStateFromError(_: unknown): ErrorBoundaryState {\n    return { hasError: true }\n  }\n\n  componentDidMount() {\n    const htmlNode = this.htmlRef.current\n    if (this.state.hasError && htmlNode) {\n      // Reapply the cached HTML attributes to the root element\n      Object.entries(this.htmlAttributes).forEach(([key, value]) => {\n        htmlNode.setAttribute(key, value)\n      })\n    }\n  }\n\n  render() {\n    const { hasError } = this.state\n    // Cache the root HTML content on the first render\n    if (typeof window !== 'undefined' && !this.rootHtml) {\n      this.rootHtml = document.documentElement.innerHTML\n      this.htmlAttributes = getDomNodeAttributes(document.documentElement)\n    }\n\n    if (hasError) {\n      // Render the current HTML content without hydration\n      return (\n        <html\n          ref={this.htmlRef}\n          suppressHydrationWarning\n          dangerouslySetInnerHTML={{\n            __html: this.rootHtml,\n          }}\n        />\n      )\n    }\n\n    return this.props.children\n  }\n}\n\nexport default GracefulDegradeBoundary\n"],"names":["Component","createRef","getDomNodeAttributes","node","result","i","attributes","length","attr","name","value","GracefulDegradeBoundary","constructor","props","state","hasError","rootHtml","htmlAttributes","htmlRef","getDerivedStateFromError","_","componentDidMount","htmlNode","current","Object","entries","forEach","key","setAttribute","render","window","document","documentElement","innerHTML","html","ref","suppressHydrationWarning","dangerouslySetInnerHTML","__html","children"],"mappings":"AAAA;;AAEA,SAASA,SAAS,EAAEC,SAAS,QAAwB,QAAO;AAU5D,SAASC,qBAAqBC,IAAiB;IAC7C,MAAMC,SAAiC,CAAC;IACxC,IAAK,IAAIC,IAAI,GAAGA,IAAIF,KAAKG,UAAU,CAACC,MAAM,EAAEF,IAAK;QAC/C,MAAMG,OAAOL,KAAKG,UAAU,CAACD,EAAE;QAC/BD,MAAM,CAACI,KAAKC,IAAI,CAAC,GAAGD,KAAKE,KAAK;IAChC;IACA,OAAON;AACT;AAEA,OAAO,MAAMO,gCAAgCX;IAQ3CY,YAAYC,KAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAACC,KAAK,GAAG;YAAEC,UAAU;QAAM;QAC/B,IAAI,CAACC,QAAQ,GAAG;QAChB,IAAI,CAACC,cAAc,GAAG,CAAC;QACvB,IAAI,CAACC,OAAO,iBAAGjB;IACjB;IAEA,OAAOkB,yBAAyBC,CAAU,EAAsB;QAC9D,OAAO;YAAEL,UAAU;QAAK;IAC1B;IAEAM,oBAAoB;QAClB,MAAMC,WAAW,IAAI,CAACJ,OAAO,CAACK,OAAO;QACrC,IAAI,IAAI,CAACT,KAAK,CAACC,QAAQ,IAAIO,UAAU;YACnC,yDAAyD;YACzDE,OAAOC,OAAO,CAAC,IAAI,CAACR,cAAc,EAAES,OAAO,CAAC,CAAC,CAACC,KAAKjB,MAAM;gBACvDY,SAASM,YAAY,CAACD,KAAKjB;YAC7B;QACF;IACF;IAEAmB,SAAS;QACP,MAAM,EAAEd,QAAQ,EAAE,GAAG,IAAI,CAACD,KAAK;QAC/B,kDAAkD;QAClD,IAAI,OAAOgB,WAAW,eAAe,CAAC,IAAI,CAACd,QAAQ,EAAE;YACnD,IAAI,CAACA,QAAQ,GAAGe,SAASC,eAAe,CAACC,SAAS;YAClD,IAAI,CAAChB,cAAc,GAAGf,qBAAqB6B,SAASC,eAAe;QACrE;QAEA,IAAIjB,UAAU;YACZ,oDAAoD;YACpD,qBACE,KAACmB;gBACCC,KAAK,IAAI,CAACjB,OAAO;gBACjBkB,wBAAwB;gBACxBC,yBAAyB;oBACvBC,QAAQ,IAAI,CAACtB,QAAQ;gBACvB;;QAGN;QAEA,OAAO,IAAI,CAACH,KAAK,CAAC0B,QAAQ;IAC5B;AACF;AAEA,eAAe5B,wBAAuB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/errors/root-error-boundary.js

@@ -0,0 +1,24 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import GracefulDegradeBoundary from './graceful-degrade-boundary';
+import { ErrorBoundary } from '../error-boundary';
+import { isBot } from '../../../shared/lib/router/utils/is-bot';
+const isBotUserAgent = typeof window !== 'undefined' && isBot(window.navigator.userAgent);
+export default function RootErrorBoundary({ children, errorComponent, errorStyles, errorScripts }) {
+    if (isBotUserAgent) {
+        // Preserve existing DOM/HTML for bots to avoid replacing content with an error UI
+        // and to keep the original SSR output intact.
+        return /*#__PURE__*/ _jsx(GracefulDegradeBoundary, {
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsx(ErrorBoundary, {
+        errorComponent: errorComponent,
+        errorStyles: errorStyles,
+        errorScripts: errorScripts,
+        children: children
+    });
+}
+
+//# sourceMappingURL=root-error-boundary.js.map

apps/public-web/node_modules/next/dist/esm/client/components/errors/root-error-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/errors/root-error-boundary.tsx"],"sourcesContent":["'use client'\n\nimport React, { type JSX } from 'react'\nimport GracefulDegradeBoundary from './graceful-degrade-boundary'\nimport { ErrorBoundary, type ErrorBoundaryProps } from '../error-boundary'\nimport { isBot } from '../../../shared/lib/router/utils/is-bot'\n\nconst isBotUserAgent =\n  typeof window !== 'undefined' && isBot(window.navigator.userAgent)\n\nexport default function RootErrorBoundary({\n  children,\n  errorComponent,\n  errorStyles,\n  errorScripts,\n}: ErrorBoundaryProps & { children: React.ReactNode }): JSX.Element {\n  if (isBotUserAgent) {\n    // Preserve existing DOM/HTML for bots to avoid replacing content with an error UI\n    // and to keep the original SSR output intact.\n    return <GracefulDegradeBoundary>{children}</GracefulDegradeBoundary>\n  }\n\n  return (\n    <ErrorBoundary\n      errorComponent={errorComponent}\n      errorStyles={errorStyles}\n      errorScripts={errorScripts}\n    >\n      {children}\n    </ErrorBoundary>\n  )\n}\n"],"names":["React","GracefulDegradeBoundary","ErrorBoundary","isBot","isBotUserAgent","window","navigator","userAgent","RootErrorBoundary","children","errorComponent","errorStyles","errorScripts"],"mappings":"AAAA;;AAEA,OAAOA,WAAyB,QAAO;AACvC,OAAOC,6BAA6B,8BAA6B;AACjE,SAASC,aAAa,QAAiC,oBAAmB;AAC1E,SAASC,KAAK,QAAQ,0CAAyC;AAE/D,MAAMC,iBACJ,OAAOC,WAAW,eAAeF,MAAME,OAAOC,SAAS,CAACC,SAAS;AAEnE,eAAe,SAASC,kBAAkB,EACxCC,QAAQ,EACRC,cAAc,EACdC,WAAW,EACXC,YAAY,EACuC;IACnD,IAAIR,gBAAgB;QAClB,kFAAkF;QAClF,8CAA8C;QAC9C,qBAAO,KAACH;sBAAyBQ;;IACnC;IAEA,qBACE,KAACP;QACCQ,gBAAgBA;QAChBC,aAAaA;QACbC,cAAcA;kBAEbH;;AAGP","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/forbidden.js

@@ -0,0 +1,32 @@
+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
+        });
+    }
+    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

apps/public-web/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  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,GAAGD,+BAA+B,IAAI,CAAC;AAEtD,OAAO,SAASE;IACd,IAAI,CAACC,QAAQC,GAAG,CAACC,mCAAmC,EAAE;QACpD,MAAM,qBAEL,CAFK,IAAIC,MACR,CAAC,+GAA+G,CAAC,GAD7G,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,MAAMC,QAAQ,qBAAiB,CAAjB,IAAID,MAAML,SAAV,qBAAA;eAAA;oBAAA;sBAAA;IAAgB;IAC5BM,MAAkCC,MAAM,GAAGP;IAC7C,MAAMM;AACR","ignoreList":[0]}

apps/public-web/node_modules/next/dist/esm/client/components/handle-isr-error.js

@@ -0,0 +1,18 @@
+const workAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/work-async-storage.external').workAsyncStorage : undefined;
+// 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
+export function HandleISRError({ error }) {
+    if (workAsyncStorage) {
+        const store = workAsyncStorage.getStore();
+        if (store?.isStaticGeneration) {
+            if (error) {
+                console.error(error);
+            }
+            throw error;
+        }
+    }
+    return null;
+}
+
+//# sourceMappingURL=handle-isr-error.js.map

apps/public-web/node_modules/next/dist/esm/client/components/handle-isr-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/handle-isr-error.tsx"],"sourcesContent":["const workAsyncStorage =\n  typeof window === 'undefined'\n    ? (\n        require('../../server/app-render/work-async-storage.external') as typeof import('../../server/app-render/work-async-storage.external')\n      ).workAsyncStorage\n    : undefined\n\n// if we are revalidating we want to re-throw the error so the\n// function crashes so we can maintain our previous cache\n// instead of caching the error page\nexport function HandleISRError({ error }: { error: any }) {\n  if (workAsyncStorage) {\n    const store = workAsyncStorage.getStore()\n    if (store?.isStaticGeneration) {\n      if (error) {\n        console.error(error)\n      }\n      throw error\n    }\n  }\n\n  return null\n}\n"],"names":["workAsyncStorage","window","require","undefined","HandleISRError","error","store","getStore","isStaticGeneration","console"],"mappings":"AAAA,MAAMA,mBACJ,OAAOC,WAAW,cACd,AACEC,QAAQ,uDACRF,gBAAgB,GAClBG;AAEN,8DAA8D;AAC9D,yDAAyD;AACzD,oCAAoC;AACpC,OAAO,SAASC,eAAe,EAAEC,KAAK,EAAkB;IACtD,IAAIL,kBAAkB;QACpB,MAAMM,QAAQN,iBAAiBO,QAAQ;QACvC,IAAID,OAAOE,oBAAoB;YAC7B,IAAIH,OAAO;gBACTI,QAAQJ,KAAK,CAACA;YAChB;YACA,MAAMA;QACR;IACF;IAEA,OAAO;AACT","ignoreList":[0]}

apps/public-web/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

apps/public-web/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,CAAC,sBAAsB,EAAEA,aAAa,QADlBA,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","ignoreList":[0]}

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

@@ -0,0 +1,117 @@
+'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 {
+    constructor(props){
+        super(props);
+        this.state = {
+            triggeredStatus: undefined,
+            previousPathname: props.pathname
+        };
+    }
+    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;
+    }
+}
+export function HTTPAccessFallbackBoundary({ notFound, forbidden, unauthorized, children }) {
+    // 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

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

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { styles } from '../styles/access-error-styles';
+export function HTTPAccessErrorFallback({ status, message }) {
+    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

apps/public-web/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 { styles } from '../styles/access-error-styles'\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":["styles","HTTPAccessErrorFallback","status","message","title","div","style","error","dangerouslySetInnerHTML","__html","h1","className","desc","h2"],"mappings":";AAAA,SAASA,MAAM,QAAQ,gCAA+B;AAEtD,OAAO,SAASC,wBAAwB,EACtCC,MAAM,EACNC,OAAO,EAIR;IACC,qBACE;;0BAEE,KAACC;0BAAO,GAAGF,OAAO,EAAE,EAAEC,SAAS;;0BAE/B,KAACE;gBAAIC,OAAON,OAAOO,KAAK;0BACtB,cAAA,MAACF;;sCACC,KAACC;4BACCE,yBAAyB;gCACvB;;;;;;;;;;;;cAYA,GACAC,QAAQ,CAAC,6NAA6N,CAAC;4BACzO;;sCAEF,KAACC;4BAAGC,WAAU;4BAAgBL,OAAON,OAAOU,EAAE;sCAC3CR;;sCAEH,KAACG;4BAAIC,OAAON,OAAOY,IAAI;sCACrB,cAAA,KAACC;gCAAGP,OAAON,OAAOa,EAAE;0CAAGV;;;;;;;;AAMnC","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

apps/public-web/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

apps/public-web/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","ignoreList":[0]}

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

@@ -0,0 +1,524 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { Activity, useContext, use, Suspense, useDeferredValue } from 'react';
+import ReactDOM from 'react-dom';
+import { LayoutRouterContext, GlobalLayoutRouterContext, TemplateContext } from '../../shared/lib/app-router-context.shared-runtime';
+import { unresolvedThenable } from './unresolved-thenable';
+import { ErrorBoundary } from './error-boundary';
+import { matchSegment } from './match-segments';
+import { disableSmoothScrollDuringRouteTransition } from '../../shared/lib/router/utils/disable-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 { useRouterBFCache } from './bfcache';
+import { normalizeAppPath } from '../../shared/lib/router/utils/app-paths';
+import { NavigationPromisesContext } from '../../shared/lib/hooks-client-context.shared-runtime';
+import { getParamValueFromCacheKey } from '../route-params';
+import { isDeferredRsc } from './router-reducer/ppr-navigations';
+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)) {
+        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;
+    }
+    // If the hash fragment is an id, the page has to scroll to the element with that id.
+    return document.getElementById(hashFragment) ?? // 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') {
+                        if (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 = [];
+                disableSmoothScrollDuringRouteTransition(()=>{
+                    // 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 `disableSmoothScrollDuringRouteTransition`
+                focusAndScrollRef.onlyHashChange = false;
+                // Set focus on the element
+                domNode.focus();
+            }
+        };
+    }
+}
+function ScrollAndFocusHandler({ segmentPath, children }) {
+    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({ tree, segmentPath, debugNameContext, cacheNode: maybeCacheNode, params, url, isActive }) {
+    const context = useContext(GlobalLayoutRouterContext);
+    const parentNavPromises = useContext(NavigationPromisesContext);
+    if (!context) {
+        throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
+            value: "E473",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const cacheNode = maybeCacheNode !== null ? maybeCacheNode : //
+    // This should only be reachable for inactive/hidden segments, during
+    // prerendering The active segment should always be consistent with the
+    // CacheNode tree. Regardless, if we don't have a matching CacheNode, we
+    // must suspend rather than render nothing, to prevent showing an
+    // inconsistent route.
+    use(unresolvedThenable);
+    // `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.
+    let resolvedRsc;
+    if (isDeferredRsc(rsc)) {
+        const unwrappedRsc = use(rsc);
+        if (unwrappedRsc === null) {
+            // If the promise was resolved to `null`, it means the data for this
+            // segment was not returned by the server. Suspend indefinitely. When this
+            // happens, the router is responsible for triggering a new state update to
+            // un-suspend this segment.
+            use(unresolvedThenable);
+        }
+        resolvedRsc = unwrappedRsc;
+    } else {
+        // This is not a deferred RSC promise. Don't need to unwrap it.
+        if (rsc === null) {
+            use(unresolvedThenable);
+        }
+        resolvedRsc = rsc;
+    }
+    // In dev, we create a NavigationPromisesContext containing the instrumented promises that provide
+    // `useSelectedLayoutSegment` and `useSelectedLayoutSegments`.
+    // Promises are cached outside of render to survive suspense retries.
+    let navigationPromises = null;
+    if (process.env.NODE_ENV !== 'production') {
+        const { createNestedLayoutNavigationPromises } = require('./navigation-devtools');
+        navigationPromises = createNestedLayoutNavigationPromises(tree, parentNavPromises);
+    }
+    let children = resolvedRsc;
+    if (navigationPromises) {
+        children = /*#__PURE__*/ _jsx(NavigationPromisesContext.Provider, {
+            value: navigationPromises,
+            children: resolvedRsc
+        });
+    }
+    children = // The layout router context narrows down tree and childNodes at each level.
+    /*#__PURE__*/ _jsx(LayoutRouterContext.Provider, {
+        value: {
+            parentTree: tree,
+            parentCacheNode: cacheNode,
+            parentSegmentPath: segmentPath,
+            parentParams: params,
+            debugNameContext: debugNameContext,
+            // TODO-APP: overriding of url for parallel routes
+            url: url,
+            isActive: isActive
+        },
+        children: children
+    });
+    return children;
+}
+/**
+ * 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({ name, loading, children }) {
+    // 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, {
+            name: name,
+            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({ parallelRouterKey, error, errorStyles, errorScripts, templateStyles, templateScripts, template, notFound, forbidden, unauthorized, segmentViewBoundaries }) {
+    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, parentParams, url, isActive, debugNameContext } = 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);
+    }
+    const parentTreeSegment = parentTree[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 activeTree = parentTree[1][parallelRouterKey];
+    if (activeTree === undefined) {
+        // Could not find a matching segment. The client tree is inconsistent with
+        // the server tree. Suspend indefinitely; the router will have already
+        // detected the inconsistency when handling the server response, and
+        // triggered a refresh of the page to recover.
+        use(unresolvedThenable);
+    }
+    const activeSegment = activeTree[0];
+    const activeStateKey = createRouterCacheKey(activeSegment, true) // no search params
+    ;
+    // At each level of the route tree, not only do we render the currently
+    // active segment — we also render the last N segments that were active at
+    // this level inside a hidden <Activity> boundary, to preserve their state
+    // if or when the user navigates to them again.
+    //
+    // bfcacheEntry is a linked list of FlightRouterStates.
+    let bfcacheEntry = useRouterBFCache(activeTree, activeStateKey);
+    let children = [];
+    do {
+        const tree = bfcacheEntry.tree;
+        const stateKey = bfcacheEntry.stateKey;
+        const segment = tree[0];
+        const cacheKey = createRouterCacheKey(segment);
+        // Read segment path from the parallel router cache node.
+        const cacheNode = segmentMap.get(cacheKey) ?? null;
+        /*
+    - Error boundary
+      - Only renders error boundary if error component is provided.
+      - Rendered for each segment to ensure they have their own error state.
+      - When gracefully degrade for bots, skip rendering error boundary.
+    - 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.
+  */ let segmentBoundaryTriggerNode = null;
+        let segmentViewStateNode = null;
+        if (process.env.NODE_ENV !== 'production') {
+            const { SegmentBoundaryTriggerNode, SegmentViewStateNode } = require('../../next-devtools/userspace/app/segment-explorer-node');
+            const pagePrefix = normalizeAppPath(url);
+            segmentViewStateNode = /*#__PURE__*/ _jsx(SegmentViewStateNode, {
+                page: pagePrefix
+            }, pagePrefix);
+            segmentBoundaryTriggerNode = /*#__PURE__*/ _jsx(_Fragment, {
+                children: /*#__PURE__*/ _jsx(SegmentBoundaryTriggerNode, {})
+            });
+        }
+        let params = parentParams;
+        if (Array.isArray(segment)) {
+            // This segment contains a route param. Accumulate these as we traverse
+            // down the router tree. The result represents the set of params that
+            // the layout/page components are permitted to access below this point.
+            const paramName = segment[0];
+            const paramCacheKey = segment[1];
+            const paramType = segment[2];
+            const paramValue = getParamValueFromCacheKey(paramCacheKey, paramType);
+            if (paramValue !== null) {
+                params = {
+                    ...parentParams,
+                    [paramName]: paramValue
+                };
+            }
+        }
+        const debugName = getBoundaryDebugNameFromSegment(segment);
+        // `debugNameContext` represents the nearest non-"virtual" parent segment.
+        // `getBoundaryDebugNameFromSegment` returns undefined for virtual segments.
+        // So if `debugName` is undefined, the context is passed through unchanged.
+        const childDebugNameContext = debugName ?? debugNameContext;
+        // In practical terms, clicking this name in the Suspense DevTools
+        // should select the child slots of that layout.
+        //
+        // So the name we apply to the Activity boundary is actually based on
+        // the nearest parent segments.
+        //
+        // We skip over "virtual" parents, i.e. ones inserted by Next.js that
+        // don't correspond to application-defined code.
+        const isVirtual = debugName === undefined;
+        const debugNameToDisplay = isVirtual ? undefined : debugNameContext;
+        // 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;
+        let child = /*#__PURE__*/ _jsxs(TemplateContext.Provider, {
+            value: /*#__PURE__*/ _jsxs(ScrollAndFocusHandler, {
+                segmentPath: segmentPath,
+                children: [
+                    /*#__PURE__*/ _jsx(ErrorBoundary, {
+                        errorComponent: error,
+                        errorStyles: errorStyles,
+                        errorScripts: errorScripts,
+                        children: /*#__PURE__*/ _jsx(LoadingBoundary, {
+                            name: debugNameToDisplay,
+                            loading: loadingModuleData,
+                            children: /*#__PURE__*/ _jsx(HTTPAccessFallbackBoundary, {
+                                notFound: notFound,
+                                forbidden: forbidden,
+                                unauthorized: unauthorized,
+                                children: /*#__PURE__*/ _jsxs(RedirectBoundary, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx(InnerLayoutRouter, {
+                                            url: url,
+                                            tree: tree,
+                                            params: params,
+                                            cacheNode: cacheNode,
+                                            segmentPath: segmentPath,
+                                            debugNameContext: childDebugNameContext,
+                                            isActive: isActive && stateKey === activeStateKey
+                                        }),
+                                        segmentBoundaryTriggerNode
+                                    ]
+                                })
+                            })
+                        })
+                    }),
+                    segmentViewStateNode
+                ]
+            }),
+            children: [
+                templateStyles,
+                templateScripts,
+                template
+            ]
+        }, stateKey);
+        if (process.env.NODE_ENV !== 'production') {
+            const { SegmentStateProvider } = require('../../next-devtools/userspace/app/segment-explorer-node');
+            child = /*#__PURE__*/ _jsxs(SegmentStateProvider, {
+                children: [
+                    child,
+                    segmentViewBoundaries
+                ]
+            }, stateKey);
+        }
+        if (process.env.__NEXT_CACHE_COMPONENTS) {
+            child = /*#__PURE__*/ _jsx(Activity, {
+                name: debugNameToDisplay,
+                mode: stateKey === activeStateKey ? 'visible' : 'hidden',
+                children: child
+            }, stateKey);
+        }
+        children.push(child);
+        bfcacheEntry = bfcacheEntry.next;
+    }while (bfcacheEntry !== null);
+    return children;
+}
+function getBoundaryDebugNameFromSegment(segment) {
+    if (segment === '/') {
+        // Reached the root
+        return '/';
+    }
+    if (typeof segment === 'string') {
+        if (isVirtualLayout(segment)) {
+            return undefined;
+        } else {
+            return segment + '/';
+        }
+    }
+    const paramCacheKey = segment[1];
+    return paramCacheKey + '/';
+}
+function isVirtualLayout(segment) {
+    return(// This is inserted by the loader. We should consider encoding these
+    // in a more special way instead of checking the name, to distinguish them
+    // from app-defined groups.
+    segment === '(slot)');
+}
+
+//# sourceMappingURL=layout-router.js.map

apps/public-web/node_modules/next/dist/esm/client/components/links.js

@@ -0,0 +1,239 @@
+import { FetchStrategy, PrefetchPriority } from './segment-cache/types';
+import { createCacheKey } from './segment-cache/cache-key';
+import { schedulePrefetchTask as scheduleSegmentPrefetchTask, cancelPrefetchTask, reschedulePrefetchTask, isPrefetchTaskDirty } from './segment-cache/scheduler';
+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?.setOptimisticLinkStatus(IDLE_LINK_STATUS);
+        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) {
+    if (typeof window !== 'undefined') {
+        const { createPrefetchURL } = require('./app-router-utils');
+        try {
+            return createPrefetchURL(href);
+        } catch  {
+            // 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;
+        }
+    } else {
+        return null;
+    }
+}
+export function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus) {
+    if (prefetchEnabled) {
+        const prefetchURL = coercePrefetchableUrl(href);
+        if (prefetchURL !== null) {
+            const instance = {
+                router,
+                fetchStrategy,
+                isVisible: false,
+                prefetchTask: null,
+                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,
+        fetchStrategy,
+        isVisible: false,
+        prefetchTask: null,
+        prefetchHref: null,
+        setOptimisticLinkStatus
+    };
+    return instance;
+}
+export function mountFormInstance(element, href, router, fetchStrategy) {
+    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,
+        fetchStrategy,
+        isVisible: false,
+        prefetchTask: null,
+        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, PrefetchPriority.Default);
+}
+export function onNavigationIntent(element, unstable_upgradeToDynamicPrefetch) {
+    const instance = prefetchable.get(element);
+    if (instance === undefined) {
+        return;
+    }
+    // Prefetch the link on hover/touchstart.
+    if (instance !== undefined) {
+        if (process.env.__NEXT_DYNAMIC_ON_HOVER && unstable_upgradeToDynamicPrefetch) {
+            // Switch to a full prefetch
+            instance.fetchStrategy = FetchStrategy.Full;
+        }
+        rescheduleLinkPrefetch(instance, PrefetchPriority.Intent);
+    }
+}
+function rescheduleLinkPrefetch(instance, priority) {
+    // Ensures that app-router-instance is not compiled in the server bundle
+    if (typeof window !== 'undefined') {
+        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;
+        }
+        const { getCurrentAppRouterState } = require('./app-router-instance');
+        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.fetchStrategy, priority, null);
+            } 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.fetchStrategy, priority);
+            }
+        }
+    }
+}
+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.
+    for (const instance of prefetchableAndVisible){
+        const task = instance.prefetchTask;
+        if (task !== null && !isPrefetchTaskDirty(task, nextUrl, 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);
+        instance.prefetchTask = scheduleSegmentPrefetchTask(cacheKey, tree, instance.fetchStrategy, PrefetchPriority.Default, null);
+    }
+}
+
+//# sourceMappingURL=links.js.map