Initial commit

frontend/webapp/node_modules/next/dist/client/components/app-router-announcer.d.ts

@@ -0,0 +1,4 @@
+import type { FlightRouterState } from '../../server/app-render/types';
+export declare function AppRouterAnnouncer({ tree }: {
+    tree: FlightRouterState;
+}): import("react").ReactPortal | null;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AppRouterAnnouncer", {
+    enumerable: true,
+    get: function() {
+        return AppRouterAnnouncer;
+    }
+});
+const _react = require("react");
+const _reactdom = require("react-dom");
+const ANNOUNCER_TYPE = 'next-route-announcer';
+const ANNOUNCER_ID = '__next-route-announcer__';
+function getAnnouncerNode() {
+    var _existingAnnouncer_shadowRoot;
+    const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0];
+    if (existingAnnouncer == null ? void 0 : (_existingAnnouncer_shadowRoot = existingAnnouncer.shadowRoot) == null ? void 0 : _existingAnnouncer_shadowRoot.childNodes[0]) {
+        return existingAnnouncer.shadowRoot.childNodes[0];
+    } else {
+        const container = document.createElement(ANNOUNCER_TYPE);
+        container.style.cssText = 'position:absolute';
+        const announcer = document.createElement('div');
+        announcer.ariaLive = 'assertive';
+        announcer.id = ANNOUNCER_ID;
+        announcer.role = 'alert';
+        announcer.style.cssText = 'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal';
+        // Use shadow DOM here to avoid any potential CSS bleed
+        const shadow = container.attachShadow({
+            mode: 'open'
+        });
+        shadow.appendChild(announcer);
+        document.body.appendChild(container);
+        return announcer;
+    }
+}
+function AppRouterAnnouncer(param) {
+    let { tree } = param;
+    const [portalNode, setPortalNode] = (0, _react.useState)(null);
+    (0, _react.useEffect)(()=>{
+        const announcer = getAnnouncerNode();
+        setPortalNode(announcer);
+        return ()=>{
+            const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0];
+            if (container == null ? void 0 : container.isConnected) {
+                document.body.removeChild(container);
+            }
+        };
+    }, []);
+    const [routeAnnouncement, setRouteAnnouncement] = (0, _react.useState)('');
+    const previousTitle = (0, _react.useRef)(undefined);
+    (0, _react.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__*/ (0, _reactdom.createPortal)(routeAnnouncement, portalNode) : null;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=app-router-announcer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/app-router-announcer.tsx"],"sourcesContent":["import { useEffect, useRef, useState } from 'react'\nimport { createPortal } from 'react-dom'\nimport type { FlightRouterState } from '../../server/app-render/types'\n\nconst ANNOUNCER_TYPE = 'next-route-announcer'\nconst ANNOUNCER_ID = '__next-route-announcer__'\n\nfunction getAnnouncerNode() {\n  const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0]\n  if (existingAnnouncer?.shadowRoot?.childNodes[0]) {\n    return existingAnnouncer.shadowRoot.childNodes[0] as HTMLElement\n  } else {\n    const container = document.createElement(ANNOUNCER_TYPE)\n    container.style.cssText = 'position:absolute'\n    const announcer = document.createElement('div')\n    announcer.ariaLive = 'assertive'\n    announcer.id = ANNOUNCER_ID\n    announcer.role = 'alert'\n    announcer.style.cssText =\n      'position:absolute;border:0;height:1px;margin:-1px;padding:0;width:1px;clip:rect(0 0 0 0);overflow:hidden;white-space:nowrap;word-wrap:normal'\n\n    // Use shadow DOM here to avoid any potential CSS bleed\n    const shadow = container.attachShadow({ mode: 'open' })\n    shadow.appendChild(announcer)\n    document.body.appendChild(container)\n    return announcer\n  }\n}\n\nexport function AppRouterAnnouncer({ tree }: { tree: FlightRouterState }) {\n  const [portalNode, setPortalNode] = useState<HTMLElement | null>(null)\n\n  useEffect(() => {\n    const announcer = getAnnouncerNode()\n    setPortalNode(announcer)\n    return () => {\n      const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0]\n      if (container?.isConnected) {\n        document.body.removeChild(container)\n      }\n    }\n  }, [])\n\n  const [routeAnnouncement, setRouteAnnouncement] = useState('')\n  const previousTitle = useRef<string | undefined>(undefined)\n\n  useEffect(() => {\n    let currentTitle = ''\n    if (document.title) {\n      currentTitle = document.title\n    } else {\n      const pageHeader = document.querySelector('h1')\n      if (pageHeader) {\n        currentTitle = pageHeader.innerText || pageHeader.textContent || ''\n      }\n    }\n\n    // Only announce the title change, but not for the first load because screen\n    // readers do that automatically.\n    if (\n      previousTitle.current !== undefined &&\n      previousTitle.current !== currentTitle\n    ) {\n      setRouteAnnouncement(currentTitle)\n    }\n    previousTitle.current = currentTitle\n  }, [tree])\n\n  return portalNode ? createPortal(routeAnnouncement, portalNode) : null\n}\n"],"names":["AppRouterAnnouncer","ANNOUNCER_TYPE","ANNOUNCER_ID","getAnnouncerNode","existingAnnouncer","document","getElementsByName","shadowRoot","childNodes","container","createElement","style","cssText","announcer","ariaLive","id","role","shadow","attachShadow","mode","appendChild","body","tree","portalNode","setPortalNode","useState","useEffect","getElementsByTagName","isConnected","removeChild","routeAnnouncement","setRouteAnnouncement","previousTitle","useRef","undefined","currentTitle","title","pageHeader","querySelector","innerText","textContent","current","createPortal"],"mappings":";;;;+BA6BgBA;;;eAAAA;;;uBA7B4B;0BACf;AAG7B,MAAMC,iBAAiB;AACvB,MAAMC,eAAe;AAErB,SAASC;QAEHC;IADJ,MAAMA,oBAAoBC,SAASC,iBAAiB,CAACL,eAAe,CAAC,EAAE;IACvE,IAAIG,sCAAAA,gCAAAA,kBAAmBG,UAAU,qBAA7BH,8BAA+BI,UAAU,CAAC,EAAE,EAAE;QAChD,OAAOJ,kBAAkBG,UAAU,CAACC,UAAU,CAAC,EAAE;IACnD,OAAO;QACL,MAAMC,YAAYJ,SAASK,aAAa,CAACT;QACzCQ,UAAUE,KAAK,CAACC,OAAO,GAAG;QAC1B,MAAMC,YAAYR,SAASK,aAAa,CAAC;QACzCG,UAAUC,QAAQ,GAAG;QACrBD,UAAUE,EAAE,GAAGb;QACfW,UAAUG,IAAI,GAAG;QACjBH,UAAUF,KAAK,CAACC,OAAO,GACrB;QAEF,uDAAuD;QACvD,MAAMK,SAASR,UAAUS,YAAY,CAAC;YAAEC,MAAM;QAAO;QACrDF,OAAOG,WAAW,CAACP;QACnBR,SAASgB,IAAI,CAACD,WAAW,CAACX;QAC1B,OAAOI;IACT;AACF;AAEO,SAASb,mBAAmB,KAAqC;IAArC,IAAA,EAAEsB,IAAI,EAA+B,GAArC;IACjC,MAAM,CAACC,YAAYC,cAAc,GAAGC,IAAAA,eAAQ,EAAqB;IAEjEC,IAAAA,gBAAS,EAAC;QACR,MAAMb,YAAYV;QAClBqB,cAAcX;QACd,OAAO;YACL,MAAMJ,YAAYJ,SAASsB,oBAAoB,CAAC1B,eAAe,CAAC,EAAE;YAClE,IAAIQ,6BAAAA,UAAWmB,WAAW,EAAE;gBAC1BvB,SAASgB,IAAI,CAACQ,WAAW,CAACpB;YAC5B;QACF;IACF,GAAG,EAAE;IAEL,MAAM,CAACqB,mBAAmBC,qBAAqB,GAAGN,IAAAA,eAAQ,EAAC;IAC3D,MAAMO,gBAAgBC,IAAAA,aAAM,EAAqBC;IAEjDR,IAAAA,gBAAS,EAAC;QACR,IAAIS,eAAe;QACnB,IAAI9B,SAAS+B,KAAK,EAAE;YAClBD,eAAe9B,SAAS+B,KAAK;QAC/B,OAAO;YACL,MAAMC,aAAahC,SAASiC,aAAa,CAAC;YAC1C,IAAID,YAAY;gBACdF,eAAeE,WAAWE,SAAS,IAAIF,WAAWG,WAAW,IAAI;YACnE;QACF;QAEA,4EAA4E;QAC5E,iCAAiC;QACjC,IACER,cAAcS,OAAO,KAAKP,aAC1BF,cAAcS,OAAO,KAAKN,cAC1B;YACAJ,qBAAqBI;QACvB;QACAH,cAAcS,OAAO,GAAGN;IAC1B,GAAG;QAACb;KAAK;IAET,OAAOC,2BAAamB,IAAAA,sBAAY,EAACZ,mBAAmBP,cAAc;AACpE"}

frontend/webapp/node_modules/next/dist/client/components/app-router-headers.d.ts

@@ -0,0 +1,16 @@
+export declare const RSC_HEADER: "RSC";
+export declare const ACTION_HEADER: "Next-Action";
+export declare const NEXT_ROUTER_STATE_TREE_HEADER: "Next-Router-State-Tree";
+export declare const NEXT_ROUTER_PREFETCH_HEADER: "Next-Router-Prefetch";
+export declare const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: "Next-Router-Segment-Prefetch";
+export declare const NEXT_HMR_REFRESH_HEADER: "Next-HMR-Refresh";
+export declare const NEXT_HMR_REFRESH_HASH_COOKIE: "__next_hmr_refresh_hash__";
+export declare const NEXT_URL: "Next-Url";
+export declare const RSC_CONTENT_TYPE_HEADER: "text/x-component";
+export declare const FLIGHT_HEADERS: readonly ["RSC", "Next-Router-State-Tree", "Next-Router-Prefetch", "Next-HMR-Refresh", "Next-Router-Segment-Prefetch"];
+export declare const NEXT_RSC_UNION_QUERY: "_rsc";
+export declare const NEXT_ROUTER_STALE_TIME_HEADER: "x-nextjs-stale-time";
+export declare const NEXT_DID_POSTPONE_HEADER: "x-nextjs-postponed";
+export declare const NEXT_REWRITTEN_PATH_HEADER: "x-nextjs-rewritten-path";
+export declare const NEXT_REWRITTEN_QUERY_HEADER: "x-nextjs-rewritten-query";
+export declare const NEXT_IS_PRERENDER_HEADER: "x-nextjs-prerender";

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ACTION_HEADER: null,
+    FLIGHT_HEADERS: null,
+    NEXT_DID_POSTPONE_HEADER: null,
+    NEXT_HMR_REFRESH_HASH_COOKIE: null,
+    NEXT_HMR_REFRESH_HEADER: null,
+    NEXT_IS_PRERENDER_HEADER: null,
+    NEXT_REWRITTEN_PATH_HEADER: null,
+    NEXT_REWRITTEN_QUERY_HEADER: null,
+    NEXT_ROUTER_PREFETCH_HEADER: null,
+    NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: null,
+    NEXT_ROUTER_STALE_TIME_HEADER: null,
+    NEXT_ROUTER_STATE_TREE_HEADER: null,
+    NEXT_RSC_UNION_QUERY: null,
+    NEXT_URL: null,
+    RSC_CONTENT_TYPE_HEADER: null,
+    RSC_HEADER: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ACTION_HEADER: function() {
+        return ACTION_HEADER;
+    },
+    FLIGHT_HEADERS: function() {
+        return FLIGHT_HEADERS;
+    },
+    NEXT_DID_POSTPONE_HEADER: function() {
+        return NEXT_DID_POSTPONE_HEADER;
+    },
+    NEXT_HMR_REFRESH_HASH_COOKIE: function() {
+        return NEXT_HMR_REFRESH_HASH_COOKIE;
+    },
+    NEXT_HMR_REFRESH_HEADER: function() {
+        return NEXT_HMR_REFRESH_HEADER;
+    },
+    NEXT_IS_PRERENDER_HEADER: function() {
+        return NEXT_IS_PRERENDER_HEADER;
+    },
+    NEXT_REWRITTEN_PATH_HEADER: function() {
+        return NEXT_REWRITTEN_PATH_HEADER;
+    },
+    NEXT_REWRITTEN_QUERY_HEADER: function() {
+        return NEXT_REWRITTEN_QUERY_HEADER;
+    },
+    NEXT_ROUTER_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_PREFETCH_HEADER;
+    },
+    NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_SEGMENT_PREFETCH_HEADER;
+    },
+    NEXT_ROUTER_STALE_TIME_HEADER: function() {
+        return NEXT_ROUTER_STALE_TIME_HEADER;
+    },
+    NEXT_ROUTER_STATE_TREE_HEADER: function() {
+        return NEXT_ROUTER_STATE_TREE_HEADER;
+    },
+    NEXT_RSC_UNION_QUERY: function() {
+        return NEXT_RSC_UNION_QUERY;
+    },
+    NEXT_URL: function() {
+        return NEXT_URL;
+    },
+    RSC_CONTENT_TYPE_HEADER: function() {
+        return RSC_CONTENT_TYPE_HEADER;
+    },
+    RSC_HEADER: function() {
+        return RSC_HEADER;
+    }
+});
+const RSC_HEADER = 'RSC';
+const ACTION_HEADER = 'Next-Action';
+const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree';
+const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch';
+const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'Next-Router-Segment-Prefetch';
+const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh';
+const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
+const NEXT_URL = 'Next-Url';
+const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
+const FLIGHT_HEADERS = [
+    RSC_HEADER,
+    NEXT_ROUTER_STATE_TREE_HEADER,
+    NEXT_ROUTER_PREFETCH_HEADER,
+    NEXT_HMR_REFRESH_HEADER,
+    NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+];
+const NEXT_RSC_UNION_QUERY = '_rsc';
+const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time';
+const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed';
+const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path';
+const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query';
+const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender';
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=app-router-headers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/app-router-headers.ts"],"sourcesContent":["export const RSC_HEADER = 'RSC' as const\nexport const ACTION_HEADER = 'Next-Action' as const\n// TODO: Instead of sending the full router state, we only need to send the\n// segment path. Saves bytes. Then we could also use this field for segment\n// prefetches, which also need to specify a particular segment.\nexport const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree' as const\nexport const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch' as const\n// This contains the path to the segment being prefetched.\n// TODO: If we change Next-Router-State-Tree to be a segment path, we can use\n// that instead. Then Next-Router-Prefetch and Next-Router-Segment-Prefetch can\n// be merged into a single enum.\nexport const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER =\n  'Next-Router-Segment-Prefetch' as const\nexport const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh' as const\nexport const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__' as const\nexport const NEXT_URL = 'Next-Url' as const\nexport const RSC_CONTENT_TYPE_HEADER = 'text/x-component' as const\n\nexport const FLIGHT_HEADERS = [\n  RSC_HEADER,\n  NEXT_ROUTER_STATE_TREE_HEADER,\n  NEXT_ROUTER_PREFETCH_HEADER,\n  NEXT_HMR_REFRESH_HEADER,\n  NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,\n] as const\n\nexport const NEXT_RSC_UNION_QUERY = '_rsc' as const\n\nexport const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time' as const\nexport const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed' as const\nexport const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path' as const\nexport const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query' as const\nexport const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender' as const\n"],"names":["ACTION_HEADER","FLIGHT_HEADERS","NEXT_DID_POSTPONE_HEADER","NEXT_HMR_REFRESH_HASH_COOKIE","NEXT_HMR_REFRESH_HEADER","NEXT_IS_PRERENDER_HEADER","NEXT_REWRITTEN_PATH_HEADER","NEXT_REWRITTEN_QUERY_HEADER","NEXT_ROUTER_PREFETCH_HEADER","NEXT_ROUTER_SEGMENT_PREFETCH_HEADER","NEXT_ROUTER_STALE_TIME_HEADER","NEXT_ROUTER_STATE_TREE_HEADER","NEXT_RSC_UNION_QUERY","NEXT_URL","RSC_CONTENT_TYPE_HEADER","RSC_HEADER"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACaA,aAAa;eAAbA;;IAiBAC,cAAc;eAAdA;;IAWAC,wBAAwB;eAAxBA;;IAfAC,4BAA4B;eAA5BA;;IADAC,uBAAuB;eAAvBA;;IAmBAC,wBAAwB;eAAxBA;;IAFAC,0BAA0B;eAA1BA;;IACAC,2BAA2B;eAA3BA;;IAzBAC,2BAA2B;eAA3BA;;IAKAC,mCAAmC;eAAnCA;;IAiBAC,6BAA6B;eAA7BA;;IAvBAC,6BAA6B;eAA7BA;;IAqBAC,oBAAoB;eAApBA;;IAXAC,QAAQ;eAARA;;IACAC,uBAAuB;eAAvBA;;IAhBAC,UAAU;eAAVA;;;AAAN,MAAMA,aAAa;AACnB,MAAMf,gBAAgB;AAItB,MAAMW,gCAAgC;AACtC,MAAMH,8BAA8B;AAKpC,MAAMC,sCACX;AACK,MAAML,0BAA0B;AAChC,MAAMD,+BAA+B;AACrC,MAAMU,WAAW;AACjB,MAAMC,0BAA0B;AAEhC,MAAMb,iBAAiB;IAC5Bc;IACAJ;IACAH;IACAJ;IACAK;CACD;AAEM,MAAMG,uBAAuB;AAE7B,MAAMF,gCAAgC;AACtC,MAAMR,2BAA2B;AACjC,MAAMI,6BAA6B;AACnC,MAAMC,8BAA8B;AACpC,MAAMF,2BAA2B"}

frontend/webapp/node_modules/next/dist/client/components/app-router-instance.d.ts

@@ -0,0 +1,32 @@
+import { type AppRouterState, type ReducerActions, type ReducerState, type NavigateAction } from './router-reducer/router-reducer-types';
+import type { AppRouterInstance } from '../../shared/lib/app-router-context.shared-runtime';
+import { type LinkInstance } from './links';
+import type { FlightRouterState } from '../../server/app-render/types';
+import type { ClientInstrumentationHooks } from '../app-index';
+export type DispatchStatePromise = React.Dispatch<ReducerState>;
+export type AppRouterActionQueue = {
+    state: AppRouterState;
+    dispatch: (payload: ReducerActions, setState: DispatchStatePromise) => void;
+    action: (state: AppRouterState, action: ReducerActions) => ReducerState;
+    onRouterTransitionStart: ((url: string, type: 'push' | 'replace' | 'traverse') => void) | null;
+    pending: ActionQueueNode | null;
+    needsRefresh?: boolean;
+    last: ActionQueueNode | null;
+};
+export type ActionQueueNode = {
+    payload: ReducerActions;
+    next: ActionQueueNode | null;
+    resolve: (value: ReducerState) => void;
+    reject: (err: Error) => void;
+    discarded?: boolean;
+};
+export declare function createMutableActionQueue(initialState: AppRouterState, instrumentationHooks: ClientInstrumentationHooks | null): AppRouterActionQueue;
+export declare function getCurrentAppRouterState(): AppRouterState | null;
+export declare function dispatchNavigateAction(href: string, navigateType: NavigateAction['navigateType'], shouldScroll: boolean, linkInstanceRef: LinkInstance | null): void;
+export declare function dispatchTraverseAction(href: string, tree: FlightRouterState | undefined): void;
+/**
+ * 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 declare const publicAppRouterInstance: AppRouterInstance;

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

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createMutableActionQueue: null,
+    dispatchNavigateAction: null,
+    dispatchTraverseAction: null,
+    getCurrentAppRouterState: null,
+    publicAppRouterInstance: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createMutableActionQueue: function() {
+        return createMutableActionQueue;
+    },
+    dispatchNavigateAction: function() {
+        return dispatchNavigateAction;
+    },
+    dispatchTraverseAction: function() {
+        return dispatchTraverseAction;
+    },
+    getCurrentAppRouterState: function() {
+        return getCurrentAppRouterState;
+    },
+    publicAppRouterInstance: function() {
+        return publicAppRouterInstance;
+    }
+});
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _routerreducer = require("./router-reducer/router-reducer");
+const _react = require("react");
+const _isthenable = require("../../shared/lib/is-thenable");
+const _segmentcache = require("./segment-cache");
+const _useactionqueue = require("./use-action-queue");
+const _addbasepath = require("../add-base-path");
+const _approuter = require("./app-router");
+const _prefetchreducer = require("./router-reducer/reducers/prefetch-reducer");
+const _links = require("./links");
+function runRemainingActions(actionQueue, setState) {
+    if (actionQueue.pending !== null) {
+        actionQueue.pending = actionQueue.pending.next;
+        if (actionQueue.pending !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            runAction({
+                actionQueue,
+                action: actionQueue.pending,
+                setState
+            });
+        } else {
+            // No more actions are pending, check if a refresh is needed
+            if (actionQueue.needsRefresh) {
+                actionQueue.needsRefresh = false;
+                actionQueue.dispatch({
+                    type: _routerreducertypes.ACTION_REFRESH,
+                    origin: window.location.origin
+                }, setState);
+            }
+        }
+    }
+}
+async function runAction(param) {
+    let { actionQueue, action, setState } = param;
+    const prevState = actionQueue.state;
+    actionQueue.pending = action;
+    const payload = action.payload;
+    const actionResult = actionQueue.action(prevState, payload);
+    function handleResult(nextState) {
+        // if we discarded this action, the state should also be discarded
+        if (action.discarded) {
+            return;
+        }
+        actionQueue.state = nextState;
+        runRemainingActions(actionQueue, setState);
+        action.resolve(nextState);
+    }
+    // if the action is a promise, set up a callback to resolve it
+    if ((0, _isthenable.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 !== _routerreducertypes.ACTION_RESTORE) {
+        // Create the promise and assign the resolvers to the object.
+        const deferredPromise = new Promise((resolve, reject)=>{
+            resolvers = {
+                resolve,
+                reject
+            };
+        });
+        (0, _react.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 === _routerreducertypes.ACTION_NAVIGATE || payload.type === _routerreducertypes.ACTION_RESTORE) {
+        // Navigations (including back/forward) take priority over any pending actions.
+        // Mark the pending action as discarded (so the state is never applied) and start the navigation action immediately.
+        actionQueue.pending.discarded = true;
+        // The rest of the current queue should still execute after this navigation.
+        // (Note that it can't contain any earlier navigations, because we always put those into `actionQueue.pending` by calling `runAction`)
+        newAction.next = actionQueue.pending.next;
+        // if the pending action was a server action, mark the queue as needing a refresh once events are processed
+        if (actionQueue.pending.payload.type === _routerreducertypes.ACTION_SERVER_ACTION) {
+            actionQueue.needsRefresh = true;
+        }
+        runAction({
+            actionQueue,
+            action: newAction,
+            setState
+        });
+    } else {
+        // The queue is not empty, so add the action to the end of the queue
+        // It will be started by runRemainingActions after the previous action finishes
+        if (actionQueue.last !== null) {
+            actionQueue.last.next = newAction;
+        }
+        actionQueue.last = newAction;
+    }
+}
+let globalActionQueue = null;
+function createMutableActionQueue(initialState, instrumentationHooks) {
+    const actionQueue = {
+        state: initialState,
+        dispatch: (payload, setState)=>dispatchAction(actionQueue, payload, setState),
+        action: async (state, action)=>{
+            const result = (0, _routerreducer.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;
+}
+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;
+}
+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((0, _addbasepath.addBasePath)(href), location.href);
+    if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+        window.next.__pendingUrl = url;
+    }
+    (0, _links.setLinkForCurrentNavigation)(linkInstanceRef);
+    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
+    if (onRouterTransitionStart !== null) {
+        onRouterTransitionStart(href, navigateType);
+    }
+    (0, _useactionqueue.dispatchAppRouterAction)({
+        type: _routerreducertypes.ACTION_NAVIGATE,
+        url,
+        isExternalUrl: (0, _approuter.isExternalURL)(url),
+        locationSearch: location.search,
+        shouldScroll,
+        navigateType,
+        allowAliasing: true
+    });
+}
+function dispatchTraverseAction(href, tree) {
+    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
+    if (onRouterTransitionStart !== null) {
+        onRouterTransitionStart(href, 'traverse');
+    }
+    (0, _useactionqueue.dispatchAppRouterAction)({
+        type: _routerreducertypes.ACTION_RESTORE,
+        url: new URL(href),
+        tree
+    });
+}
+const publicAppRouterInstance = {
+    back: ()=>window.history.back(),
+    forward: ()=>window.history.forward(),
+    prefetch: process.env.__NEXT_CLIENT_SEGMENT_CACHE ? // data in the router reducer state; it writes into a global mutable
+    // cache. So we don't need to dispatch an action.
+    (href, options)=>{
+        const actionQueue = getAppRouterActionQueue();
+        (0, _segmentcache.prefetch)(href, actionQueue.state.nextUrl, actionQueue.state.tree, (options == null ? void 0 : options.kind) === _routerreducertypes.PrefetchKind.FULL);
+    } : (href, options)=>{
+        // Use the old prefetch implementation.
+        const actionQueue = getAppRouterActionQueue();
+        const url = (0, _approuter.createPrefetchURL)(href);
+        if (url !== null) {
+            var _options_kind;
+            // The prefetch reducer doesn't actually update any state or
+            // trigger a rerender. It just writes to a mutable cache. So we
+            // shouldn't bother calling setState/dispatch; we can just re-run
+            // the reducer directly using the current state.
+            // TODO: Refactor this away from a "reducer" so it's
+            // less confusing.
+            (0, _prefetchreducer.prefetchReducer)(actionQueue.state, {
+                type: _routerreducertypes.ACTION_PREFETCH,
+                url,
+                kind: (_options_kind = options == null ? void 0 : options.kind) != null ? _options_kind : _routerreducertypes.PrefetchKind.FULL
+            });
+        }
+    },
+    replace: (href, options)=>{
+        (0, _react.startTransition)(()=>{
+            var _options_scroll;
+            dispatchNavigateAction(href, 'replace', (_options_scroll = options == null ? void 0 : options.scroll) != null ? _options_scroll : true, null);
+        });
+    },
+    push: (href, options)=>{
+        (0, _react.startTransition)(()=>{
+            var _options_scroll;
+            dispatchNavigateAction(href, 'push', (_options_scroll = options == null ? void 0 : options.scroll) != null ? _options_scroll : true, null);
+        });
+    },
+    refresh: ()=>{
+        (0, _react.startTransition)(()=>{
+            (0, _useactionqueue.dispatchAppRouterAction)({
+                type: _routerreducertypes.ACTION_REFRESH,
+                origin: window.location.origin
+            });
+        });
+    },
+    hmrRefresh: ()=>{
+        if (process.env.NODE_ENV !== 'development') {
+            throw Object.defineProperty(new Error('hmrRefresh can only be used in development mode. Please use refresh instead.'), "__NEXT_ERROR_CODE", {
+                value: "E485",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            (0, _react.startTransition)(()=>{
+                (0, _useactionqueue.dispatchAppRouterAction)({
+                    type: _routerreducertypes.ACTION_HMR_REFRESH,
+                    origin: window.location.origin
+                });
+            });
+        }
+    }
+};
+// Exists for debugging purposes. Don't use in application code.
+if (typeof window !== 'undefined' && window.next) {
+    window.next.router = publicAppRouterInstance;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=app-router-instance.js.map

frontend/webapp/node_modules/next/dist/client/components/app-router.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { CacheNode } from '../../shared/lib/app-router-context.shared-runtime';
+import { type GlobalErrorComponent } from './error-boundary';
+import { type AppRouterActionQueue } from './app-router-instance';
+export declare function isExternalURL(url: URL): boolean;
+/**
+ * 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 declare function createPrefetchURL(href: string): URL | null;
+export declare function createEmptyCacheNode(): CacheNode;
+export default function AppRouter({ actionQueue, globalErrorComponentAndStyles: [globalErrorComponent, globalErrorStyles], assetPrefix, }: {
+    actionQueue: AppRouterActionQueue;
+    globalErrorComponentAndStyles: [GlobalErrorComponent, React.ReactNode];
+    assetPrefix: string;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/app-router.js

@@ -0,0 +1,536 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createEmptyCacheNode: null,
+    createPrefetchURL: null,
+    default: null,
+    isExternalURL: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createEmptyCacheNode: function() {
+        return createEmptyCacheNode;
+    },
+    createPrefetchURL: function() {
+        return createPrefetchURL;
+    },
+    default: function() {
+        return AppRouter;
+    },
+    isExternalURL: function() {
+        return isExternalURL;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _createhreffromurl = require("./router-reducer/create-href-from-url");
+const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
+const _useactionqueue = require("./use-action-queue");
+const _errorboundary = /*#__PURE__*/ _interop_require_wildcard._(require("./error-boundary"));
+const _isbot = require("../../shared/lib/router/utils/is-bot");
+const _addbasepath = require("../add-base-path");
+const _approuterannouncer = require("./app-router-announcer");
+const _redirectboundary = require("./redirect-boundary");
+const _findheadincache = require("./router-reducer/reducers/find-head-in-cache");
+const _unresolvedthenable = require("./unresolved-thenable");
+const _removebasepath = require("../remove-base-path");
+const _hasbasepath = require("../has-base-path");
+const _computechangedpath = require("./router-reducer/compute-changed-path");
+const _navfailurehandler = require("./nav-failure-handler");
+const _approuterinstance = require("./app-router-instance");
+const _redirect = require("./redirect");
+const _redirecterror = require("./redirect-error");
+const _links = require("./links");
+const globalMutable = {};
+function isExternalURL(url) {
+    return url.origin !== window.location.origin;
+}
+function createPrefetchURL(href) {
+    // Don't prefetch for bots as they don't navigate.
+    if ((0, _isbot.isBot)(window.navigator.userAgent)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL((0, _addbasepath.addBasePath)(href), window.location.href);
+    } catch (_) {
+        // TODO: Does this need to throw or can we just console.error instead? Does
+        // anyone rely on this throwing? (Seems unlikely.)
+        throw Object.defineProperty(new Error("Cannot prefetch '" + href + "' because it cannot be converted to a URL."), "__NEXT_ERROR_CODE", {
+            value: "E234",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Don't prefetch during development (improves compilation performance)
+    if (process.env.NODE_ENV === 'development') {
+        return null;
+    }
+    // External urls can't be prefetched in the same way.
+    if (isExternalURL(url)) {
+        return null;
+    }
+    return url;
+}
+function HistoryUpdater(param) {
+    let { appRouterState } = param;
+    (0, _react.useInsertionEffect)(()=>{
+        if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+            // clear pending URL as navigation is no longer
+            // in flight
+            window.next.__pendingUrl = undefined;
+        }
+        const { tree, pushRef, canonicalUrl } = appRouterState;
+        const historyState = {
+            ...pushRef.preserveCustomHistoryState ? window.history.state : {},
+            // Identifier is shortened intentionally.
+            // __NA is used to identify if the history entry can be handled by the app-router.
+            // __N is used to identify if the history entry can be handled by the old router.
+            __NA: true,
+            __PRIVATE_NEXTJS_INTERNALS_TREE: tree
+        };
+        if (pushRef.pendingPush && // Skip pushing an additional history entry if the canonicalUrl is the same as the current url.
+        // This mirrors the browser behavior for normal navigation.
+        (0, _createhreffromurl.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
+    ]);
+    (0, _react.useEffect)(()=>{
+        // The Next-Url and the base tree may affect the result of a prefetch
+        // task. Re-prefetch all visible links with the updated values. In most
+        // cases, this will not result in any new network requests, only if
+        // the prefetch result actually varies on one of these inputs.
+        if (process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
+            (0, _links.pingVisibleLinks)(appRouterState.nextUrl, appRouterState.tree);
+        }
+    }, [
+        appRouterState.nextUrl,
+        appRouterState.tree
+    ]);
+    return null;
+}
+function createEmptyCacheNode() {
+    return {
+        lazyData: null,
+        rsc: null,
+        prefetchRsc: null,
+        head: null,
+        prefetchHead: null,
+        parallelRoutes: new Map(),
+        loading: null,
+        navigatedAt: -1
+    };
+}
+function copyNextJsInternalHistoryState(data) {
+    if (data == null) data = {};
+    const currentState = window.history.state;
+    const __NA = currentState == null ? void 0 : currentState.__NA;
+    if (__NA) {
+        data.__NA = __NA;
+    }
+    const __PRIVATE_NEXTJS_INTERNALS_TREE = currentState == null ? void 0 : currentState.__PRIVATE_NEXTJS_INTERNALS_TREE;
+    if (__PRIVATE_NEXTJS_INTERNALS_TREE) {
+        data.__PRIVATE_NEXTJS_INTERNALS_TREE = __PRIVATE_NEXTJS_INTERNALS_TREE;
+    }
+    return data;
+}
+function Head(param) {
+    let { headCacheNode } = param;
+    // If this segment has a `prefetchHead`, it's the statically prefetched data.
+    // We should use that on initial render instead of `head`. Then we'll switch
+    // to `head` when the dynamic response streams in.
+    const head = headCacheNode !== null ? headCacheNode.head : null;
+    const prefetchHead = headCacheNode !== null ? headCacheNode.prefetchHead : null;
+    // If no prefetch data is available, then we go straight to rendering `head`.
+    const resolvedPrefetchRsc = prefetchHead !== null ? prefetchHead : head;
+    // We use `useDeferredValue` to handle switching between the prefetched and
+    // final values. The second argument is returned on initial render, then it
+    // re-renders with the first argument.
+    return (0, _react.useDeferredValue)(head, resolvedPrefetchRsc);
+}
+/**
+ * The global router that wraps the application components.
+ */ function Router(param) {
+    let { actionQueue, assetPrefix, globalError } = param;
+    const state = (0, _useactionqueue.useActionQueue)(actionQueue);
+    const { canonicalUrl } = state;
+    // Add memoized pathname/query for useSearchParams and usePathname.
+    const { searchParams, pathname } = (0, _react.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: (0, _hasbasepath.hasBasePath)(url.pathname) ? (0, _removebasepath.removeBasePath)(url.pathname) : url.pathname
+        };
+    }, [
+        canonicalUrl
+    ]);
+    if (process.env.NODE_ENV !== 'production') {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { cache, prefetchCache, tree } = state;
+        // This hook is in a conditional but that is ok because `process.env.NODE_ENV` never changes
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, _react.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: _approuterinstance.publicAppRouterInstance,
+                cache,
+                prefetchCache,
+                tree
+            };
+        }, [
+            cache,
+            prefetchCache,
+            tree
+        ]);
+    }
+    (0, _react.useEffect)(()=>{
+        // If the app is restored from bfcache, it's possible that
+        // pushRef.mpaNavigation is true, which would mean that any re-render of this component
+        // would trigger the mpa navigation logic again from the lines below.
+        // This will restore the router to the initial state in the event that the app is restored from bfcache.
+        function handlePageShow(event) {
+            var _window_history_state;
+            if (!event.persisted || !((_window_history_state = window.history.state) == null ? void 0 : _window_history_state.__PRIVATE_NEXTJS_INTERNALS_TREE)) {
+                return;
+            }
+            // Clear the pendingMpaPath value so that a subsequent MPA navigation to the same URL can be triggered.
+            // This is necessary because if the browser restored from bfcache, the pendingMpaPath would still be set to the value
+            // of the last MPA navigation.
+            globalMutable.pendingMpaPath = undefined;
+            (0, _useactionqueue.dispatchAppRouterAction)({
+                type: _routerreducertypes.ACTION_RESTORE,
+                url: new URL(window.location.href),
+                tree: window.history.state.__PRIVATE_NEXTJS_INTERNALS_TREE
+            });
+        }
+        window.addEventListener('pageshow', handlePageShow);
+        return ()=>{
+            window.removeEventListener('pageshow', handlePageShow);
+        };
+    }, []);
+    (0, _react.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 ((0, _redirecterror.isRedirectError)(error)) {
+                event.preventDefault();
+                const url = (0, _redirect.getURLFromRedirectError)(error);
+                const redirectType = (0, _redirect.getRedirectTypeFromError)(error);
+                // TODO: This should access the router methods directly, rather than
+                // go through the public interface.
+                if (redirectType === _redirecterror.RedirectType.push) {
+                    _approuterinstance.publicAppRouterInstance.push(url, {});
+                } else {
+                    _approuterinstance.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?
+        (0, _react.use)(_unresolvedthenable.unresolvedThenable);
+    }
+    (0, _react.useEffect)(()=>{
+        const originalPushState = window.history.pushState.bind(window.history);
+        const originalReplaceState = window.history.replaceState.bind(window.history);
+        // Ensure the canonical URL in the Next.js Router is updated when the URL is changed so that `usePathname` and `useSearchParams` hold the pushed values.
+        const applyUrlFromHistoryPushReplace = (url)=>{
+            var _window_history_state;
+            const href = window.location.href;
+            const tree = (_window_history_state = window.history.state) == null ? void 0 : _window_history_state.__PRIVATE_NEXTJS_INTERNALS_TREE;
+            (0, _react.startTransition)(()=>{
+                (0, _useactionqueue.dispatchAppRouterAction)({
+                    type: _routerreducertypes.ACTION_RESTORE,
+                    url: new URL(url != null ? url : href, href),
+                    tree
+                });
+            });
+        };
+        /**
+     * Patch pushState to ensure external changes to the history are reflected in the Next.js Router.
+     * Ensures Next.js internal history state is copied to the new history entry.
+     * Ensures usePathname and useSearchParams hold the newly provided url.
+     */ window.history.pushState = function pushState(data, _unused, url) {
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if ((data == null ? void 0 : data.__NA) || (data == null ? void 0 : data._N)) {
+                return originalPushState(data, _unused, url);
+            }
+            data = copyNextJsInternalHistoryState(data);
+            if (url) {
+                applyUrlFromHistoryPushReplace(url);
+            }
+            return originalPushState(data, _unused, url);
+        };
+        /**
+     * Patch replaceState to ensure external changes to the history are reflected in the Next.js Router.
+     * Ensures Next.js internal history state is copied to the new history entry.
+     * Ensures usePathname and useSearchParams hold the newly provided url.
+     */ window.history.replaceState = function replaceState(data, _unused, url) {
+            // Avoid a loop when Next.js internals trigger pushState/replaceState
+            if ((data == null ? void 0 : data.__NA) || (data == null ? void 0 : data._N)) {
+                return originalReplaceState(data, _unused, url);
+            }
+            data = copyNextJsInternalHistoryState(data);
+            if (url) {
+                applyUrlFromHistoryPushReplace(url);
+            }
+            return originalReplaceState(data, _unused, url);
+        };
+        /**
+     * Handle popstate event, this is used to handle back/forward in the browser.
+     * By default dispatches ACTION_RESTORE, however if the history entry was not pushed/replaced by app-router it will reload the page.
+     * That case can happen when the old router injected the history entry.
+     */ const onPopState = (event)=>{
+            if (!event.state) {
+                // TODO-APP: this case only happens when pushState/replaceState was called outside of Next.js. It should probably reload the page in this case.
+                return;
+            }
+            // This case happens when the history entry was pushed by the `pages` router.
+            if (!event.state.__NA) {
+                window.location.reload();
+                return;
+            }
+            // TODO-APP: Ideally the back button should not use startTransition as it should apply the updates synchronously
+            // Without startTransition works if the cache is there for this path
+            (0, _react.startTransition)(()=>{
+                (0, _approuterinstance.dispatchTraverseAction)(window.location.href, event.state.__PRIVATE_NEXTJS_INTERNALS_TREE);
+            });
+        };
+        // Register popstate event to call onPopstate.
+        window.addEventListener('popstate', onPopState);
+        return ()=>{
+            window.history.pushState = originalPushState;
+            window.history.replaceState = originalReplaceState;
+            window.removeEventListener('popstate', onPopState);
+        };
+    }, []);
+    const { cache, tree, nextUrl, focusAndScrollRef } = state;
+    const matchingHead = (0, _react.useMemo)(()=>{
+        return (0, _findheadincache.findHeadInCache)(cache, tree[1]);
+    }, [
+        cache,
+        tree
+    ]);
+    // Add memoized pathParams for useParams.
+    const pathParams = (0, _react.useMemo)(()=>{
+        return (0, _computechangedpath.getSelectedParams)(tree);
+    }, [
+        tree
+    ]);
+    const layoutRouterContext = (0, _react.useMemo)(()=>{
+        return {
+            parentTree: tree,
+            parentCacheNode: cache,
+            parentSegmentPath: null,
+            // Root node always has `url`
+            // Provided in AppTreeContext to ensure it can be overwritten in layout-router
+            url: canonicalUrl
+        };
+    }, [
+        tree,
+        cache,
+        canonicalUrl
+    ]);
+    const globalLayoutRouterContext = (0, _react.useMemo)(()=>{
+        return {
+            tree,
+            focusAndScrollRef,
+            nextUrl
+        };
+    }, [
+        tree,
+        focusAndScrollRef,
+        nextUrl
+    ]);
+    let head;
+    if (matchingHead !== null) {
+        // The head is wrapped in an extra component so we can use
+        // `useDeferredValue` to swap between the prefetched and final versions of
+        // the head. (This is what LayoutRouter does for segment data, too.)
+        //
+        // The `key` is used to remount the component whenever the head moves to
+        // a different segment.
+        const [headCacheNode, headKey] = matchingHead;
+        head = /*#__PURE__*/ (0, _jsxruntime.jsx)(Head, {
+            headCacheNode: headCacheNode
+        }, headKey);
+    } else {
+        head = null;
+    }
+    let content = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_redirectboundary.RedirectBoundary, {
+        children: [
+            head,
+            cache.rsc,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_approuterannouncer.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__*/ (0, _jsxruntime.jsx)(DevRootHTTPAccessFallbackBoundary, {
+                children: content
+            });
+        }
+        const HotReloader = require('./react-dev-overlay/app/hot-reloader-client').default;
+        content = /*#__PURE__*/ (0, _jsxruntime.jsx)(HotReloader, {
+            assetPrefix: assetPrefix,
+            globalError: globalError,
+            children: content
+        });
+    } else {
+        // In production, we only apply the user-customized global error boundary.
+        content = /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
+            errorComponent: globalError[0],
+            errorStyles: globalError[1],
+            children: content
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(HistoryUpdater, {
+                appRouterState: state
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(RuntimeStyles, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.PathParamsContext.Provider, {
+                value: pathParams,
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.PathnameContext.Provider, {
+                    value: pathname,
+                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.SearchParamsContext.Provider, {
+                        value: searchParams,
+                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.GlobalLayoutRouterContext.Provider, {
+                            value: globalLayoutRouterContext,
+                            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.AppRouterContext.Provider, {
+                                value: _approuterinstance.publicAppRouterInstance,
+                                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
+                                    value: layoutRouterContext,
+                                    children: content
+                                })
+                            })
+                        })
+                    })
+                })
+            })
+        ]
+    });
+}
+function AppRouter(param) {
+    let { actionQueue, globalErrorComponentAndStyles: [globalErrorComponent, globalErrorStyles], assetPrefix } = param;
+    (0, _navfailurehandler.useNavFailureHandler)();
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
+        // At the very top level, use the default GlobalError component as the final fallback.
+        // When the app router itself fails, which means the framework itself fails, we show the default error.
+        errorComponent: _errorboundary.default,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Router, {
+            actionQueue: actionQueue,
+            assetPrefix: assetPrefix,
+            globalError: [
+                globalErrorComponent,
+                globalErrorStyles
+            ]
+        })
+    });
+}
+const runtimeStyles = new Set();
+let runtimeStyleChanged = new Set();
+globalThis._N_E_STYLE_LOAD = function(href) {
+    let len = runtimeStyles.size;
+    runtimeStyles.add(href);
+    if (runtimeStyles.size !== len) {
+        runtimeStyleChanged.forEach((cb)=>cb());
+    }
+    // TODO figure out how to get a promise here
+    // But maybe it's not necessary as react would block rendering until it's loaded
+    return Promise.resolve();
+};
+function RuntimeStyles() {
+    const [, forceUpdate] = _react.default.useState(0);
+    const renderedStylesSize = runtimeStyles.size;
+    (0, _react.useEffect)(()=>{
+        const changed = ()=>forceUpdate((c)=>c + 1);
+        runtimeStyleChanged.add(changed);
+        if (renderedStylesSize !== runtimeStyles.size) {
+            changed();
+        }
+        return ()=>{
+            runtimeStyleChanged.delete(changed);
+        };
+    }, [
+        renderedStylesSize,
+        forceUpdate
+    ]);
+    const dplId = process.env.NEXT_DEPLOYMENT_ID ? "?dpl=" + process.env.NEXT_DEPLOYMENT_ID : '';
+    return [
+        ...runtimeStyles
+    ].map((href, i)=>/*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
+            rel: "stylesheet",
+            href: "" + href + dplId,
+            // @ts-ignore
+            precedence: "next"
+        }, i));
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=app-router.js.map

frontend/webapp/node_modules/next/dist/client/components/bailout-to-client-rendering.d.ts

@@ -0,0 +1 @@
+export declare function bailoutToClientRendering(reason: string): void | never;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "bailoutToClientRendering", {
+    enumerable: true,
+    get: function() {
+        return bailoutToClientRendering;
+    }
+});
+const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _workasyncstorageexternal = require("../../server/app-render/work-async-storage.external");
+function bailoutToClientRendering(reason) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (workStore == null ? void 0 : workStore.forceStatic) return;
+    if (workStore == null ? void 0 : workStore.isStaticGeneration) throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(reason), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=bailout-to-client-rendering.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/bailout-to-client-rendering.ts"],"sourcesContent":["import { BailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr'\nimport { workAsyncStorage } from '../../server/app-render/work-async-storage.external'\n\nexport function bailoutToClientRendering(reason: string): void | never {\n  const workStore = workAsyncStorage.getStore()\n\n  if (workStore?.forceStatic) return\n\n  if (workStore?.isStaticGeneration) throw new BailoutToCSRError(reason)\n}\n"],"names":["bailoutToClientRendering","reason","workStore","workAsyncStorage","getStore","forceStatic","isStaticGeneration","BailoutToCSRError"],"mappings":";;;;+BAGgBA;;;eAAAA;;;8BAHkB;0CACD;AAE1B,SAASA,yBAAyBC,MAAc;IACrD,MAAMC,YAAYC,0CAAgB,CAACC,QAAQ;IAE3C,IAAIF,6BAAAA,UAAWG,WAAW,EAAE;IAE5B,IAAIH,6BAAAA,UAAWI,kBAAkB,EAAE,MAAM,qBAA6B,CAA7B,IAAIC,+BAAiB,CAACN,SAAtB,qBAAA;eAAA;oBAAA;sBAAA;IAA4B;AACvE"}

frontend/webapp/node_modules/next/dist/client/components/client-page.d.ts

@@ -0,0 +1,16 @@
+import type { ParsedUrlQuery } from 'querystring';
+import type { Params } from '../../server/request/params';
+/**
+ * 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 declare function ClientPageRoot({ Component, searchParams, params, promises, }: {
+    Component: React.ComponentType<any>;
+    searchParams: ParsedUrlQuery;
+    params: Params;
+    promises?: Array<Promise<any>>;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/client-page.js

@@ -0,0 +1,57 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ClientPageRoot", {
+    enumerable: true,
+    get: function() {
+        return ClientPageRoot;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function ClientPageRoot(param) {
+    let { Component, searchParams, params, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    promises } = param;
+    if (typeof window === 'undefined') {
+        const { workAsyncStorage } = require('../../server/app-render/work-async-storage.external');
+        let clientSearchParams;
+        let clientParams;
+        // We are going to instrument the searchParams prop with tracking for the
+        // appropriate context. We wrap differently in prerendering vs rendering
+        const store = workAsyncStorage.getStore();
+        if (!store) {
+            throw Object.defineProperty(new _invarianterror.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__*/ (0, _jsxruntime.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__*/ (0, _jsxruntime.jsx)(Component, {
+            params: clientParams,
+            searchParams: clientSearchParams
+        });
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=client-page.js.map

frontend/webapp/node_modules/next/dist/client/components/client-page.js.map

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

frontend/webapp/node_modules/next/dist/client/components/client-segment.d.ts

@@ -0,0 +1,17 @@
+import type { Params } from '../../server/request/params';
+/**
+ * When the Page is a client component we send the params to this client wrapper
+ * where they are turned into dynamically tracked values before being passed to the actual Segment component.
+ *
+ * additionally we may send a promise representing params. We don't ever use this passed
+ * value but it can be necessary for the sender to send a Promise that doesn't resolve in certain situations
+ * such as when dynamicIO is enabled. It is up to the caller to decide if the promises are needed.
+ */
+export declare function ClientSegmentRoot({ Component, slots, params, promise, }: {
+    Component: React.ComponentType<any>;
+    slots: {
+        [key: string]: React.ReactNode;
+    };
+    params: Params;
+    promise?: Promise<any>;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/client-segment.js

@@ -0,0 +1,52 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ClientSegmentRoot", {
+    enumerable: true,
+    get: function() {
+        return ClientSegmentRoot;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function ClientSegmentRoot(param) {
+    let { Component, slots, params, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    promise } = param;
+    if (typeof window === 'undefined') {
+        const { workAsyncStorage } = require('../../server/app-render/work-async-storage.external');
+        let clientParams;
+        // We are going to instrument the searchParams prop with tracking for the
+        // appropriate context. We wrap differently in prerendering vs rendering
+        const store = workAsyncStorage.getStore();
+        if (!store) {
+            throw Object.defineProperty(new _invarianterror.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__*/ (0, _jsxruntime.jsx)(Component, {
+            ...slots,
+            params: clientParams
+        });
+    } else {
+        const { createRenderParamsFromClient } = require('../request/params.browser');
+        const clientParams = createRenderParamsFromClient(params);
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
+            ...slots,
+            params: clientParams
+        });
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=client-segment.js.map

frontend/webapp/node_modules/next/dist/client/components/client-segment.js.map

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

frontend/webapp/node_modules/next/dist/client/components/default-layout.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export default function DefaultLayout({ children, }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/default-layout.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return DefaultLayout;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+function DefaultLayout(param) {
+    let { children } = param;
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("html", {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)("body", {
+            children: children
+        })
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=default-layout.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/dev-root-http-access-fallback-boundary.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function bailOnRootNotFound(): void;
+export declare function DevRootHTTPAccessFallbackBoundary({ children, }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,53 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DevRootHTTPAccessFallbackBoundary: null,
+    bailOnRootNotFound: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DevRootHTTPAccessFallbackBoundary: function() {
+        return DevRootHTTPAccessFallbackBoundary;
+    },
+    bailOnRootNotFound: function() {
+        return bailOnRootNotFound;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _errorboundary = require("./http-access-fallback/error-boundary");
+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;
+}
+function DevRootHTTPAccessFallbackBoundary(param) {
+    let { children } = param;
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.HTTPAccessFallbackBoundary, {
+        notFound: /*#__PURE__*/ (0, _jsxruntime.jsx)(NotAllowedRootHTTPFallbackError, {}),
+        children: children
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=dev-root-http-access-fallback-boundary.js.map

frontend/webapp/node_modules/next/dist/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":["DevRootHTTPAccessFallbackBoundary","bailOnRootNotFound","Error","NotAllowedRootHTTPFallbackError","children","HTTPAccessFallbackBoundary","notFound"],"mappings":"AAAA;;;;;;;;;;;;;;;;IAegBA,iCAAiC;eAAjCA;;IATAC,kBAAkB;eAAlBA;;;;;gEAJE;+BACyB;AAGpC,SAASA;IACd,MAAM,qBAA4D,CAA5D,IAAIC,MAAM,oDAAV,qBAAA;eAAA;oBAAA;sBAAA;IAA2D;AACnE;AAEA,SAASC;IACPF;IACA,OAAO;AACT;AAEO,SAASD,kCAAkC,KAIjD;IAJiD,IAAA,EAChDI,QAAQ,EAGT,GAJiD;IAKhD,qBACE,qBAACC,yCAA0B;QAACC,wBAAU,qBAACH;kBACpCC;;AAGP"}

frontend/webapp/node_modules/next/dist/client/components/error-boundary.d.ts

@@ -0,0 +1,46 @@
+import React, { type JSX } from 'react';
+export type ErrorComponent = React.ComponentType<{
+    error: Error;
+    reset?: () => void;
+}>;
+export interface ErrorBoundaryProps {
+    children?: React.ReactNode;
+    errorComponent: ErrorComponent | undefined;
+    errorStyles?: React.ReactNode | undefined;
+    errorScripts?: React.ReactNode | undefined;
+}
+interface ErrorBoundaryHandlerProps extends ErrorBoundaryProps {
+    pathname: string | null;
+    errorComponent: ErrorComponent;
+}
+interface ErrorBoundaryHandlerState {
+    error: Error | null;
+    previousPathname: string | null;
+}
+export declare class ErrorBoundaryHandler extends React.Component<ErrorBoundaryHandlerProps, ErrorBoundaryHandlerState> {
+    constructor(props: ErrorBoundaryHandlerProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    static getDerivedStateFromProps(props: ErrorBoundaryHandlerProps, state: ErrorBoundaryHandlerState): ErrorBoundaryHandlerState | null;
+    reset: () => void;
+    render(): React.ReactNode;
+}
+export type GlobalErrorComponent = React.ComponentType<{
+    error: any;
+}>;
+export declare function GlobalError({ error }: {
+    error: any;
+}): import("react/jsx-runtime").JSX.Element;
+export default GlobalError;
+/**
+ * Handles errors through `getDerivedStateFromError`.
+ * Renders the provided error component and provides a way to `reset` the error boundary state.
+ */
+/**
+ * Renders error boundary with the provided "errorComponent" property as the fallback.
+ * If no "errorComponent" property is provided it renders the children without an error boundary.
+ */
+export declare function ErrorBoundary({ errorComponent, errorStyles, errorScripts, children, }: ErrorBoundaryProps & {
+    children: React.ReactNode;
+}): JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/error-boundary.js

@@ -0,0 +1,215 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ErrorBoundary: null,
+    ErrorBoundaryHandler: null,
+    GlobalError: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ErrorBoundary: function() {
+        return ErrorBoundary;
+    },
+    ErrorBoundaryHandler: function() {
+        return ErrorBoundaryHandler;
+    },
+    GlobalError: function() {
+        return GlobalError;
+    },
+    // Exported so that the import signature in the loaders can be identical to user
+    // supplied custom global error signatures.
+    default: function() {
+        return _default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _navigationuntracked = require("./navigation-untracked");
+const _isnextroutererror = require("./is-next-router-error");
+const _navfailurehandler = require("./nav-failure-handler");
+const workAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/work-async-storage.external').workAsyncStorage : undefined;
+const styles = {
+    error: {
+        // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52
+        fontFamily: 'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+        height: '100vh',
+        textAlign: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center'
+    },
+    text: {
+        fontSize: '14px',
+        fontWeight: 400,
+        lineHeight: '28px',
+        margin: '0 8px'
+    }
+};
+// if we are revalidating we want to re-throw the error so the
+// function crashes so we can maintain our previous cache
+// instead of caching the error page
+function HandleISRError(param) {
+    let { error } = param;
+    if (workAsyncStorage) {
+        const store = workAsyncStorage.getStore();
+        if ((store == null ? void 0 : store.isRevalidate) || (store == null ? void 0 : store.isStaticGeneration)) {
+            console.error(error);
+            throw error;
+        }
+    }
+    return null;
+}
+class ErrorBoundaryHandler extends _react.default.Component {
+    static getDerivedStateFromError(error) {
+        if ((0, _isnextroutererror.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 && (0, _navfailurehandler.handleHardNavError)(error)) {
+                // clear error so we don't render anything
+                return {
+                    error: null,
+                    previousPathname: props.pathname
+                };
+            }
+        }
+        /**
+     * Handles reset of the error boundary when a navigation happens.
+     * Ensures the error boundary does not stay enabled when navigating to a new page.
+     * Approach of setState in render is safe as it checks the previous pathname and then overrides
+     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
+     */ if (props.pathname !== state.previousPathname && state.error) {
+            return {
+                error: null,
+                previousPathname: props.pathname
+            };
+        }
+        return {
+            error: state.error,
+            previousPathname: props.pathname
+        };
+    }
+    // Explicit type is needed to avoid the generated `.d.ts` having a wide return type that could be specific to the `@types/react` version.
+    render() {
+        if (this.state.error) {
+            return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleISRError, {
+                        error: this.state.error
+                    }),
+                    this.props.errorStyles,
+                    this.props.errorScripts,
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(this.props.errorComponent, {
+                        error: this.state.error,
+                        reset: this.reset
+                    })
+                ]
+            });
+        }
+        return this.props.children;
+    }
+    constructor(props){
+        super(props), this.reset = ()=>{
+            this.setState({
+                error: null
+            });
+        };
+        this.state = {
+            error: null,
+            previousPathname: this.props.pathname
+        };
+    }
+}
+function GlobalError(param) {
+    let { error } = param;
+    const digest = error == null ? void 0 : error.digest;
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("html", {
+        id: "__next_error__",
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)("head", {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)("body", {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleISRError, {
+                        error: error
+                    }),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                        style: styles.error,
+                        children: /*#__PURE__*/ (0, _jsxruntime.jsxs)("div", {
+                            children: [
+                                /*#__PURE__*/ (0, _jsxruntime.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__*/ (0, _jsxruntime.jsx)("p", {
+                                    style: styles.text,
+                                    children: "Digest: " + digest
+                                }) : null
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+const _default = GlobalError;
+function ErrorBoundary(param) {
+    let { errorComponent, errorStyles, errorScripts, children } = param;
+    // When we're rendering the missing params shell, this will return null. This
+    // is because we won't be rendering any not found boundaries or error
+    // boundaries for the missing params shell. When this runs on the client
+    // (where these errors can occur), we will get the correct pathname.
+    const pathname = (0, _navigationuntracked.useUntrackedPathname)();
+    if (errorComponent) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorBoundaryHandler, {
+            pathname: pathname,
+            errorComponent: errorComponent,
+            errorStyles: errorStyles,
+            errorScripts: errorScripts,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+        children: children
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=error-boundary.js.map

frontend/webapp/node_modules/next/dist/client/components/errors/attach-hydration-error-state.d.ts

@@ -0,0 +1 @@
+export declare function attachHydrationErrorState(error: Error): void;

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

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

frontend/webapp/node_modules/next/dist/client/components/errors/console-error.d.ts

@@ -0,0 +1,11 @@
+declare const digestSym: unique symbol;
+declare const consoleTypeSym: unique symbol;
+export type ConsoleError = Error & {
+    [digestSym]: 'NEXT_CONSOLE_ERROR';
+    [consoleTypeSym]: 'string' | 'error';
+    environmentName: string;
+};
+export declare function createConsoleError(message: string | Error, environmentName?: string | null): ConsoleError;
+export declare const isConsoleError: (error: any) => error is ConsoleError;
+export declare const getConsoleErrorType: (error: ConsoleError) => "string" | "error";
+export {};

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

@@ -0,0 +1,56 @@
+// To distinguish from React error.digest, we use a different symbol here to determine if the error is from console.error or unhandled promise rejection.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createConsoleError: null,
+    getConsoleErrorType: null,
+    isConsoleError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createConsoleError: function() {
+        return createConsoleError;
+    },
+    getConsoleErrorType: function() {
+        return getConsoleErrorType;
+    },
+    isConsoleError: function() {
+        return isConsoleError;
+    }
+});
+const digestSym = Symbol.for('next.console.error.digest');
+const consoleTypeSym = Symbol.for('next.console.error.type');
+function createConsoleError(message, environmentName) {
+    const error = typeof message === 'string' ? Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    }) : message;
+    error[digestSym] = 'NEXT_CONSOLE_ERROR';
+    error[consoleTypeSym] = typeof message === 'string' ? 'string' : 'error';
+    if (environmentName && !error.environmentName) {
+        error.environmentName = environmentName;
+    }
+    return error;
+}
+const isConsoleError = (error)=>{
+    return error && error[digestSym] === 'NEXT_CONSOLE_ERROR';
+};
+const getConsoleErrorType = (error)=>{
+    return error[consoleTypeSym];
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=console-error.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/errors/enqueue-client-error.d.ts

@@ -0,0 +1 @@
+export declare function enqueueConsecutiveDedupedError(queue: Array<Error>, error: Error): void;

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

@@ -0,0 +1,27 @@
+// Dedupe the two consecutive errors: If the previous one is same as current one, ignore the current one.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "enqueueConsecutiveDedupedError", {
+    enumerable: true,
+    get: function() {
+        return enqueueConsecutiveDedupedError;
+    }
+});
+function enqueueConsecutiveDedupedError(queue, error) {
+    const previousError = queue[queue.length - 1];
+    // Compare the error stack to dedupe the consecutive errors
+    if (previousError && previousError.stack === error.stack) {
+        return;
+    }
+    queue.push(error);
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=enqueue-client-error.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/errors/hydration-error-info.d.ts

@@ -0,0 +1,19 @@
+export type HydrationErrorState = {
+    warning?: [string, string, string];
+    serverContent?: string;
+    clientContent?: string;
+    notes?: string;
+    reactOutputComponentDiff?: string;
+};
+type NullableText = string | null | undefined;
+export declare const hydrationErrorState: HydrationErrorState;
+export declare const getHydrationWarningType: (message: NullableText) => "tag" | "text" | "text-in-tag";
+export declare const getReactHydrationDiffSegments: (msg: NullableText) => (string | undefined)[] | undefined;
+/**
+ * Patch console.error to capture hydration errors.
+ * If any of the knownHydrationWarnings are logged, store the message and component stack.
+ * When the hydration runtime error is thrown, the message and component stack are added to the error.
+ * This results in a more helpful error message in the error overlay.
+ */
+export declare function storeHydrationErrorStateFromConsoleArgs(...args: any[]): void;
+export {};

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

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

frontend/webapp/node_modules/next/dist/client/components/errors/runtime-error-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const RuntimeErrorHandler: {
+    hadRuntimeError: boolean;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RuntimeErrorHandler", {
+    enumerable: true,
+    get: function() {
+        return RuntimeErrorHandler;
+    }
+});
+const RuntimeErrorHandler = {
+    hadRuntimeError: false
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=runtime-error-handler.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/errors/stitched-error.d.ts

@@ -0,0 +1 @@
+export declare function getReactStitchedError<T = unknown>(err: T): Error | T;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getReactStitchedError", {
+    enumerable: true,
+    get: function() {
+        return getReactStitchedError;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _iserror = /*#__PURE__*/ _interop_require_default._(require("../../../lib/is-error"));
+const _errortelemetryutils = require("../../../lib/error-telemetry-utils");
+const REACT_ERROR_STACK_BOTTOM_FRAME = 'react-stack-bottom-frame';
+const REACT_ERROR_STACK_BOTTOM_FRAME_REGEX = new RegExp("(at " + REACT_ERROR_STACK_BOTTOM_FRAME + " )|(" + REACT_ERROR_STACK_BOTTOM_FRAME + "\\@)");
+function getReactStitchedError(err) {
+    const isErrorInstance = (0, _iserror.default)(err);
+    const originStack = isErrorInstance ? err.stack || '' : '';
+    const originMessage = isErrorInstance ? err.message : '';
+    const stackLines = originStack.split('\n');
+    const indexOfSplit = stackLines.findIndex((line)=>REACT_ERROR_STACK_BOTTOM_FRAME_REGEX.test(line));
+    const isOriginalReactError = indexOfSplit >= 0 // has the react-stack-bottom-frame
+    ;
+    let newStack = isOriginalReactError ? stackLines.slice(0, indexOfSplit).join('\n') : originStack;
+    const newError = Object.defineProperty(new Error(originMessage), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+    // Copy all enumerable properties, e.g. digest
+    Object.assign(newError, err);
+    (0, _errortelemetryutils.copyNextErrorCode)(err, newError);
+    newError.stack = newStack;
+    // Avoid duplicate overriding stack frames
+    appendOwnerStack(newError);
+    return newError;
+}
+function appendOwnerStack(error) {
+    if (!_react.default.captureOwnerStack) {
+        return;
+    }
+    let stack = error.stack || '';
+    // This module is only bundled in development mode so this is safe.
+    const ownerStack = _react.default.captureOwnerStack();
+    // Avoid duplicate overriding stack frames
+    if (ownerStack && stack.endsWith(ownerStack) === false) {
+        stack += ownerStack;
+        // Override stack
+        error.stack = stack;
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=stitched-error.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/errors/stitched-error.ts"],"sourcesContent":["import React from 'react'\nimport isError from '../../../lib/is-error'\nimport { copyNextErrorCode } from '../../../lib/error-telemetry-utils'\n\nconst REACT_ERROR_STACK_BOTTOM_FRAME = 'react-stack-bottom-frame'\nconst REACT_ERROR_STACK_BOTTOM_FRAME_REGEX = new RegExp(\n  `(at ${REACT_ERROR_STACK_BOTTOM_FRAME} )|(${REACT_ERROR_STACK_BOTTOM_FRAME}\\\\@)`\n)\n\nexport function getReactStitchedError<T = unknown>(err: T): Error | T {\n  const isErrorInstance = isError(err)\n  const originStack = isErrorInstance ? err.stack || '' : ''\n  const originMessage = isErrorInstance ? err.message : ''\n  const stackLines = originStack.split('\\n')\n  const indexOfSplit = stackLines.findIndex((line) =>\n    REACT_ERROR_STACK_BOTTOM_FRAME_REGEX.test(line)\n  )\n  const isOriginalReactError = indexOfSplit >= 0 // has the react-stack-bottom-frame\n  let newStack = isOriginalReactError\n    ? stackLines.slice(0, indexOfSplit).join('\\n')\n    : originStack\n\n  const newError = new Error(originMessage)\n  // Copy all enumerable properties, e.g. digest\n  Object.assign(newError, err)\n  copyNextErrorCode(err, newError)\n  newError.stack = newStack\n\n  // Avoid duplicate overriding stack frames\n  appendOwnerStack(newError)\n\n  return newError\n}\n\nfunction appendOwnerStack(error: Error) {\n  if (!React.captureOwnerStack) {\n    return\n  }\n  let stack = error.stack || ''\n  // This module is only bundled in development mode so this is safe.\n  const ownerStack = React.captureOwnerStack()\n  // Avoid duplicate overriding stack frames\n  if (ownerStack && stack.endsWith(ownerStack) === false) {\n    stack += ownerStack\n    // Override stack\n    error.stack = stack\n  }\n}\n"],"names":["getReactStitchedError","REACT_ERROR_STACK_BOTTOM_FRAME","REACT_ERROR_STACK_BOTTOM_FRAME_REGEX","RegExp","err","isErrorInstance","isError","originStack","stack","originMessage","message","stackLines","split","indexOfSplit","findIndex","line","test","isOriginalReactError","newStack","slice","join","newError","Error","Object","assign","copyNextErrorCode","appendOwnerStack","error","React","captureOwnerStack","ownerStack","endsWith"],"mappings":";;;;+BASgBA;;;eAAAA;;;;gEATE;kEACE;qCACc;AAElC,MAAMC,iCAAiC;AACvC,MAAMC,uCAAuC,IAAIC,OAC/C,AAAC,SAAMF,iCAA+B,SAAMA,iCAA+B;AAGtE,SAASD,sBAAmCI,GAAM;IACvD,MAAMC,kBAAkBC,IAAAA,gBAAO,EAACF;IAChC,MAAMG,cAAcF,kBAAkBD,IAAII,KAAK,IAAI,KAAK;IACxD,MAAMC,gBAAgBJ,kBAAkBD,IAAIM,OAAO,GAAG;IACtD,MAAMC,aAAaJ,YAAYK,KAAK,CAAC;IACrC,MAAMC,eAAeF,WAAWG,SAAS,CAAC,CAACC,OACzCb,qCAAqCc,IAAI,CAACD;IAE5C,MAAME,uBAAuBJ,gBAAgB,EAAE,mCAAmC;;IAClF,IAAIK,WAAWD,uBACXN,WAAWQ,KAAK,CAAC,GAAGN,cAAcO,IAAI,CAAC,QACvCb;IAEJ,MAAMc,WAAW,qBAAwB,CAAxB,IAAIC,MAAMb,gBAAV,qBAAA;eAAA;oBAAA;sBAAA;IAAuB;IACxC,8CAA8C;IAC9Cc,OAAOC,MAAM,CAACH,UAAUjB;IACxBqB,IAAAA,sCAAiB,EAACrB,KAAKiB;IACvBA,SAASb,KAAK,GAAGU;IAEjB,0CAA0C;IAC1CQ,iBAAiBL;IAEjB,OAAOA;AACT;AAEA,SAASK,iBAAiBC,KAAY;IACpC,IAAI,CAACC,cAAK,CAACC,iBAAiB,EAAE;QAC5B;IACF;IACA,IAAIrB,QAAQmB,MAAMnB,KAAK,IAAI;IAC3B,mEAAmE;IACnE,MAAMsB,aAAaF,cAAK,CAACC,iBAAiB;IAC1C,0CAA0C;IAC1C,IAAIC,cAActB,MAAMuB,QAAQ,CAACD,gBAAgB,OAAO;QACtDtB,SAASsB;QACT,iBAAiB;QACjBH,MAAMnB,KAAK,GAAGA;IAChB;AACF"}

frontend/webapp/node_modules/next/dist/client/components/errors/use-error-handler.d.ts

@@ -0,0 +1,5 @@
+export type ErrorHandler = (error: Error) => void;
+export declare function handleConsoleError(originError: unknown, consoleErrorArgs: any[]): void;
+export declare function handleClientError(originError: unknown): void;
+export declare function useErrorHandler(handleOnUnhandledError: ErrorHandler, handleOnUnhandledRejection: ErrorHandler): void;
+export declare function handleGlobalErrors(): void;

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

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

frontend/webapp/node_modules/next/dist/client/components/forbidden-error.d.ts

@@ -0,0 +1 @@
+export default function Forbidden(): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/forbidden-error.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Forbidden;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _errorfallback = require("./http-access-fallback/error-fallback");
+function Forbidden() {
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorfallback.HTTPAccessErrorFallback, {
+        status: 403,
+        message: "This page could not be accessed."
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=forbidden-error.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/components/forbidden-error.tsx"],"sourcesContent":["import { HTTPAccessErrorFallback } from './http-access-fallback/error-fallback'\n\nexport default function Forbidden() {\n  return (\n    <HTTPAccessErrorFallback\n      status={403}\n      message=\"This page could not be accessed.\"\n    />\n  )\n}\n"],"names":["Forbidden","HTTPAccessErrorFallback","status","message"],"mappings":";;;;+BAEA;;;eAAwBA;;;;+BAFgB;AAEzB,SAASA;IACtB,qBACE,qBAACC,sCAAuB;QACtBC,QAAQ;QACRC,SAAQ;;AAGd"}

frontend/webapp/node_modules/next/dist/client/components/forbidden.d.ts

@@ -0,0 +1 @@
+export declare function forbidden(): never;

frontend/webapp/node_modules/next/dist/client/components/forbidden.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "forbidden", {
+    enumerable: true,
+    get: function() {
+        return forbidden;
+    }
+});
+const _httpaccessfallback = require("./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 = "" + _httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE + ";403";
+function forbidden() {
+    if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
+        throw Object.defineProperty(new Error("`forbidden()` is experimental and only allowed to be enabled when `experimental.authInterrupts` is enabled."), "__NEXT_ERROR_CODE", {
+            value: "E488",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // eslint-disable-next-line no-throw-literal
+    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+    error.digest = DIGEST;
+    throw error;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=forbidden.js.map

frontend/webapp/node_modules/next/dist/client/components/forbidden.js.map

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

frontend/webapp/node_modules/next/dist/client/components/globals/handle-global-errors.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _useerrorhandler = require("../errors/use-error-handler");
+(0, _useerrorhandler.handleGlobalErrors)();
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=handle-global-errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/handle-global-errors.ts"],"sourcesContent":["import { handleGlobalErrors } from '../errors/use-error-handler'\n\nhandleGlobalErrors()\n"],"names":["handleGlobalErrors"],"mappings":";;;;iCAAmC;AAEnCA,IAAAA,mCAAkB"}

frontend/webapp/node_modules/next/dist/client/components/globals/intercept-console-error.d.ts

@@ -0,0 +1,5 @@
+export declare const originConsoleError: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+export declare function patchConsoleError(): void;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    originConsoleError: null,
+    patchConsoleError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    originConsoleError: function() {
+        return originConsoleError;
+    },
+    patchConsoleError: function() {
+        return patchConsoleError;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _iserror = /*#__PURE__*/ _interop_require_default._(require("../../../lib/is-error"));
+const _isnextroutererror = require("../is-next-router-error");
+const _useerrorhandler = require("../errors/use-error-handler");
+const _console = require("../../lib/console");
+const originConsoleError = globalThis.console.error;
+function patchConsoleError() {
+    // Ensure it's only patched once
+    if (typeof window === 'undefined') {
+        return;
+    }
+    window.console.error = function error() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        let maybeError;
+        if (process.env.NODE_ENV !== 'production') {
+            const { error: replayedError } = (0, _console.parseConsoleArgs)(args);
+            if (replayedError) {
+                maybeError = replayedError;
+            } else if ((0, _iserror.default)(args[0])) {
+                maybeError = args[0];
+            } else {
+                // See https://github.com/facebook/react/blob/d50323eb845c5fde0d720cae888bf35dedd05506/packages/react-reconciler/src/ReactFiberErrorLogger.js#L78
+                maybeError = args[1];
+            }
+        } else {
+            maybeError = args[0];
+        }
+        if (!(0, _isnextroutererror.isNextRouterError)(maybeError)) {
+            if (process.env.NODE_ENV !== 'production') {
+                (0, _useerrorhandler.handleConsoleError)(// replayed errors have their own complex format string that should be used,
+                // but if we pass the error directly, `handleClientError` will ignore it
+                maybeError, args);
+            }
+            originConsoleError.apply(window.console, args);
+        }
+    };
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=intercept-console-error.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/intercept-console-error.ts"],"sourcesContent":["import isError from '../../../lib/is-error'\nimport { isNextRouterError } from '../is-next-router-error'\nimport { handleConsoleError } from '../errors/use-error-handler'\nimport { parseConsoleArgs } from '../../lib/console'\n\nexport const originConsoleError = globalThis.console.error\n\n// Patch console.error to collect information about hydration errors\nexport function patchConsoleError() {\n  // Ensure it's only patched once\n  if (typeof window === 'undefined') {\n    return\n  }\n  window.console.error = function error(...args: any[]) {\n    let maybeError: unknown\n    if (process.env.NODE_ENV !== 'production') {\n      const { error: replayedError } = parseConsoleArgs(args)\n      if (replayedError) {\n        maybeError = replayedError\n      } else if (isError(args[0])) {\n        maybeError = args[0]\n      } else {\n        // See https://github.com/facebook/react/blob/d50323eb845c5fde0d720cae888bf35dedd05506/packages/react-reconciler/src/ReactFiberErrorLogger.js#L78\n        maybeError = args[1]\n      }\n    } else {\n      maybeError = args[0]\n    }\n\n    if (!isNextRouterError(maybeError)) {\n      if (process.env.NODE_ENV !== 'production') {\n        handleConsoleError(\n          // replayed errors have their own complex format string that should be used,\n          // but if we pass the error directly, `handleClientError` will ignore it\n          maybeError,\n          args\n        )\n      }\n\n      originConsoleError.apply(window.console, args)\n    }\n  }\n}\n"],"names":["originConsoleError","patchConsoleError","globalThis","console","error","window","args","maybeError","process","env","NODE_ENV","replayedError","parseConsoleArgs","isError","isNextRouterError","handleConsoleError","apply"],"mappings":";;;;;;;;;;;;;;;IAKaA,kBAAkB;eAAlBA;;IAGGC,iBAAiB;eAAjBA;;;;kEARI;mCACc;iCACC;yBACF;AAE1B,MAAMD,qBAAqBE,WAAWC,OAAO,CAACC,KAAK;AAGnD,SAASH;IACd,gCAAgC;IAChC,IAAI,OAAOI,WAAW,aAAa;QACjC;IACF;IACAA,OAAOF,OAAO,CAACC,KAAK,GAAG,SAASA;QAAM,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGE,OAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA;YAAGA,KAAH,QAAA,SAAA,CAAA,KAAc;;QAClD,IAAIC;QACJ,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,MAAM,EAAEN,OAAOO,aAAa,EAAE,GAAGC,IAAAA,yBAAgB,EAACN;YAClD,IAAIK,eAAe;gBACjBJ,aAAaI;YACf,OAAO,IAAIE,IAAAA,gBAAO,EAACP,IAAI,CAAC,EAAE,GAAG;gBAC3BC,aAAaD,IAAI,CAAC,EAAE;YACtB,OAAO;gBACL,iJAAiJ;gBACjJC,aAAaD,IAAI,CAAC,EAAE;YACtB;QACF,OAAO;YACLC,aAAaD,IAAI,CAAC,EAAE;QACtB;QAEA,IAAI,CAACQ,IAAAA,oCAAiB,EAACP,aAAa;YAClC,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzCK,IAAAA,mCAAkB,EAChB,4EAA4E;gBAC5E,wEAAwE;gBACxER,YACAD;YAEJ;YAEAN,mBAAmBgB,KAAK,CAACX,OAAOF,OAAO,EAAEG;QAC3C;IACF;AACF"}

frontend/webapp/node_modules/next/dist/client/components/globals/patch-console.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interceptconsoleerror = require("./intercept-console-error");
+(0, _interceptconsoleerror.patchConsoleError)();
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=patch-console.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/components/globals/patch-console.ts"],"sourcesContent":["import { patchConsoleError } from './intercept-console-error'\n\npatchConsoleError()\n"],"names":["patchConsoleError"],"mappings":";;;;uCAAkC;AAElCA,IAAAA,wCAAiB"}

frontend/webapp/node_modules/next/dist/client/components/hooks-server-context.d.ts

@@ -0,0 +1,8 @@
+declare const DYNAMIC_ERROR_CODE = "DYNAMIC_SERVER_USAGE";
+export declare class DynamicServerError extends Error {
+    readonly description: string;
+    digest: typeof DYNAMIC_ERROR_CODE;
+    constructor(description: string);
+}
+export declare function isDynamicServerError(err: unknown): err is DynamicServerError;
+export {};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DynamicServerError: null,
+    isDynamicServerError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DynamicServerError: function() {
+        return DynamicServerError;
+    },
+    isDynamicServerError: function() {
+        return isDynamicServerError;
+    }
+});
+const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
+class DynamicServerError extends Error {
+    constructor(description){
+        super("Dynamic server usage: " + description), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+    }
+}
+function isDynamicServerError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
+        return false;
+    }
+    return err.digest === DYNAMIC_ERROR_CODE;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=hooks-server-context.js.map

frontend/webapp/node_modules/next/dist/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":["DynamicServerError","isDynamicServerError","DYNAMIC_ERROR_CODE","Error","constructor","description","digest","err"],"mappings":";;;;;;;;;;;;;;;IAEaA,kBAAkB;eAAlBA;;IAQGC,oBAAoB;eAApBA;;;AAVhB,MAAMC,qBAAqB;AAEpB,MAAMF,2BAA2BG;IAGtCC,YAAY,AAAgBC,WAAmB,CAAE;QAC/C,KAAK,CAAC,AAAC,2BAAwBA,mBADLA,cAAAA,kBAF5BC,SAAoCJ;IAIpC;AACF;AAEO,SAASD,qBAAqBM,GAAY;IAC/C,IACE,OAAOA,QAAQ,YACfA,QAAQ,QACR,CAAE,CAAA,YAAYA,GAAE,KAChB,OAAOA,IAAID,MAAM,KAAK,UACtB;QACA,OAAO;IACT;IAEA,OAAOC,IAAID,MAAM,KAAKJ;AACxB"}

frontend/webapp/node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 from 'react';
+interface HTTPAccessFallbackBoundaryProps {
+    notFound?: React.ReactNode;
+    forbidden?: React.ReactNode;
+    unauthorized?: React.ReactNode;
+    children: React.ReactNode;
+    missingSlots?: Set<string>;
+}
+export declare function HTTPAccessFallbackBoundary({ notFound, forbidden, unauthorized, children, }: HTTPAccessFallbackBoundaryProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,126 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HTTPAccessFallbackBoundary", {
+    enumerable: true,
+    get: function() {
+        return HTTPAccessFallbackBoundary;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _navigationuntracked = require("../navigation-untracked");
+const _httpaccessfallback = require("./http-access-fallback");
+const _warnonce = require("../../../shared/lib/utils/warn-once");
+const _approutercontextsharedruntime = require("../../../shared/lib/app-router-context.shared-runtime");
+class HTTPAccessFallbackErrorBoundary extends _react.default.Component {
+    componentDidCatch() {
+        if (process.env.NODE_ENV === 'development' && this.props.missingSlots && this.props.missingSlots.size > 0 && // A missing children slot is the typical not-found case, so no need to warn
+        !this.props.missingSlots.has('children')) {
+            let warningMessage = 'No default component was found for a parallel route rendered on this page. Falling back to nearest NotFound boundary.\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/routing/parallel-routes#defaultjs\n\n';
+            const formattedSlots = Array.from(this.props.missingSlots).sort((a, b)=>a.localeCompare(b)).map((slot)=>"@" + slot).join(', ');
+            warningMessage += 'Missing slots: ' + formattedSlots;
+            (0, _warnonce.warnOnce)(warningMessage);
+        }
+    }
+    static getDerivedStateFromError(error) {
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(error)) {
+            const httpStatus = (0, _httpaccessfallback.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 = {
+            [_httpaccessfallback.HTTPAccessErrorStatus.NOT_FOUND]: notFound,
+            [_httpaccessfallback.HTTPAccessErrorStatus.FORBIDDEN]: forbidden,
+            [_httpaccessfallback.HTTPAccessErrorStatus.UNAUTHORIZED]: unauthorized
+        };
+        if (triggeredStatus) {
+            const isNotFound = triggeredStatus === _httpaccessfallback.HTTPAccessErrorStatus.NOT_FOUND && notFound;
+            const isForbidden = triggeredStatus === _httpaccessfallback.HTTPAccessErrorStatus.FORBIDDEN && forbidden;
+            const isUnauthorized = triggeredStatus === _httpaccessfallback.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__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                        name: "robots",
+                        content: "noindex"
+                    }),
+                    process.env.NODE_ENV === 'development' && /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                        name: "boundary-next-error",
+                        content: (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(triggeredStatus)
+                    }),
+                    errorComponents[triggeredStatus]
+                ]
+            });
+        }
+        return children;
+    }
+    constructor(props){
+        super(props);
+        this.state = {
+            triggeredStatus: undefined,
+            previousPathname: props.pathname
+        };
+    }
+}
+function HTTPAccessFallbackBoundary(param) {
+    let { notFound, forbidden, unauthorized, children } = param;
+    // When we're rendering the missing params shell, this will return null. This
+    // is because we won't be rendering any not found boundaries or error
+    // boundaries for the missing params shell. When this runs on the client
+    // (where these error can occur), we will get the correct pathname.
+    const pathname = (0, _navigationuntracked.useUntrackedPathname)();
+    const missingSlots = (0, _react.useContext)(_approutercontextsharedruntime.MissingSlotContext);
+    const hasErrorFallback = !!(notFound || forbidden || unauthorized);
+    if (hasErrorFallback) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(HTTPAccessFallbackErrorBoundary, {
+            pathname: pathname,
+            notFound: notFound,
+            forbidden: forbidden,
+            unauthorized: unauthorized,
+            missingSlots: missingSlots,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+        children: children
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=error-boundary.js.map

frontend/webapp/node_modules/next/dist/client/components/http-access-fallback/error-fallback.d.ts

@@ -0,0 +1,4 @@
+export declare function HTTPAccessErrorFallback({ status, message, }: {
+    status: number;
+    message: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HTTPAccessErrorFallback", {
+    enumerable: true,
+    get: function() {
+        return HTTPAccessErrorFallback;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const styles = {
+    error: {
+        // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52
+        fontFamily: 'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
+        height: '100vh',
+        textAlign: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center'
+    },
+    desc: {
+        display: 'inline-block'
+    },
+    h1: {
+        display: 'inline-block',
+        margin: '0 20px 0 0',
+        padding: '0 23px 0 0',
+        fontSize: 24,
+        fontWeight: 500,
+        verticalAlign: 'top',
+        lineHeight: '49px'
+    },
+    h2: {
+        fontSize: 14,
+        fontWeight: 400,
+        lineHeight: '49px',
+        margin: 0
+    }
+};
+function HTTPAccessErrorFallback(param) {
+    let { status, message } = param;
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)("title", {
+                children: status + ": " + message
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                style: styles.error,
+                children: /*#__PURE__*/ (0, _jsxruntime.jsxs)("div", {
+                    children: [
+                        /*#__PURE__*/ (0, _jsxruntime.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__*/ (0, _jsxruntime.jsx)("h1", {
+                            className: "next-error-h1",
+                            style: styles.h1,
+                            children: status
+                        }),
+                        /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                            style: styles.desc,
+                            children: /*#__PURE__*/ (0, _jsxruntime.jsx)("h2", {
+                                style: styles.h2,
+                                children: message
+                            })
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=error-fallback.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/http-access-fallback/http-access-fallback.d.ts

@@ -0,0 +1,19 @@
+export declare const HTTPAccessErrorStatus: {
+    NOT_FOUND: number;
+    FORBIDDEN: number;
+    UNAUTHORIZED: number;
+};
+export declare const HTTP_ERROR_FALLBACK_ERROR_CODE = "NEXT_HTTP_ERROR_FALLBACK";
+export type HTTPAccessFallbackError = Error & {
+    digest: `${typeof HTTP_ERROR_FALLBACK_ERROR_CODE};${string}`;
+};
+/**
+ * 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 declare function isHTTPAccessFallbackError(error: unknown): error is HTTPAccessFallbackError;
+export declare function getAccessFallbackHTTPStatus(error: HTTPAccessFallbackError): number;
+export declare function getAccessFallbackErrorTypeByStatus(status: number): 'not-found' | 'forbidden' | 'unauthorized' | undefined;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HTTPAccessErrorStatus: null,
+    HTTP_ERROR_FALLBACK_ERROR_CODE: null,
+    getAccessFallbackErrorTypeByStatus: null,
+    getAccessFallbackHTTPStatus: null,
+    isHTTPAccessFallbackError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HTTPAccessErrorStatus: function() {
+        return HTTPAccessErrorStatus;
+    },
+    HTTP_ERROR_FALLBACK_ERROR_CODE: function() {
+        return HTTP_ERROR_FALLBACK_ERROR_CODE;
+    },
+    getAccessFallbackErrorTypeByStatus: function() {
+        return getAccessFallbackErrorTypeByStatus;
+    },
+    getAccessFallbackHTTPStatus: function() {
+        return getAccessFallbackHTTPStatus;
+    },
+    isHTTPAccessFallbackError: function() {
+        return isHTTPAccessFallbackError;
+    }
+});
+const HTTPAccessErrorStatus = {
+    NOT_FOUND: 404,
+    FORBIDDEN: 403,
+    UNAUTHORIZED: 401
+};
+const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
+const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK';
+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));
+}
+function getAccessFallbackHTTPStatus(error) {
+    const httpStatus = error.digest.split(';')[1];
+    return Number(httpStatus);
+}
+function getAccessFallbackErrorTypeByStatus(status) {
+    switch(status){
+        case 401:
+            return 'unauthorized';
+        case 403:
+            return 'forbidden';
+        case 404:
+            return 'not-found';
+        default:
+            return;
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=http-access-fallback.js.map

frontend/webapp/node_modules/next/dist/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","HTTP_ERROR_FALLBACK_ERROR_CODE","getAccessFallbackErrorTypeByStatus","getAccessFallbackHTTPStatus","isHTTPAccessFallbackError","NOT_FOUND","FORBIDDEN","UNAUTHORIZED","ALLOWED_CODES","Set","Object","values","error","digest","prefix","httpStatus","split","has","Number","status"],"mappings":";;;;;;;;;;;;;;;;;;IAAaA,qBAAqB;eAArBA;;IAQAC,8BAA8B;eAA9BA;;IAuCGC,kCAAkC;eAAlCA;;IAPAC,2BAA2B;eAA3BA;;IAnBAC,yBAAyB;eAAzBA;;;AArBT,MAAMJ,wBAAwB;IACnCK,WAAW;IACXC,WAAW;IACXC,cAAc;AAChB;AAEA,MAAMC,gBAAgB,IAAIC,IAAIC,OAAOC,MAAM,CAACX;AAErC,MAAMC,iCAAiC;AAavC,SAASG,0BACdQ,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,WAAWb,kCACXO,cAAcS,GAAG,CAACC,OAAOH;AAE7B;AAEO,SAASZ,4BACdS,KAA8B;IAE9B,MAAMG,aAAaH,MAAMC,MAAM,CAACG,KAAK,CAAC,IAAI,CAAC,EAAE;IAC7C,OAAOE,OAAOH;AAChB;AAEO,SAASb,mCACdiB,MAAc;IAEd,OAAQA;QACN,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT;YACE;IACJ;AACF"}

frontend/webapp/node_modules/next/dist/client/components/is-hydration-error.d.ts

@@ -0,0 +1,11 @@
+export declare const REACT_HYDRATION_ERROR_LINK = "https://react.dev/link/hydration-mismatch";
+export declare const NEXTJS_HYDRATION_ERROR_LINK = "https://nextjs.org/docs/messages/react-hydration-error";
+export declare const getDefaultHydrationErrorMessage: () => string;
+export declare function isHydrationError(error: unknown): boolean;
+export declare function isReactHydrationErrorMessage(msg: string): boolean;
+export declare function testReactHydrationWarning(msg: string): boolean;
+export declare function getHydrationErrorStackInfo(rawMessage: string): {
+    message: string | null;
+    stack?: string;
+    diff?: string;
+};

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

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

frontend/webapp/node_modules/next/dist/client/components/is-next-router-error.d.ts

@@ -0,0 +1,8 @@
+import { type HTTPAccessFallbackError } from './http-access-fallback/http-access-fallback';
+import { type RedirectError } 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 declare function isNextRouterError(error: unknown): error is RedirectError | HTTPAccessFallbackError;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isNextRouterError", {
+    enumerable: true,
+    get: function() {
+        return isNextRouterError;
+    }
+});
+const _httpaccessfallback = require("./http-access-fallback/http-access-fallback");
+const _redirecterror = require("./redirect-error");
+function isNextRouterError(error) {
+    return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error);
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=is-next-router-error.js.map

frontend/webapp/node_modules/next/dist/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":["isNextRouterError","error","isRedirectError","isHTTPAccessFallbackError"],"mappings":";;;;+BAWgBA;;;eAAAA;;;oCART;+BAC6C;AAO7C,SAASA,kBACdC,KAAc;IAEd,OAAOC,IAAAA,8BAAe,EAACD,UAAUE,IAAAA,6CAAyB,EAACF;AAC7D"}

frontend/webapp/node_modules/next/dist/client/components/layout-router.d.ts

@@ -0,0 +1,18 @@
+import type { ErrorComponent } from './error-boundary';
+import React from 'react';
+/**
+ * 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, }: {
+    parallelRouterKey: string;
+    error: ErrorComponent | undefined;
+    errorStyles: React.ReactNode | undefined;
+    errorScripts: React.ReactNode | undefined;
+    templateStyles: React.ReactNode | undefined;
+    templateScripts: React.ReactNode | undefined;
+    template: React.ReactNode;
+    notFound: React.ReactNode | undefined;
+    forbidden: React.ReactNode | undefined;
+    unauthorized: React.ReactNode | undefined;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/layout-router.js

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

frontend/webapp/node_modules/next/dist/client/components/links.d.ts

@@ -0,0 +1,48 @@
+import type { FlightRouterState } from '../../server/app-render/types';
+import type { AppRouterInstance } from '../../shared/lib/app-router-context.shared-runtime';
+import { PrefetchKind } from './router-reducer/router-reducer-types';
+import { type PrefetchTask } from './segment-cache';
+type LinkElement = HTMLAnchorElement | SVGAElement;
+type Element = LinkElement | HTMLFormElement;
+type LinkOrFormInstanceShared = {
+    router: AppRouterInstance;
+    kind: PrefetchKind.AUTO | PrefetchKind.FULL;
+    isVisible: boolean;
+    wasHoveredOrTouched: boolean;
+    prefetchTask: PrefetchTask | null;
+    cacheVersion: number;
+};
+export type FormInstance = LinkOrFormInstanceShared & {
+    prefetchHref: string;
+    setOptimisticLinkStatus: null;
+};
+type PrefetchableLinkInstance = LinkOrFormInstanceShared & {
+    prefetchHref: string;
+    setOptimisticLinkStatus: (status: {
+        pending: boolean;
+    }) => void;
+};
+type NonPrefetchableLinkInstance = LinkOrFormInstanceShared & {
+    prefetchHref: null;
+    setOptimisticLinkStatus: (status: {
+        pending: boolean;
+    }) => void;
+};
+export type LinkInstance = PrefetchableLinkInstance | NonPrefetchableLinkInstance;
+export declare const PENDING_LINK_STATUS: {
+    pending: boolean;
+};
+export declare const IDLE_LINK_STATUS: {
+    pending: boolean;
+};
+export declare function setLinkForCurrentNavigation(link: LinkInstance | null): void;
+export declare function unmountLinkForCurrentNavigation(link: LinkInstance): void;
+export declare function mountLinkInstance(element: LinkElement, href: string, router: AppRouterInstance, kind: PrefetchKind.AUTO | PrefetchKind.FULL, prefetchEnabled: boolean, setOptimisticLinkStatus: (status: {
+    pending: boolean;
+}) => void): LinkInstance;
+export declare function mountFormInstance(element: HTMLFormElement, href: string, router: AppRouterInstance, kind: PrefetchKind.AUTO | PrefetchKind.FULL): void;
+export declare function unmountPrefetchableInstance(element: Element): void;
+export declare function onLinkVisibilityChanged(element: Element, isVisible: boolean): void;
+export declare function onNavigationIntent(element: HTMLAnchorElement | SVGAElement, unstable_upgradeToDynamicPrefetch: boolean): void;
+export declare function pingVisibleLinks(nextUrl: string | null, tree: FlightRouterState): void;
+export {};

frontend/webapp/node_modules/next/dist/client/components/links.js

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

frontend/webapp/node_modules/next/dist/client/components/match-segments.d.ts

@@ -0,0 +1,2 @@
+import type { Segment } from '../../server/app-render/types';
+export declare const matchSegment: (existingSegment: Segment, segment: Segment) => boolean;

frontend/webapp/node_modules/next/dist/client/components/match-segments.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "matchSegment", {
+    enumerable: true,
+    get: function() {
+        return matchSegment;
+    }
+});
+const matchSegment = (existingSegment, segment)=>{
+    // segment is either Array or string
+    if (typeof existingSegment === 'string') {
+        if (typeof segment === 'string') {
+            // Common case: segment is just a string
+            return existingSegment === segment;
+        }
+        return false;
+    }
+    if (typeof segment === 'string') {
+        return false;
+    }
+    return existingSegment[0] === segment[0] && existingSegment[1] === segment[1];
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=match-segments.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/metadata/async-metadata.d.ts

@@ -0,0 +1,5 @@
+import type { StreamingMetadataResolvedState } from './types';
+export declare const AsyncMetadata: typeof import("./browser-resolved-metadata").BrowserResolvedMetadata;
+export declare function AsyncMetadataOutlet({ promise, }: {
+    promise: Promise<StreamingMetadataResolvedState>;
+}): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/components/metadata/async-metadata.js

@@ -0,0 +1,57 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AsyncMetadata: null,
+    AsyncMetadataOutlet: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AsyncMetadata: function() {
+        return AsyncMetadata;
+    },
+    AsyncMetadataOutlet: function() {
+        return AsyncMetadataOutlet;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const AsyncMetadata = typeof window === 'undefined' ? require('./server-inserted-metadata').ServerInsertMetadata : require('./browser-resolved-metadata').BrowserResolvedMetadata;
+function MetadataOutlet(param) {
+    let { promise } = param;
+    const { error, digest } = (0, _react.use)(promise);
+    if (error) {
+        if (digest) {
+            // The error will lose its original digest after passing from server layer to client layer；
+            // We recover the digest property here to override the React created one if original digest exists.
+            ;
+            error.digest = digest;
+        }
+        throw error;
+    }
+    return null;
+}
+function AsyncMetadataOutlet(param) {
+    let { promise } = param;
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
+        fallback: null,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataOutlet, {
+            promise: promise
+        })
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=async-metadata.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/metadata/browser-resolved-metadata.d.ts

@@ -0,0 +1,4 @@
+import type { StreamingMetadataResolvedState } from './types';
+export declare function BrowserResolvedMetadata({ promise, }: {
+    promise: Promise<StreamingMetadataResolvedState>;
+}): import("react").ReactNode;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BrowserResolvedMetadata", {
+    enumerable: true,
+    get: function() {
+        return BrowserResolvedMetadata;
+    }
+});
+const _react = require("react");
+function BrowserResolvedMetadata(param) {
+    let { promise } = param;
+    const { metadata, error } = (0, _react.use)(promise);
+    // If there's metadata error on client, discard the browser metadata
+    // and let metadata outlet deal with the error. This will avoid the duplication metadata.
+    if (error) return null;
+    return metadata;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=browser-resolved-metadata.js.map

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

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

frontend/webapp/node_modules/next/dist/client/components/metadata/metadata-boundary.d.ts

@@ -0,0 +1,9 @@
+export declare const MetadataBoundary: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react").ReactNode;
+export declare const ViewportBoundary: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react").ReactNode;
+export declare const OutletBoundary: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react").ReactNode;