153-5311706f896a8c23.js

js jpg-to-pdf.pro collected 2026-10-02 02:05:40 UTC 275,072 bytes, 6,649 lines download raw bytes

1(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[153],{
2
3/***/ 6754:
4/***/ (function(__unused_webpack_module, exports) {
5
6"use strict";
7
8Object.defineProperty(exports, "__esModule", ({
9    value: true
10}));
11Object.defineProperty(exports, "getDeploymentIdQueryOrEmptyString", ({
12    enumerable: true,
13    get: function() {
14        return getDeploymentIdQueryOrEmptyString;
15    }
16}));
17function getDeploymentIdQueryOrEmptyString() {
18    if (false) {}
19    return "";
20}
21
22//# sourceMappingURL=deployment-id.js.map
23
24/***/ }),
25
26/***/ 6574:
27/***/ (function() {
28
29"trimStart"in String.prototype||(String.prototype.trimStart=String.prototype.trimLeft),"trimEnd"in String.prototype||(String.prototype.trimEnd=String.prototype.trimRight),"description"in Symbol.prototype||Object.defineProperty(Symbol.prototype,"description",{configurable:!0,get:function(){var t=/\((.*)\)/.exec(this.toString());return t?t[1]:void 0}}),Array.prototype.flat||(Array.prototype.flat=function(t,r){return r=this.concat.apply([],this),t>1&&r.some(Array.isArray)?r.flat(t-1):r},Array.prototype.flatMap=function(t,r){return this.map(t,r).flat()}),Promise.prototype.finally||(Promise.prototype.finally=function(t){if("function"!=typeof t)return this.then(t,t);var r=this.constructor||Promise;return this.then(function(n){return r.resolve(t()).then(function(){return n})},function(n){return r.resolve(t()).then(function(){throw n})})}),Object.fromEntries||(Object.fromEntries=function(t){return Array.from(t).reduce(function(t,r){return t[r[0]]=r[1],t},{})}),Array.prototype.at||(Array.prototype.at=function(t){var r=Math.trunc(t)||0;if(r<0&&(r+=this.length),!(r<0||r>=this.length))return this[r]});
30
31
32/***/ }),
33
34/***/ 5733:
35/***/ (function(module, exports, __webpack_require__) {
36
37"use strict";
38
39Object.defineProperty(exports, "__esModule", ({
40    value: true
41}));
42Object.defineProperty(exports, "addBasePath", ({
43    enumerable: true,
44    get: function() {
45        return addBasePath;
46    }
47}));
48const _addpathprefix = __webpack_require__(3952);
49const _normalizetrailingslash = __webpack_require__(9926);
50const basePath =  false || "";
51function addBasePath(path, required) {
52    return (0, _normalizetrailingslash.normalizePathTrailingSlash)( false ? 0 : (0, _addpathprefix.addPathPrefix)(path, basePath));
53}
54if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
55    Object.defineProperty(exports.default, "__esModule", {
56        value: true
57    });
58    Object.assign(exports.default, exports);
59    module.exports = exports.default;
60} //# sourceMappingURL=add-base-path.js.map
61
62
63/***/ }),
64
65/***/ 4808:
66/***/ (function(module, exports) {
67
68"use strict";
69/**
70 * Before starting the Next.js runtime and requiring any module, we need to make
71 * sure the following scripts are executed in the correct order:
72 * - Polyfills
73 * - next/script with `beforeInteractive` strategy
74 */ 
75Object.defineProperty(exports, "__esModule", ({
76    value: true
77}));
78Object.defineProperty(exports, "appBootstrap", ({
79    enumerable: true,
80    get: function() {
81        return appBootstrap;
82    }
83}));
84const version = "14.0.5-canary.17";
85window.next = {
86    version,
87    appDir: true
88};
89function loadScriptsInSequence(scripts, hydrate) {
90    if (!scripts || !scripts.length) {
91        return hydrate();
92    }
93    return scripts.reduce((promise, param)=>{
94        let [src, props] = param;
95        return promise.then(()=>{
96            return new Promise((resolve, reject)=>{
97                const el = document.createElement("script");
98                if (props) {
99                    for(const key in props){
100                        if (key !== "children") {
101                            el.setAttribute(key, props[key]);
102                        }
103                    }
104                }
105                if (src) {
106                    el.src = src;
107                    el.onload = ()=>resolve();
108                    el.onerror = reject;
109                } else if (props) {
110                    el.innerHTML = props.children;
111                    setTimeout(resolve);
112                }
113                document.head.appendChild(el);
114            });
115        });
116    }, Promise.resolve()).catch((err)=>{
117        console.error(err);
118    // Still try to hydrate even if there's an error.
119    }).then(()=>{
120        hydrate();
121    });
122}
123function appBootstrap(callback) {
124    loadScriptsInSequence(self.__next_s, ()=>{
125        callback();
126    });
127}
128if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
129    Object.defineProperty(exports.default, "__esModule", {
130        value: true
131    });

132    Object.assign(exports.default, exports);
133    module.exports = exports.default;
134} //# sourceMappingURL=app-bootstrap.js.map
135
136
137/***/ }),
138
139/***/ 714:
140/***/ (function(module, exports, __webpack_require__) {
141
142"use strict";
143
144Object.defineProperty(exports, "__esModule", ({
145    value: true
146}));
147Object.defineProperty(exports, "callServer", ({
148    enumerable: true,
149    get: function() {
150        return callServer;
151    }
152}));
153const _approuter = __webpack_require__(9985);
154async function callServer(actionId, actionArgs) {
155    const actionDispatcher = (0, _approuter.getServerActionDispatcher)();
156    if (!actionDispatcher) {
157        throw new Error("Invariant: missing action dispatcher.");
158    }
159    return new Promise((resolve, reject)=>{
160        actionDispatcher({
161            actionId,
162            actionArgs,
163            resolve,
164            reject
165        });
166    });
167}
168if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
169    Object.defineProperty(exports.default, "__esModule", {
170        value: true
171    });
172    Object.assign(exports.default, exports);
173    module.exports = exports.default;
174} //# sourceMappingURL=app-call-server.js.map
175
176
177/***/ }),
178
179/***/ 1592:
180/***/ (function(module, exports, __webpack_require__) {
181
182"use strict";
183/* global location */ 
184Object.defineProperty(exports, "__esModule", ({
185    value: true
186}));
187Object.defineProperty(exports, "hydrate", ({
188    enumerable: true,
189    get: function() {
190        return hydrate;
191    }
192}));
193const _interop_require_default = __webpack_require__(7295);
194const _interop_require_wildcard = __webpack_require__(3589);
195const _jsxruntime = __webpack_require__(1411);
196__webpack_require__(6574);
197const _client = /*#__PURE__*/ _interop_require_default._(__webpack_require__(1626));
198const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
199const _client1 = __webpack_require__(5552);
200const _headmanagercontextsharedruntime = __webpack_require__(6061);
201const _approutercontextsharedruntime = __webpack_require__(1214);
202const _onrecoverableerror = /*#__PURE__*/ _interop_require_default._(__webpack_require__(8325));
203const _appcallserver = __webpack_require__(714);
204const _isnextroutererror = __webpack_require__(7884);
205const _actionqueue = __webpack_require__(8811);
206// Since React doesn't call onerror for errors caught in error boundaries.
207const origConsoleError = window.console.error;
208window.console.error = function() {
209    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
210        args[_key] = arguments[_key];
211    }
212    if ((0, _isnextroutererror.isNextRouterError)(args[0])) {
213        return;
214    }
215    origConsoleError.apply(window.console, args);
216};
217window.addEventListener("error", (ev)=>{
218    if ((0, _isnextroutererror.isNextRouterError)(ev.error)) {
219        ev.preventDefault();
220        return;
221    }
222});
223/// <reference types="react-dom/experimental" />
224const appElement = document;
225const getCacheKey = ()=>{
226    const { pathname, search } = location;
227    return pathname + search;
228};
229const encoder = new TextEncoder();
230let initialServerDataBuffer = undefined;
231let initialServerDataWriter = undefined;
232let initialServerDataLoaded = false;
233let initialServerDataFlushed = false;
234let initialFormStateData = null;
235function nextServerDataCallback(seg) {
236    if (seg[0] === 0) {
237        initialServerDataBuffer = [];
238    } else if (seg[0] === 1) {
239        if (!initialServerDataBuffer) throw new Error("Unexpected server data: missing bootstrap script.");
240        if (initialServerDataWriter) {
241            initialServerDataWriter.enqueue(encoder.encode(seg[1]));
242        } else {
243            initialServerDataBuffer.push(seg[1]);
244        }
245    } else if (seg[0] === 2) {
246        initialFormStateData = seg[1];
247    }
248}
249// There might be race conditions between `nextServerDataRegisterWriter` and
250// `DOMContentLoaded`. The former will be called when React starts to hydrate
251// the root, the latter will be called when the DOM is fully loaded.
252// For streaming, the former is called first due to partial hydration.
253// For non-streaming, the latter can be called first.
254// Hence, we use two variables `initialServerDataLoaded` and
255// `initialServerDataFlushed` to make sure the writer will be closed and
256// `initialServerDataBuffer` will be cleared in the right time.
257function nextServerDataRegisterWriter(ctr) {
258    if (initialServerDataBuffer) {
259        initialServerDataBuffer.forEach((val)=>{
260            ctr.enqueue(encoder.encode(val));
261        });
262        if (initialServerDataLoaded && !initialServerDataFlushed) {
263            ctr.close();
264            initialServerDataFlushed = true;
265            initialServerDataBuffer = undefined;
266        }
267    }
268    initialServerDataWriter = ctr;
269}
270// When `DOMContentLoaded`, we can close all pending writers to finish hydration.
271const DOMContentLoaded = function() {
272    if (initialServerDataWriter && !initialServerDataFlushed) {
273        initialServerDataWriter.close();
274        initialServerDataFlushed = true;
275        initialServerDataBuffer = undefined;
276    }
277    initialServerDataLoaded = true;
278};
279// It's possible that the DOM is already loaded.
280if (document.readyState === "loading") {
281    document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
282} else {
283    DOMContentLoaded();
284}
285const nextServerDataLoadingGlobal = self.__next_f = self.__next_f || [];
286nextServerDataLoadingGlobal.forEach(nextServerDataCallback);
287nextServerDataLoadingGlobal.push = nextServerDataCallback;

288function createResponseCache() {
289    return new Map();
290}
291const rscCache = createResponseCache();
292function useInitialServerResponse(cacheKey) {
293    const response = rscCache.get(cacheKey);
294    if (response) return response;
295    const readable = new ReadableStream({
296        start (controller) {
297            nextServerDataRegisterWriter(controller);
298        }
299    });
300    const newResponse = (0, _client1.createFromReadableStream)(readable, {
301        callServer: _appcallserver.callServer
302    });
303    rscCache.set(cacheKey, newResponse);
304    return newResponse;
305}
306function ServerRoot(param) {
307    let { cacheKey } = param;
308    _react.default.useEffect(()=>{
309        rscCache.delete(cacheKey);
310    });
311    const response = useInitialServerResponse(cacheKey);
312    const root = (0, _react.use)(response);
313    return root;
314}
315const StrictModeIfEnabled =  true ? _react.default.StrictMode : 0;
316function Root(param) {
317    let { children } = param;
318    if (false) {}
319    if (false) {}
320    return children;
321}
322function RSCComponent(props) {
323    return /*#__PURE__*/ (0, _jsxruntime.jsx)(ServerRoot, {
324        ...props,
325        cacheKey: getCacheKey()
326    });
327}
328function hydrate() {
329    if (false) {}
330    const actionQueue = (0, _actionqueue.createMutableActionQueue)();
331    const reactEl = /*#__PURE__*/ (0, _jsxruntime.jsx)(StrictModeIfEnabled, {
332        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_headmanagercontextsharedruntime.HeadManagerContext.Provider, {
333            value: {
334                appDir: true
335            },
336            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_actionqueue.ActionQueueContext.Provider, {
337                value: actionQueue,
338                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Root, {
339                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(RSCComponent, {})
340                })
341            })
342        })
343    });
344    const options = {
345        onRecoverableError: _onrecoverableerror.default
346    };
347    const isError = document.documentElement.id === "__next_error__";
348    if (false) {}
349    if (isError) {
350        if (false) {} else {
351            _client.default.createRoot(appElement, options).render(reactEl);
352        }
353    } else {
354        _react.default.startTransition(()=>_client.default.hydrateRoot(appElement, reactEl, {
355                ...options,
356                formState: initialFormStateData
357            }));
358    }
359    // TODO-APP: Remove this logic when Float has GC built-in in development.
360    if (false) {}
361}
362if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
363    Object.defineProperty(exports.default, "__esModule", {
364        value: true
365    });
366    Object.assign(exports.default, exports);
367    module.exports = exports.default;
368} //# sourceMappingURL=app-index.js.map
369
370
371/***/ }),
372
373/***/ 7614:
374/***/ (function(module, exports, __webpack_require__) {
375
376"use strict";

377// This import must go first because it needs to patch webpack chunk loading
378// before React patches chunk loading.
379
380Object.defineProperty(exports, "__esModule", ({
381    value: true
382}));
383__webpack_require__(2434);
384const _appbootstrap = __webpack_require__(4808);
385(0, _appbootstrap.appBootstrap)(()=>{
386    const { hydrate } = __webpack_require__(1592);
387    // Include app-router and layout-router in the main chunk
388    __webpack_require__(9985);
389    __webpack_require__(6273);
390    hydrate();
391});
392if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
393    Object.defineProperty(exports.default, "__esModule", {
394        value: true
395    });
396    Object.assign(exports.default, exports);
397    module.exports = exports.default;
398} //# sourceMappingURL=app-next.js.map
399
400
401/***/ }),
402
403/***/ 2434:
404/***/ (function(module, exports, __webpack_require__) {
405
406"use strict";
407// Override chunk URL mapping in the webpack runtime
408// https://github.com/webpack/webpack/blob/2738eebc7880835d88c727d364ad37f3ec557593/lib/RuntimeGlobals.js#L204
409
410Object.defineProperty(exports, "__esModule", ({
411    value: true
412}));
413const _deploymentid = __webpack_require__(6754);
414// If we have a deployment ID, we need to append it to the webpack chunk names
415// I am keeping the process check explicit so this can be statically optimized
416if (false) {} else {
417    // eslint-disable-next-line no-undef
418    const getChunkScriptFilename = __webpack_require__.u;
419    // eslint-disable-next-line no-undef
420    __webpack_require__.u = function() // filename path.
421    {
422        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
423            args[_key] = arguments[_key];
424        }
425        return encodeURI(getChunkScriptFilename(...args));
426    };
427// We don't need to override __webpack_require__.k because we don't modify
428// the css chunk name when not using deployment id suffixes
429// WE don't need to override __webpack_require__.miniCssF because we don't modify
430// the mini css chunk name when not using deployment id suffixes
431}
432if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
433    Object.defineProperty(exports.default, "__esModule", {
434        value: true
435    });
436    Object.assign(exports.default, exports);
437    module.exports = exports.default;
438} //# sourceMappingURL=app-webpack.js.map
439
440
441/***/ }),
442
443/***/ 1828:
444/***/ (function(module, exports, __webpack_require__) {
445
446"use strict";
447
448Object.defineProperty(exports, "__esModule", ({
449    value: true
450}));
451Object.defineProperty(exports, "actionAsyncStorage", ({
452    enumerable: true,
453    get: function() {
454        return actionAsyncStorage;
455    }
456}));
457const _asynclocalstorage = __webpack_require__(2532);
458const actionAsyncStorage = (0, _asynclocalstorage.createAsyncLocalStorage)();
459if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
460    Object.defineProperty(exports.default, "__esModule", {
461        value: true
462    });
463    Object.assign(exports.default, exports);
464    module.exports = exports.default;
465} //# sourceMappingURL=action-async-storage.external.js.map
466
467
468/***/ }),
469
470/***/ 3611:
471/***/ (function(module, exports, __webpack_require__) {
472
473"use strict";
474
475Object.defineProperty(exports, "__esModule", ({
476    value: true
477}));
478Object.defineProperty(exports, "AppRouterAnnouncer", ({
479    enumerable: true,
480    get: function() {
481        return AppRouterAnnouncer;
482    }
483}));
484const _react = __webpack_require__(9988);
485const _reactdom = __webpack_require__(7897);
486const ANNOUNCER_TYPE = "next-route-announcer";
487const ANNOUNCER_ID = "__next-route-announcer__";
488function getAnnouncerNode() {
489    var _existingAnnouncer_shadowRoot;
490    const existingAnnouncer = document.getElementsByName(ANNOUNCER_TYPE)[0];
491    if (existingAnnouncer == null ? void 0 : (_existingAnnouncer_shadowRoot = existingAnnouncer.shadowRoot) == null ? void 0 : _existingAnnouncer_shadowRoot.childNodes[0]) {
492        return existingAnnouncer.shadowRoot.childNodes[0];
493    } else {
494        const container = document.createElement(ANNOUNCER_TYPE);
495        container.style.cssText = "position:absolute";
496        const announcer = document.createElement("div");
497        announcer.ariaLive = "assertive";
498        announcer.id = ANNOUNCER_ID;
499        announcer.role = "alert";
500        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";
501        // Use shadow DOM here to avoid any potential CSS bleed
502        const shadow = container.attachShadow({
503            mode: "open"
504        });
505        shadow.appendChild(announcer);
506        document.body.appendChild(container);
507        return announcer;
508    }
509}
510function AppRouterAnnouncer(param) {
511    let { tree } = param;
512    const [portalNode, setPortalNode] = (0, _react.useState)(null);
513    (0, _react.useEffect)(()=>{
514        const announcer = getAnnouncerNode();
515        setPortalNode(announcer);
516        return ()=>{
517            const container = document.getElementsByTagName(ANNOUNCER_TYPE)[0];
518            if (container == null ? void 0 : container.isConnected) {
519                document.body.removeChild(container);
520            }
521        };
522    }, []);
523    const [routeAnnouncement, setRouteAnnouncement] = (0, _react.useState)("");
524    const previousTitle = (0, _react.useRef)();
525    (0, _react.useEffect)(()=>{
526        let currentTitle = "";
527        if (document.title) {
528            currentTitle = document.title;
529        } else {
530            const pageHeader = document.querySelector("h1");
531            if (pageHeader) {
532                currentTitle = pageHeader.innerText || pageHeader.textContent || "";
533            }
534        }
535        // Only announce the title change, but not for the first load because screen
536        // readers do that automatically.
537        if (previousTitle.current !== undefined && previousTitle.current !== currentTitle) {
538            setRouteAnnouncement(currentTitle);
539        }
540        previousTitle.current = currentTitle;
541    }, [
542        tree
543    ]);
544    return portalNode ? /*#__PURE__*/ (0, _reactdom.createPortal)(routeAnnouncement, portalNode) : null;
545}
546if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
547    Object.defineProperty(exports.default, "__esModule", {
548        value: true
549    });

550    Object.assign(exports.default, exports);
551    module.exports = exports.default;
552} //# sourceMappingURL=app-router-announcer.js.map
553
554
555/***/ }),
556
557/***/ 5767:
558/***/ (function(module, exports) {
559
560"use strict";
561
562Object.defineProperty(exports, "__esModule", ({
563    value: true
564}));
5650 && (0);
566function _export(target, all) {
567    for(var name in all)Object.defineProperty(target, name, {
568        enumerable: true,
569        get: all[name]
570    });
571}
572_export(exports, {
573    RSC_HEADER: function() {
574        return RSC_HEADER;
575    },
576    ACTION: function() {
577        return ACTION;
578    },
579    NEXT_ROUTER_STATE_TREE: function() {
580        return NEXT_ROUTER_STATE_TREE;
581    },
582    NEXT_ROUTER_PREFETCH_HEADER: function() {
583        return NEXT_ROUTER_PREFETCH_HEADER;
584    },
585    NEXT_URL: function() {
586        return NEXT_URL;
587    },
588    RSC_CONTENT_TYPE_HEADER: function() {
589        return RSC_CONTENT_TYPE_HEADER;
590    },
591    RSC_VARY_HEADER: function() {
592        return RSC_VARY_HEADER;
593    },
594    FLIGHT_PARAMETERS: function() {
595        return FLIGHT_PARAMETERS;
596    },
597    NEXT_RSC_UNION_QUERY: function() {
598        return NEXT_RSC_UNION_QUERY;
599    },
600    NEXT_DID_POSTPONE_HEADER: function() {
601        return NEXT_DID_POSTPONE_HEADER;
602    }
603});
604const RSC_HEADER = "RSC";
605const ACTION = "Next-Action";
606const NEXT_ROUTER_STATE_TREE = "Next-Router-State-Tree";
607const NEXT_ROUTER_PREFETCH_HEADER = "Next-Router-Prefetch";
608const NEXT_URL = "Next-Url";
609const RSC_CONTENT_TYPE_HEADER = "text/x-component";
610const RSC_VARY_HEADER = RSC_HEADER + ", " + NEXT_ROUTER_STATE_TREE + ", " + NEXT_ROUTER_PREFETCH_HEADER + ", " + NEXT_URL;
611const FLIGHT_PARAMETERS = [
612    [
613        RSC_HEADER
614    ],
615    [
616        NEXT_ROUTER_STATE_TREE
617    ],
618    [
619        NEXT_ROUTER_PREFETCH_HEADER
620    ]
621];
622const NEXT_RSC_UNION_QUERY = "_rsc";
623const NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
624if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
625    Object.defineProperty(exports.default, "__esModule", {
626        value: true
627    });
628    Object.assign(exports.default, exports);
629    module.exports = exports.default;
630} //# sourceMappingURL=app-router-headers.js.map
631
632
633/***/ }),
634
635/***/ 9985:
636/***/ (function(module, exports, __webpack_require__) {
637
638"use strict";
639/* __next_internal_client_entry_do_not_use__  cjs */ 
640Object.defineProperty(exports, "__esModule", ({
641    value: true
642}));
6430 && (0);
644function _export(target, all) {
645    for(var name in all)Object.defineProperty(target, name, {
646        enumerable: true,
647        get: all[name]
648    });
649}
650_export(exports, {
651    getServerActionDispatcher: function() {
652        return getServerActionDispatcher;
653    },
654    urlToUrlWithoutFlightMarker: function() {
655        return urlToUrlWithoutFlightMarker;
656    },
657    createEmptyCacheNode: function() {
658        return createEmptyCacheNode;
659    },
660    default: function() {
661        return AppRouter;
662    }
663});
664const _interop_require_wildcard = __webpack_require__(3589);
665const _jsxruntime = __webpack_require__(1411);
666const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
667const _approutercontextsharedruntime = __webpack_require__(1214);
668const _routerreducertypes = __webpack_require__(1606);
669const _createhreffromurl = __webpack_require__(6690);
670const _hooksclientcontextsharedruntime = __webpack_require__(8581);
671const _usereducerwithdevtools = __webpack_require__(766);
672const _errorboundary = __webpack_require__(9697);
673const _createinitialrouterstate = __webpack_require__(8661);
674const _isbot = __webpack_require__(1778);
675const _addbasepath = __webpack_require__(5733);
676const _approuterannouncer = __webpack_require__(3611);
677const _redirectboundary = __webpack_require__(5813);
678const _findheadincache = __webpack_require__(8521);
679const _infinitepromise = __webpack_require__(6639);
680const _approuterheaders = __webpack_require__(5767);
681const _removebasepath = __webpack_require__(657);
682const _hasbasepath = __webpack_require__(1152);
683const isServer = "object" === "undefined";
684// Ensure the initialParallelRoutes are not combined because of double-rendering in the browser with Strict Mode.
685let initialParallelRoutes = isServer ? null : new Map();
686let globalServerActionDispatcher = null;
687function getServerActionDispatcher() {
688    return globalServerActionDispatcher;
689}
690const globalMutable = {};
691function urlToUrlWithoutFlightMarker(url) {
692    const urlWithoutFlightParameters = new URL(url, location.origin);
693    urlWithoutFlightParameters.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
694    if (true) {
695        if (false) {}
696    }
697    return urlWithoutFlightParameters;
698}
699function isExternalURL(url) {
700    return url.origin !== window.location.origin;
701}
702function HistoryUpdater(param) {
703    let { appRouterState, sync } = param;
704    (0, _react.useInsertionEffect)(()=>{
705        const { tree, pushRef, canonicalUrl } = appRouterState;
706        const historyState = {
707            ... false ? 0 : {},
708            // Identifier is shortened intentionally.
709            // __NA is used to identify if the history entry can be handled by the app-router.
710            // __N is used to identify if the history entry can be handled by the old router.
711            __NA: true,
712            __PRIVATE_NEXTJS_INTERNALS_TREE: tree
713        };
714        if (pushRef.pendingPush && // Skip pushing an additional history entry if the canonicalUrl is the same as the current url.
715        // This mirrors the browser behavior for normal navigation.
716        (0, _createhreffromurl.createHrefFromUrl)(new URL(window.location.href)) !== canonicalUrl) {
717            // This intentionally mutates React state, pushRef is overwritten to ensure additional push/replace calls do not trigger an additional history entry.
718            pushRef.pendingPush = false;

719            window.history.pushState(historyState, "", canonicalUrl);
720        } else {
721            window.history.replaceState(historyState, "", canonicalUrl);
722        }
723        sync(appRouterState);
724    }, [
725        appRouterState,
726        sync
727    ]);
728    return null;
729}
730function createEmptyCacheNode() {
731    return {
732        lazyData: null,
733        rsc: null,
734        prefetchRsc: null,
735        parallelRoutes: new Map()
736    };
737}
738function useServerActionDispatcher(dispatch) {
739    const serverActionDispatcher = (0, _react.useCallback)((actionPayload)=>{
740        (0, _react.startTransition)(()=>{
741            dispatch({
742                ...actionPayload,
743                type: _routerreducertypes.ACTION_SERVER_ACTION
744            });
745        });
746    }, [
747        dispatch
748    ]);
749    globalServerActionDispatcher = serverActionDispatcher;
750}
751/**
752 * Server response that only patches the cache and tree.
753 */ function useChangeByServerResponse(dispatch) {
754    return (0, _react.useCallback)((previousTree, flightData, overrideCanonicalUrl)=>{
755        (0, _react.startTransition)(()=>{
756            dispatch({
757                type: _routerreducertypes.ACTION_SERVER_PATCH,
758                flightData,
759                previousTree,
760                overrideCanonicalUrl
761            });
762        });
763    }, [
764        dispatch
765    ]);
766}
767function useNavigate(dispatch) {
768    return (0, _react.useCallback)((href, navigateType, shouldScroll)=>{
769        const url = new URL((0, _addbasepath.addBasePath)(href), location.href);
770        return dispatch({
771            type: _routerreducertypes.ACTION_NAVIGATE,
772            url,
773            isExternalUrl: isExternalURL(url),
774            locationSearch: location.search,
775            shouldScroll: shouldScroll != null ? shouldScroll : true,
776            navigateType
777        });
778    }, [
779        dispatch
780    ]);
781}
782function copyNextJsInternalHistoryState(data) {
783    if (data == null) data = {};
784    const currentState = window.history.state;
785    const __NA = currentState == null ? void 0 : currentState.__NA;
786    if (__NA) {
787        data.__NA = __NA;
788    }
789    const __PRIVATE_NEXTJS_INTERNALS_TREE = currentState == null ? void 0 : currentState.__PRIVATE_NEXTJS_INTERNALS_TREE;
790    if (__PRIVATE_NEXTJS_INTERNALS_TREE) {
791        data.__PRIVATE_NEXTJS_INTERNALS_TREE = __PRIVATE_NEXTJS_INTERNALS_TREE;
792    }
793    return data;
794}
795/**
796 * The global router that wraps the application components.
797 */ function Router(param) {
798    let { buildId, initialHead, initialTree, initialCanonicalUrl, initialSeedData, assetPrefix } = param;
799    const initialState = (0, _react.useMemo)(()=>(0, _createinitialrouterstate.createInitialRouterState)({
800            buildId,
801            initialSeedData,
802            initialCanonicalUrl,
803            initialTree,
804            initialParallelRoutes,
805            isServer,
806            location: !isServer ? window.location : null,
807            initialHead
808        }), [
809        buildId,
810        initialSeedData,
811        initialCanonicalUrl,
812        initialTree,
813        initialHead
814    ]);
815    const [reducerState, dispatch, sync] = (0, _usereducerwithdevtools.useReducerWithReduxDevtools)(initialState);
816    (0, _react.useEffect)(()=>{
817        // Ensure initialParallelRoutes is cleaned up from memory once it's used.
818        initialParallelRoutes = null;
819    }, []);
820    const { canonicalUrl } = (0, _usereducerwithdevtools.useUnwrapState)(reducerState);
821    // Add memoized pathname/query for useSearchParams and usePathname.
822    const { searchParams, pathname } = (0, _react.useMemo)(()=>{
823        const url = new URL(canonicalUrl,  false ? 0 : window.location.href);
824        return {
825            // This is turned into a readonly class in `useSearchParams`
826            searchParams: url.searchParams,
827            pathname: (0, _hasbasepath.hasBasePath)(url.pathname) ? (0, _removebasepath.removeBasePath)(url.pathname) : url.pathname
828        };
829    }, [
830        canonicalUrl
831    ]);
832    const changeByServerResponse = useChangeByServerResponse(dispatch);
833    const navigate = useNavigate(dispatch);
834    useServerActionDispatcher(dispatch);
835    /**
836   * The app router that is exposed through `useRouter`. It's only concerned with dispatching actions to the reducer, does not hold state.
837   */ const appRouter = (0, _react.useMemo)(()=>{
838        const routerInstance = {
839            back: ()=>window.history.back(),
840            forward: ()=>window.history.forward(),
841            prefetch: (href, options)=>{
842                // Don't prefetch for bots as they don't navigate.
843                // Don't prefetch during development (improves compilation performance)
844                if ((0, _isbot.isBot)(window.navigator.userAgent) || "production" === "development") {
845                    return;
846                }
847                const url = new URL((0, _addbasepath.addBasePath)(href), window.location.href);
848                // External urls can't be prefetched in the same way.
849                if (isExternalURL(url)) {
850                    return;
851                }
852                (0, _react.startTransition)(()=>{
853                    var _options_kind;
854                    dispatch({
855                        type: _routerreducertypes.ACTION_PREFETCH,
856                        url,
857                        kind: (_options_kind = options == null ? void 0 : options.kind) != null ? _options_kind : _routerreducertypes.PrefetchKind.FULL
858                    });
859                });
860            },
861            replace: (href, options)=>{
862                if (options === void 0) options = {};
863                (0, _react.startTransition)(()=>{
864                    var _options_scroll;
865                    navigate(href, "replace", (_options_scroll = options.scroll) != null ? _options_scroll : true);
866                });
867            },
868            push: (href, options)=>{
869                if (options === void 0) options = {};
870                (0, _react.startTransition)(()=>{
871                    var _options_scroll;
872                    navigate(href, "push", (_options_scroll = options.scroll) != null ? _options_scroll : true);
873                });
874            },
875            refresh: ()=>{
876                (0, _react.startTransition)(()=>{
877                    dispatch({
878                        type: _routerreducertypes.ACTION_REFRESH,
879                        origin: window.location.origin
880                    });
881                });
882            },
883            // @ts-ignore we don't want to expose this method at all
884            fastRefresh: ()=>{
885                if (true) {
886                    throw new Error("fastRefresh can only be used in development mode. Please use refresh instead.");
887                } else {}
888            }
889        };
890        return routerInstance;
891    }, [
892        dispatch,
893        navigate
894    ]);
895    (0, _react.useEffect)(()=>{
896        // Exists for debugging purposes. Don't use in application code.
897        if (window.next) {
898            window.next.router = appRouter;
899        }
900    }, [
901        appRouter
902    ]);
903    if (false) {}
904    (0, _react.useEffect)(()=>{
905        // If the app is restored from bfcache, it's possible that
906        // pushRef.mpaNavigation is true, which would mean that any re-render of this component
907        // would trigger the mpa navigation logic again from the lines below.
908        // This will restore the router to the initial state in the event that the app is restored from bfcache.
909        function handlePageShow(event) {
910            var _window_history_state;
911            if (!event.persisted || !((_window_history_state = window.history.state) == null ? void 0 : _window_history_state.__PRIVATE_NEXTJS_INTERNALS_TREE)) {
912                return;
913            }
914            dispatch({
915                type: _routerreducertypes.ACTION_RESTORE,
916                url: new URL(window.location.href),
917                tree: window.history.state.__PRIVATE_NEXTJS_INTERNALS_TREE
918            });
919        }
920        window.addEventListener("pageshow", handlePageShow);
921        return ()=>{
922            window.removeEventListener("pageshow", handlePageShow);
923        };
924    }, [
925        dispatch
926    ]);
927    // When mpaNavigation flag is set do a hard navigation to the new url.
928    // Infinitely suspend because we don't actually want to rerender any child
929    // components with the new URL and any entangled state updates shouldn't
930    // commit either (eg: useTransition isPending should stay true until the page
931    // unloads).
932    //
933    // This is a side effect in render. Don't try this at home, kids. It's
934    // probably safe because we know this is a singleton component and it's never
935    // in <Offscreen>. At least I hope so. (It will run twice in dev strict mode,
936    // but that's... fine?)
937    const { pushRef } = (0, _usereducerwithdevtools.useUnwrapState)(reducerState);
938    if (pushRef.mpaNavigation) {
939        // if there's a re-render, we don't want to trigger another redirect if one is already in flight to the same URL
940        if (globalMutable.pendingMpaPath !== canonicalUrl) {
941            const location1 = window.location;
942            if (pushRef.pendingPush) {
943                location1.assign(canonicalUrl);
944            } else {
945                location1.replace(canonicalUrl);
946            }
947            globalMutable.pendingMpaPath = canonicalUrl;
948        }
949        // TODO-APP: Should we listen to navigateerror here to catch failed
950        // navigations somehow? And should we call window.stop() if a SPA navigation
951        // should interrupt an MPA one?
952        (0, _react.use)((0, _infinitepromise.createInfinitePromise)());
953    }
954    (0, _react.useEffect)(()=>{
955        const originalPushState = window.history.pushState.bind(window.history);
956        const originalReplaceState = window.history.replaceState.bind(window.history);
957        if (false) {}
958        /**
959     * Handle popstate event, this is used to handle back/forward in the browser.
960     * By default dispatches ACTION_RESTORE, however if the history entry was not pushed/replaced by app-router it will reload the page.
961     * That case can happen when the old router injected the history entry.
962     */ const onPopState = (param)=>{
963            let { state } = param;
964            if (!state) {
965                // TODO-APP: this case only happens when pushState/replaceState was called outside of Next.js. It should probably reload the page in this case.
966                return;
967            }
968            // This case happens when the history entry was pushed by the `pages` router.
969            if (!state.__NA) {
970                window.location.reload();
971                return;
972            }
973            // @ts-ignore useTransition exists
974            // TODO-APP: Ideally the back button should not use startTransition as it should apply the updates synchronously

975            // Without startTransition works if the cache is there for this path
976            (0, _react.startTransition)(()=>{
977                dispatch({
978                    type: _routerreducertypes.ACTION_RESTORE,
979                    url: new URL(window.location.href),
980                    tree: state.__PRIVATE_NEXTJS_INTERNALS_TREE
981                });
982            });
983        };
984        // Register popstate event to call onPopstate.
985        window.addEventListener("popstate", onPopState);
986        return ()=>{
987            if (false) {}
988            window.removeEventListener("popstate", onPopState);
989        };
990    }, [
991        dispatch
992    ]);
993    const { cache, tree, nextUrl, focusAndScrollRef } = (0, _usereducerwithdevtools.useUnwrapState)(reducerState);
994    const head = (0, _react.useMemo)(()=>{
995        return (0, _findheadincache.findHeadInCache)(cache, tree[1]);
996    }, [
997        cache,
998        tree
999    ]);
1000    let content = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_redirectboundary.RedirectBoundary, {
1001        children: [
1002            head,
1003            cache.rsc,
1004            /*#__PURE__*/ (0, _jsxruntime.jsx)(_approuterannouncer.AppRouterAnnouncer, {
1005                tree: tree
1006            })
1007        ]
1008    });
1009    if (false) {}
1010    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
1011        children: [
1012            /*#__PURE__*/ (0, _jsxruntime.jsx)(HistoryUpdater, {
1013                appRouterState: (0, _usereducerwithdevtools.useUnwrapState)(reducerState),
1014                sync: sync
1015            }),
1016            /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.PathnameContext.Provider, {
1017                value: pathname,
1018                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.SearchParamsContext.Provider, {
1019                    value: searchParams,
1020                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.GlobalLayoutRouterContext.Provider, {
1021                        value: {
1022                            buildId,
1023                            changeByServerResponse,
1024                            tree,
1025                            focusAndScrollRef,
1026                            nextUrl
1027                        },
1028                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.AppRouterContext.Provider, {
1029                            value: appRouter,
1030                            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
1031                                value: {
1032                                    childNodes: cache.parallelRoutes,
1033                                    tree,
1034                                    // Root node always has `url`
1035                                    // Provided in AppTreeContext to ensure it can be overwritten in layout-router
1036                                    url: canonicalUrl
1037                                },
1038                                children: content
1039                            })
1040                        })
1041                    })
1042                })
1043            })
1044        ]
1045    });
1046}
1047function AppRouter(props) {
1048    const { globalErrorComponent, ...rest } = props;
1049    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
1050        errorComponent: globalErrorComponent,
1051        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Router, {
1052            ...rest
1053        })
1054    });
1055}
1056if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1057    Object.defineProperty(exports.default, "__esModule", {
1058        value: true
1059    });
1060    Object.assign(exports.default, exports);
1061    module.exports = exports.default;
1062} //# sourceMappingURL=app-router.js.map
1063
1064
1065/***/ }),
1066
1067/***/ 363:
1068/***/ (function(module, exports, __webpack_require__) {
1069
1070"use strict";
1071
1072Object.defineProperty(exports, "__esModule", ({
1073    value: true
1074}));
1075Object.defineProperty(exports, "clientHookInServerComponentError", ({
1076    enumerable: true,
1077    get: function() {
1078        return clientHookInServerComponentError;
1079    }
1080}));
1081const _interop_require_default = __webpack_require__(7295);
1082const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
1083function clientHookInServerComponentError(hookName) {
1084    if (false) {}
1085}
1086if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1087    Object.defineProperty(exports.default, "__esModule", {
1088        value: true
1089    });

1090    Object.assign(exports.default, exports);
1091    module.exports = exports.default;
1092} //# sourceMappingURL=client-hook-in-server-component-error.js.map
1093
1094
1095/***/ }),
1096
1097/***/ 9697:
1098/***/ (function(module, exports, __webpack_require__) {
1099
1100"use strict";
1101/* __next_internal_client_entry_do_not_use__  cjs */ 
1102Object.defineProperty(exports, "__esModule", ({
1103    value: true
1104}));
11050 && (0);
1106function _export(target, all) {
1107    for(var name in all)Object.defineProperty(target, name, {
1108        enumerable: true,
1109        get: all[name]
1110    });
1111}
1112_export(exports, {
1113    ErrorBoundaryHandler: function() {
1114        return ErrorBoundaryHandler;
1115    },
1116    GlobalError: function() {
1117        return GlobalError;
1118    },
1119    // Exported so that the import signature in the loaders can be identical to user
1120    // supplied custom global error signatures.
1121    default: function() {
1122        return _default;
1123    },
1124    ErrorBoundary: function() {
1125        return ErrorBoundary;
1126    }
1127});
1128const _interop_require_default = __webpack_require__(7295);
1129const _jsxruntime = __webpack_require__(1411);
1130const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
1131const _navigation = __webpack_require__(9960);
1132const styles = {
1133    error: {
1134        // https://github.com/sindresorhus/modern-normalize/blob/main/modern-normalize.css#L38-L52
1135        fontFamily: 'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
1136        height: "100vh",
1137        textAlign: "center",
1138        display: "flex",
1139        flexDirection: "column",
1140        alignItems: "center",
1141        justifyContent: "center"
1142    },
1143    text: {
1144        fontSize: "14px",
1145        fontWeight: 400,
1146        lineHeight: "28px",
1147        margin: "0 8px"
1148    }
1149};
1150// if we are revalidating we want to re-throw the error so the
1151// function crashes so we can maintain our previous cache
1152// instead of caching the error page
1153function HandleISRError(param) {
1154    let { error } = param;
1155    if (typeof fetch.__nextGetStaticStore === "function") {
1156        var _fetch___nextGetStaticStore;
1157        const store = (_fetch___nextGetStaticStore = fetch.__nextGetStaticStore()) == null ? void 0 : _fetch___nextGetStaticStore.getStore();
1158        if ((store == null ? void 0 : store.isRevalidate) || (store == null ? void 0 : store.isStaticGeneration)) {
1159            console.error(error);
1160            throw error;
1161        }
1162    }
1163    return null;
1164}
1165class ErrorBoundaryHandler extends _react.default.Component {
1166    static getDerivedStateFromError(error) {
1167        return {
1168            error
1169        };
1170    }
1171    static getDerivedStateFromProps(props, state) {
1172        /**
1173     * Handles reset of the error boundary when a navigation happens.
1174     * Ensures the error boundary does not stay enabled when navigating to a new page.
1175     * Approach of setState in render is safe as it checks the previous pathname and then overrides
1176     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
1177     */ if (props.pathname !== state.previousPathname && state.error) {
1178            return {
1179                error: null,
1180                previousPathname: props.pathname
1181            };
1182        }
1183        return {
1184            error: state.error,
1185            previousPathname: props.pathname
1186        };
1187    }
1188    render() {
1189        if (this.state.error) {
1190            return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
1191                children: [
1192                    /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleISRError, {
1193                        error: this.state.error
1194                    }),
1195                    this.props.errorStyles,
1196                    this.props.errorScripts,
1197                    /*#__PURE__*/ (0, _jsxruntime.jsx)(this.props.errorComponent, {
1198                        error: this.state.error,
1199                        reset: this.reset
1200                    })
1201                ]
1202            });
1203        }
1204        return this.props.children;
1205    }
1206    constructor(props){
1207        super(props);
1208        this.reset = ()=>{
1209            this.setState({
1210                error: null
1211            });
1212        };
1213        this.state = {
1214            error: null,
1215            previousPathname: this.props.pathname
1216        };
1217    }
1218}
1219function GlobalError(param) {
1220    let { error } = param;
1221    const digest = error == null ? void 0 : error.digest;
1222    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("html", {
1223        id: "__next_error__",
1224        children: [
1225            /*#__PURE__*/ (0, _jsxruntime.jsx)("head", {}),
1226            /*#__PURE__*/ (0, _jsxruntime.jsxs)("body", {
1227                children: [
1228                    /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleISRError, {
1229                        error: error
1230                    }),
1231                    /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
1232                        style: styles.error,
1233                        children: /*#__PURE__*/ (0, _jsxruntime.jsxs)("div", {
1234                            children: [
1235                                /*#__PURE__*/ (0, _jsxruntime.jsx)("h2", {
1236                                    style: styles.text,
1237                                    children: "Application error: a " + (digest ? "server" : "client") + "-side exception has occurred (see the " + (digest ? "server logs" : "browser console") + " for more information)."
1238                                }),
1239                                digest ? /*#__PURE__*/ (0, _jsxruntime.jsx)("p", {
1240                                    style: styles.text,
1241                                    children: "Digest: " + digest
1242                                }) : null
1243                            ]
1244                        })
1245                    })
1246                ]
1247            })
1248        ]
1249    });
1250}
1251const _default = GlobalError;
1252function ErrorBoundary(param) {
1253    let { errorComponent, errorStyles, errorScripts, children } = param;
1254    const pathname = (0, _navigation.usePathname)();
1255    if (errorComponent) {
1256        return /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorBoundaryHandler, {
1257            pathname: pathname,
1258            errorComponent: errorComponent,
1259            errorStyles: errorStyles,
1260            errorScripts: errorScripts,
1261            children: children
1262        });
1263    }

1264    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
1265        children: children
1266    });
1267}
1268if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1269    Object.defineProperty(exports.default, "__esModule", {
1270        value: true
1271    });
1272    Object.assign(exports.default, exports);
1273    module.exports = exports.default;
1274} //# sourceMappingURL=error-boundary.js.map
1275
1276
1277/***/ }),
1278
1279/***/ 3459:
1280/***/ (function(module, exports) {
1281
1282"use strict";
1283
1284Object.defineProperty(exports, "__esModule", ({
1285    value: true
1286}));
12870 && (0);
1288function _export(target, all) {
1289    for(var name in all)Object.defineProperty(target, name, {
1290        enumerable: true,
1291        get: all[name]
1292    });
1293}
1294_export(exports, {
1295    DYNAMIC_ERROR_CODE: function() {
1296        return DYNAMIC_ERROR_CODE;
1297    },
1298    DynamicServerError: function() {
1299        return DynamicServerError;
1300    }
1301});
1302const DYNAMIC_ERROR_CODE = "DYNAMIC_SERVER_USAGE";
1303class DynamicServerError extends Error {
1304    constructor(type){
1305        super("Dynamic server usage: " + type);
1306        this.digest = DYNAMIC_ERROR_CODE;
1307    }
1308}
1309if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1310    Object.defineProperty(exports.default, "__esModule", {
1311        value: true
1312    });
1313    Object.assign(exports.default, exports);
1314    module.exports = exports.default;
1315} //# sourceMappingURL=hooks-server-context.js.map
1316
1317
1318/***/ }),
1319
1320/***/ 6639:
1321/***/ (function(module, exports) {
1322
1323"use strict";
1324/**
1325 * Used to cache in createInfinitePromise
1326 */ 
1327Object.defineProperty(exports, "__esModule", ({
1328    value: true
1329}));
1330Object.defineProperty(exports, "createInfinitePromise", ({
1331    enumerable: true,
1332    get: function() {
1333        return createInfinitePromise;
1334    }
1335}));
1336let infinitePromise;
1337function createInfinitePromise() {
1338    if (!infinitePromise) {
1339        // Only create the Promise once
1340        infinitePromise = new Promise(()=>{
1341        // This is used to debug when the rendering is never updated.
1342        // setTimeout(() => {
1343        //   infinitePromise = new Error('Infinite promise')
1344        //   resolve()
1345        // }, 5000)
1346        });
1347    }
1348    return infinitePromise;
1349}
1350if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1351    Object.defineProperty(exports.default, "__esModule", {
1352        value: true
1353    });
1354    Object.assign(exports.default, exports);
1355    module.exports = exports.default;
1356} //# sourceMappingURL=infinite-promise.js.map
1357
1358
1359/***/ }),
1360
1361/***/ 7884:
1362/***/ (function(module, exports, __webpack_require__) {
1363
1364"use strict";
1365
1366Object.defineProperty(exports, "__esModule", ({
1367    value: true
1368}));
1369Object.defineProperty(exports, "isNextRouterError", ({
1370    enumerable: true,
1371    get: function() {
1372        return isNextRouterError;
1373    }
1374}));
1375const _notfound = __webpack_require__(7309);
1376const _redirect = __webpack_require__(50);
1377function isNextRouterError(error) {
1378    return error && error.digest && ((0, _redirect.isRedirectError)(error) || (0, _notfound.isNotFoundError)(error));
1379}
1380if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1381    Object.defineProperty(exports.default, "__esModule", {
1382        value: true
1383    });
1384    Object.assign(exports.default, exports);
1385    module.exports = exports.default;
1386} //# sourceMappingURL=is-next-router-error.js.map
1387
1388
1389/***/ }),
1390
1391/***/ 6273:
1392/***/ (function(module, exports, __webpack_require__) {
1393
1394"use strict";
1395/* __next_internal_client_entry_do_not_use__  cjs */ 
1396Object.defineProperty(exports, "__esModule", ({
1397    value: true
1398}));
1399Object.defineProperty(exports, "default", ({
1400    enumerable: true,
1401    get: function() {
1402        return OuterLayoutRouter;
1403    }
1404}));
1405const _interop_require_default = __webpack_require__(7295);
1406const _interop_require_wildcard = __webpack_require__(3589);
1407const _jsxruntime = __webpack_require__(1411);
1408const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
1409const _reactdom = /*#__PURE__*/ _interop_require_default._(__webpack_require__(7897));
1410const _approutercontextsharedruntime = __webpack_require__(1214);
1411const _fetchserverresponse = __webpack_require__(5501);
1412const _infinitepromise = __webpack_require__(6639);
1413const _errorboundary = __webpack_require__(9697);
1414const _matchsegments = __webpack_require__(1118);

1415const _handlesmoothscroll = __webpack_require__(4875);
1416const _redirectboundary = __webpack_require__(5813);
1417const _notfoundboundary = __webpack_require__(213);
1418const _getsegmentvalue = __webpack_require__(1846);
1419const _createroutercachekey = __webpack_require__(7310);
1420/**
1421 * Add refetch marker to router state at the point of the current layout segment.
1422 * This ensures the response returned is not further down than the current layout segment.
1423 */ function walkAddRefetch(segmentPathToWalk, treeToRecreate) {
1424    if (segmentPathToWalk) {
1425        const [segment, parallelRouteKey] = segmentPathToWalk;
1426        const isLast = segmentPathToWalk.length === 2;
1427        if ((0, _matchsegments.matchSegment)(treeToRecreate[0], segment)) {
1428            if (treeToRecreate[1].hasOwnProperty(parallelRouteKey)) {
1429                if (isLast) {
1430                    const subTree = walkAddRefetch(undefined, treeToRecreate[1][parallelRouteKey]);
1431                    return [
1432                        treeToRecreate[0],
1433                        {
1434                            ...treeToRecreate[1],
1435                            [parallelRouteKey]: [
1436                                subTree[0],
1437                                subTree[1],
1438                                subTree[2],
1439                                "refetch"
1440                            ]
1441                        }
1442                    ];
1443                }
1444                return [
1445                    treeToRecreate[0],
1446                    {
1447                        ...treeToRecreate[1],
1448                        [parallelRouteKey]: walkAddRefetch(segmentPathToWalk.slice(2), treeToRecreate[1][parallelRouteKey])
1449                    }
1450                ];
1451            }
1452        }
1453    }
1454    return treeToRecreate;
1455}
1456// TODO-APP: Replace with new React API for finding dom nodes without a `ref` when available
1457/**
1458 * Wraps ReactDOM.findDOMNode with additional logic to hide React Strict Mode warning
1459 */ function findDOMNode(instance) {
1460    // Tree-shake for server bundle
1461    if (false) {}
1462    // Only apply strict mode warning when not in production
1463    if (false) {}
1464    return _reactdom.default.findDOMNode(instance);
1465}
1466const rectProperties = [
1467    "bottom",
1468    "height",
1469    "left",
1470    "right",
1471    "top",
1472    "width",
1473    "x",
1474    "y"
1475];
1476/**
1477 * Check if a HTMLElement is hidden or fixed/sticky position
1478 */ function shouldSkipElement(element) {
1479    // we ignore fixed or sticky positioned elements since they'll likely pass the "in-viewport" check
1480    // and will result in a situation we bail on scroll because of something like a fixed nav,
1481    // even though the actual page content is offscreen
1482    if ([
1483        "sticky",
1484        "fixed"
1485    ].includes(getComputedStyle(element).position)) {
1486        if (false) {}
1487        return true;
1488    }
1489    // Uses `getBoundingClientRect` to check if the element is hidden instead of `offsetParent`
1490    // because `offsetParent` doesn't consider document/body
1491    const rect = element.getBoundingClientRect();
1492    return rectProperties.every((item)=>rect[item] === 0);
1493}
1494/**
1495 * Check if the top corner of the HTMLElement is in the viewport.

1496 */ function topOfElementInViewport(element, viewportHeight) {
1497    const rect = element.getBoundingClientRect();
1498    return rect.top >= 0 && rect.top <= viewportHeight;
1499}
1500/**
1501 * Find the DOM node for a hash fragment.
1502 * If `top` the page has to scroll to the top of the page. This mirrors the browser's behavior.
1503 * If the hash fragment is an id, the page has to scroll to the element with that id.
1504 * If the hash fragment is a name, the page has to scroll to the first element with that name.
1505 */ function getHashFragmentDomNode(hashFragment) {
1506    // If the hash fragment is `top` the page has to scroll to the top of the page.
1507    if (hashFragment === "top") {
1508        return document.body;
1509    }
1510    var _document_getElementById;
1511    // If the hash fragment is an id, the page has to scroll to the element with that id.
1512    return (_document_getElementById = document.getElementById(hashFragment)) != null ? _document_getElementById : document.getElementsByName(hashFragment)[0];
1513}
1514class InnerScrollAndFocusHandler extends _react.default.Component {
1515    componentDidMount() {
1516        this.handlePotentialScroll();
1517    }
1518    componentDidUpdate() {
1519        // 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.
1520        if (this.props.focusAndScrollRef.apply) {
1521            this.handlePotentialScroll();
1522        }
1523    }
1524    render() {
1525        return this.props.children;
1526    }
1527    constructor(...args){
1528        super(...args);
1529        this.handlePotentialScroll = ()=>{
1530            // Handle scroll and focus, it's only applied once in the first useEffect that triggers that changed.
1531            const { focusAndScrollRef, segmentPath } = this.props;
1532            if (focusAndScrollRef.apply) {
1533                // segmentPaths is an array of segment paths that should be scrolled to
1534                // if the current segment path is not in the array, the scroll is not applied
1535                // unless the array is empty, in which case the scroll is always applied
1536                if (focusAndScrollRef.segmentPaths.length !== 0 && !focusAndScrollRef.segmentPaths.some((scrollRefSegmentPath)=>segmentPath.every((segment, index)=>(0, _matchsegments.matchSegment)(segment, scrollRefSegmentPath[index])))) {
1537                    return;
1538                }
1539                let domNode = null;
1540                const hashFragment = focusAndScrollRef.hashFragment;
1541                if (hashFragment) {
1542                    domNode = getHashFragmentDomNode(hashFragment);
1543                }
1544                // `findDOMNode` is tricky because it returns just the first child if the component is a fragment.
1545                // This already caused a bug where the first child was a <link/> in head.
1546                if (!domNode) {
1547                    domNode = findDOMNode(this);
1548                }
1549                // If there is no DOM node this layout-router level is skipped. It'll be handled higher-up in the tree.
1550                if (!(domNode instanceof Element)) {
1551                    return;
1552                }
1553                // Verify if the element is a HTMLElement and if we want to consider it for scroll behavior.
1554                // If the element is skipped, try to select the next sibling and try again.
1555                while(!(domNode instanceof HTMLElement) || shouldSkipElement(domNode)){
1556                    // No siblings found that match the criteria are found, so handle scroll higher up in the tree instead.
1557                    if (domNode.nextElementSibling === null) {
1558                        return;
1559                    }
1560                    domNode = domNode.nextElementSibling;
1561                }
1562                // State is mutated to ensure that the focus and scroll is applied only once.
1563                focusAndScrollRef.apply = false;
1564                focusAndScrollRef.hashFragment = null;
1565                focusAndScrollRef.segmentPaths = [];
1566                (0, _handlesmoothscroll.handleSmoothScroll)(()=>{
1567                    // In case of hash scroll, we only need to scroll the element into view
1568                    if (hashFragment) {
1569                        domNode.scrollIntoView();
1570                        return;
1571                    }
1572                    // Store the current viewport height because reading `clientHeight` causes a reflow,

1573                    // and it won't change during this function.
1574                    const htmlElement = document.documentElement;
1575                    const viewportHeight = htmlElement.clientHeight;
1576                    // If the element's top edge is already in the viewport, exit early.
1577                    if (topOfElementInViewport(domNode, viewportHeight)) {
1578                        return;
1579                    }
1580                    // Otherwise, try scrolling go the top of the document to be backward compatible with pages
1581                    // scrollIntoView() called on `<html/>` element scrolls horizontally on chrome and firefox (that shouldn't happen)
1582                    // We could use it to scroll horizontally following RTL but that also seems to be broken - it will always scroll left
1583                    // scrollLeft = 0 also seems to ignore RTL and manually checking for RTL is too much hassle so we will scroll just vertically
1584                    htmlElement.scrollTop = 0;
1585                    // Scroll to domNode if domNode is not in viewport when scrolled to top of document
1586                    if (!topOfElementInViewport(domNode, viewportHeight)) {
1587                        domNode.scrollIntoView();
1588                    }
1589                }, {
1590                    // We will force layout by querying domNode position
1591                    dontForceLayout: true,
1592                    onlyHashChange: focusAndScrollRef.onlyHashChange
1593                });
1594                // Mutate after scrolling so that it can be read by `handleSmoothScroll`
1595                focusAndScrollRef.onlyHashChange = false;
1596                // Set focus on the element
1597                domNode.focus();
1598            }
1599        };
1600    }
1601}
1602function ScrollAndFocusHandler(param) {
1603    let { segmentPath, children } = param;
1604    const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
1605    if (!context) {
1606        throw new Error("invariant global layout router not mounted");
1607    }
1608    return /*#__PURE__*/ (0, _jsxruntime.jsx)(InnerScrollAndFocusHandler, {
1609        segmentPath: segmentPath,
1610        focusAndScrollRef: context.focusAndScrollRef,
1611        children: children
1612    });
1613}
1614/**
1615 * InnerLayoutRouter handles rendering the provided segment based on the cache.
1616 */ function InnerLayoutRouter(param) {
1617    let { parallelRouterKey, url, childNodes, segmentPath, tree, // isActive,
1618    cacheKey } = param;
1619    const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
1620    if (!context) {
1621        throw new Error("invariant global layout router not mounted");
1622    }
1623    const { buildId, changeByServerResponse, tree: fullTree } = context;
1624    // Read segment path from the parallel router cache node.
1625    let childNode = childNodes.get(cacheKey);
1626    // When data is not available during rendering client-side we need to fetch
1627    // it from the server.
1628    if (!childNode || // Check if this is a lazy cache entry that has not yet initiated a
1629    // data request.
1630    //
1631    // TODO: An eventual goal of PPR is to remove this case entirely.
1632    childNode.rsc === null && childNode.lazyData === null) {
1633        /**
1634     * Router state with refetch marker added
1635     */ // TODO-APP: remove ''
1636        const refetchTree = walkAddRefetch([
1637            "",
1638            ...segmentPath
1639        ], fullTree);
1640        // TODO: Since this case always suspends indefinitely, and the only thing
1641        // we're doing here is setting `lazyData`, it would be fine to mutate the
1642        // current cache node (if it exists) rather than cloning it.
1643        childNode = {
1644            lazyData: (0, _fetchserverresponse.fetchServerResponse)(new URL(url, location.origin), refetchTree, context.nextUrl, buildId),
1645            rsc: null,
1646            prefetchRsc: childNode ? childNode.prefetchRsc : null,
1647            head: childNode ? childNode.head : undefined,
1648            parallelRoutes: childNode ? childNode.parallelRoutes : new Map()
1649        };
1650        /**
1651     * Flight data fetch kicked off during render and put into the cache.
1652     */ childNodes.set(cacheKey, childNode);
1653    }
1654    // This case should never happen so it throws an error. It indicates there's a bug in the Next.js.
1655    if (!childNode) {
1656        throw new Error("Child node should always exist");
1657    }
1658    // This case should never happen so it throws an error. It indicates there's a bug in the Next.js.
1659    if (childNode.rsc && childNode.lazyData) {
1660        throw new Error("Child node should not have both rsc and lazyData");
1661    }
1662    // If cache node has a data request we have to unwrap response by `use` and update the cache.
1663    if (childNode.lazyData) {
1664        /**
1665     * Flight response data
1666     */ // When the data has not resolved yet `use` will suspend here.

1667        const [flightData, overrideCanonicalUrl] = (0, _react.use)(childNode.lazyData);
1668        // segmentPath from the server does not match the layout's segmentPath
1669        childNode.lazyData = null;
1670        // setTimeout is used to start a new transition during render, this is an intentional hack around React.
1671        setTimeout(()=>{
1672            (0, _react.startTransition)(()=>{
1673                changeByServerResponse(fullTree, flightData, overrideCanonicalUrl);
1674            });
1675        });
1676        // Suspend infinitely as `changeByServerResponse` will cause a different part of the tree to be rendered.
1677        (0, _react.use)((0, _infinitepromise.createInfinitePromise)());
1678    }
1679    // If cache node has no rsc and no lazy data request we have to infinitely suspend as the data will likely flow in from another place.
1680    // TODO-APP: double check users can't return null in a component that will kick in here.
1681    if (!childNode.rsc) {
1682        (0, _react.use)((0, _infinitepromise.createInfinitePromise)());
1683    }
1684    const subtree = /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
1685        value: {
1686            tree: tree[1][parallelRouterKey],
1687            childNodes: childNode.parallelRoutes,
1688            // TODO-APP: overriding of url for parallel routes
1689            url: url
1690        },
1691        children: childNode.rsc
1692    });
1693    // Ensure root layout is not wrapped in a div as the root layout renders `<html>`
1694    return subtree;
1695}
1696/**
1697 * Renders suspense boundary with the provided "loading" property as the fallback.
1698 * If no loading property is provided it renders the children without a suspense boundary.
1699 */ function LoadingBoundary(param) {
1700    let { children, loading, loadingStyles, loadingScripts, hasLoading } = param;
1701    if (hasLoading) {
1702        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
1703            fallback: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
1704                children: [
1705                    loadingStyles,
1706                    loadingScripts,
1707                    loading
1708                ]
1709            }),
1710            children: children
1711        });
1712    }
1713    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
1714        children: children
1715    });
1716}
1717function OuterLayoutRouter(param) {
1718    let { parallelRouterKey, segmentPath, error, errorStyles, errorScripts, templateStyles, templateScripts, loading, loadingStyles, loadingScripts, hasLoading, template, notFound, notFoundStyles, styles } = param;
1719    const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
1720    if (!context) {
1721        throw new Error("invariant expected layout router to be mounted");
1722    }
1723    const { childNodes, tree, url } = context;
1724    // Get the current parallelRouter cache node
1725    let childNodesForParallelRouter = childNodes.get(parallelRouterKey);
1726    // If the parallel router cache node does not exist yet, create it.
1727    // 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.
1728    if (!childNodesForParallelRouter) {
1729        childNodesForParallelRouter = new Map();
1730        childNodes.set(parallelRouterKey, childNodesForParallelRouter);
1731    }
1732    // Get the active segment in the tree
1733    // 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.
1734    const treeSegment = tree[1][parallelRouterKey][0];
1735    // If segment is an array it's a dynamic route and we want to read the dynamic route value as the segment to get from the cache.
1736    const currentChildSegmentValue = (0, _getsegmentvalue.getSegmentValue)(treeSegment);
1737    /**
1738   * Decides which segments to keep rendering, all segments that are not active will be wrapped in `<Offscreen>`.
1739   */ // TODO-APP: Add handling of `<Offscreen>` when it's available.
1740    const preservedSegments = [
1741        treeSegment
1742    ];
1743    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
1744        children: [
1745            styles,
1746            preservedSegments.map((preservedSegment)=>{
1747                const preservedSegmentValue = (0, _getsegmentvalue.getSegmentValue)(preservedSegment);
1748                const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(preservedSegment);
1749                return(/*
1750            - Error boundary
1751              - Only renders error boundary if error component is provided.
1752              - Rendered for each segment to ensure they have their own error state.
1753            - Loading boundary
1754              - Only renders suspense boundary if loading components is provided.
1755              - Rendered for each segment to ensure they have their own loading state.
1756              - Passed to the router during rendering to ensure it can be immediately rendered when suspending on a Flight fetch.
1757          */ /*#__PURE__*/ (0, _jsxruntime.jsxs)(_approutercontextsharedruntime.TemplateContext.Provider, {
1758                    value: /*#__PURE__*/ (0, _jsxruntime.jsx)(ScrollAndFocusHandler, {
1759                        segmentPath: segmentPath,
1760                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
1761                            errorComponent: error,
1762                            errorStyles: errorStyles,
1763                            errorScripts: errorScripts,
1764                            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(LoadingBoundary, {
1765                                hasLoading: hasLoading,
1766                                loading: loading,
1767                                loadingStyles: loadingStyles,
1768                                loadingScripts: loadingScripts,
1769                                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_

1769notfoundboundary.NotFoundBoundary, {
1770                                    notFound: notFound,
1771                                    notFoundStyles: notFoundStyles,
1772                                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_redirectboundary.RedirectBoundary, {
1773                                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(InnerLayoutRouter, {
1774                                            parallelRouterKey: parallelRouterKey,
1775                                            url: url,
1776                                            tree: tree,
1777                                            childNodes: childNodesForParallelRouter,
1778                                            segmentPath: segmentPath,
1779                                            cacheKey: cacheKey,
1780                                            isActive: currentChildSegmentValue === preservedSegmentValue
1781                                        })
1782                                    })
1783                                })
1784                            })
1785                        })
1786                    }),
1787                    children: [
1788                        templateStyles,
1789                        templateScripts,
1790                        template
1791                    ]
1792                }, (0, _createroutercachekey.createRouterCacheKey)(preservedSegment, true)));
1793            })
1794        ]
1795    });
1796}
1797if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1798    Object.defineProperty(exports.default, "__esModule", {
1799        value: true
1800    });
1801    Object.assign(exports.default, exports);
1802    module.exports = exports.default;
1803} //# sourceMappingURL=layout-router.js.map
1804
1805
1806/***/ }),
1807
1808/***/ 1118:
1809/***/ (function(module, exports, __webpack_require__) {
1810
1811"use strict";
1812
1813Object.defineProperty(exports, "__esModule", ({
1814    value: true
1815}));
18160 && (0);
1817function _export(target, all) {
1818    for(var name in all)Object.defineProperty(target, name, {
1819        enumerable: true,
1820        get: all[name]
1821    });
1822}
1823_export(exports, {
1824    matchSegment: function() {
1825        return matchSegment;
1826    },
1827    canSegmentBeOverridden: function() {
1828        return canSegmentBeOverridden;
1829    }
1830});
1831const _getsegmentparam = __webpack_require__(4758);
1832const matchSegment = (existingSegment, segment)=>{
1833    // segment is either Array or string
1834    if (typeof existingSegment === "string") {
1835        if (typeof segment === "string") {
1836            // Common case: segment is just a string
1837            return existingSegment === segment;
1838        }
1839        return false;
1840    }
1841    if (typeof segment === "string") {
1842        return false;
1843    }
1844    return existingSegment[0] === segment[0] && existingSegment[1] === segment[1];
1845};
1846const canSegmentBeOverridden = (existingSegment, segment)=>{
1847    var _getSegmentParam;
1848    if (Array.isArray(existingSegment) || !Array.isArray(segment)) {
1849        return false;
1850    }
1851    return ((_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(existingSegment)) == null ? void 0 : _getSegmentParam.param) === segment[0];
1852};
1853if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
1854    Object.defineProperty(exports.default, "__esModule", {
1855        value: true
1856    });
1857    Object.assign(exports.default, exports);
1858    module.exports = exports.default;
1859} //# sourceMappingURL=match-segments.js.map
1860
1861
1862/***/ }),
1863
1864/***/ 9960:
1865/***/ (function(module, exports, __webpack_require__) {
1866
1867"use strict";
1868
1869Object.defineProperty(exports, "__esModule", ({
1870    value: true
1871}));
18720 && (0);
1873function _export(target, all) {
1874    for(var name in all)Object.defineProperty(target, name, {
1875        enumerable: true,
1876        get: all[name]
1877    });
1878}
1879_export(exports, {
1880    ReadonlyURLSearchParams: function() {
1881        return ReadonlyURLSearchParams;
1882    },
1883    useSearchParams: function() {
1884        return useSearchParams;
1885    },
1886    usePathname: function() {
1887        return usePathname;
1888    },
1889    ServerInsertedHTMLContext: function() {
1890        return _serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext;
1891    },
1892    useServerInsertedHTML: function() {
1893        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
1894    },
1895    useRouter: function() {
1896        return useRouter;
1897    },
1898    useParams: function() {
1899        return useParams;
1900    },
1901    useSelectedLayoutSegments: function() {
1902        return useSelectedLayoutSegments;
1903    },
1904    useSelectedLayoutSegment: function() {
1905        return useSelectedLayoutSegment;
1906    },
1907    redirect: function() {
1908        return _redirect.redirect;
1909    },
1910    permanentRedirect: function() {
1911        return _redirect.permanentRedirect;
1912    },
1913    RedirectType: function() {
1914        return _redirect.RedirectType;
1915    },
1916    notFound: function() {
1917        return _notfound.notFound;
1918    }
1919});
1920const _react = __webpack_require__(9988);
1921const _approutercontextsharedruntime = __webpack_require__(1214);
1922const _hooksclientcontextsharedruntime = __webpack_require__(8581);
1923const _clienthookinservercomponenterror = __webpack_require__(363);
1924const _getsegmentvalue = __webpack_require__(1846);
1925const _segment = __webpack_require__(1956);
1926const _serverinsertedhtmlsharedruntime = __webpack_require__(2342);
1927const _redirect = __webpack_require__(50);
1928const _notfound = __webpack_require__(7309);
1929const INTERNAL_URLSEARCHPARAMS_INSTANCE = Symbol("internal for urlsearchparams readonly");
1930function readonlyURLSearchParamsError() {
1931    return new Error("ReadonlyURLSearchParams cannot be modified");
1932}
1933class ReadonlyURLSearchParams {
1934    [Symbol.iterator]() {
1935        return this[INTERNAL_URLSEARCHPARAMS_INSTANCE][Symbol.iterator]();
1936    }
1937    append() {
1938        throw readonlyURLSearchParamsError();
1939    }
1940    delete() {
1941        throw readonlyURLSearchParamsError();
1942    }
1943    set() {
1944        throw readonlyURLSearchParamsError();
1945    }
1946    sort() {
1947        throw readonlyURLSearchParamsError();
1948    }
1949    constructor(urlSearchParams){
1950        this[INTERNAL_URLSEARCHPARAMS_INSTANCE] = urlSearchParams;

1951        this.entries = urlSearchParams.entries.bind(urlSearchParams);
1952        this.forEach = urlSearchParams.forEach.bind(urlSearchParams);
1953        this.get = urlSearchParams.get.bind(urlSearchParams);
1954        this.getAll = urlSearchParams.getAll.bind(urlSearchParams);
1955        this.has = urlSearchParams.has.bind(urlSearchParams);
1956        this.keys = urlSearchParams.keys.bind(urlSearchParams);
1957        this.values = urlSearchParams.values.bind(urlSearchParams);
1958        this.toString = urlSearchParams.toString.bind(urlSearchParams);
1959        this.size = urlSearchParams.size;
1960    }
1961}
1962function useSearchParams() {
1963    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("useSearchParams");
1964    const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
1965    // In the case where this is `null`, the compat types added in
1966    // `next-env.d.ts` will add a new overload that changes the return type to
1967    // include `null`.
1968    const readonlySearchParams = (0, _react.useMemo)(()=>{
1969        if (!searchParams) {
1970            // When the router is not ready in pages, we won't have the search params
1971            // available.
1972            return null;
1973        }
1974        return new ReadonlyURLSearchParams(searchParams);
1975    }, [
1976        searchParams
1977    ]);
1978    if (false) {}
1979    return readonlySearchParams;
1980}
1981function usePathname() {
1982    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("usePathname");
1983    // In the case where this is `null`, the compat types added in `next-env.d.ts`
1984    // will add a new overload that changes the return type to include `null`.
1985    return (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
1986}
1987function useRouter() {
1988    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("useRouter");
1989    const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
1990    if (router === null) {
1991        throw new Error("invariant expected app router to be mounted");
1992    }
1993    return router;
1994}
1995// this function performs a depth-first search of the tree to find the selected
1996// params
1997function getSelectedParams(tree, params) {
1998    if (params === void 0) params = {};
1999    const parallelRoutes = tree[1];
2000    for (const parallelRoute of Object.values(parallelRoutes)){
2001        const segment = parallelRoute[0];
2002        const isDynamicParameter = Array.isArray(segment);
2003        const segmentValue = isDynamicParameter ? segment[1] : segment;
2004        if (!segmentValue || segmentValue.startsWith(_segment.PAGE_SEGMENT_KEY)) continue;
2005        // Ensure catchAll and optional catchall are turned into an array
2006        const isCatchAll = isDynamicParameter && (segment[2] === "c" || segment[2] === "oc");
2007        if (isCatchAll) {
2008            params[segment[0]] = segment[1].split("/");
2009        } else if (isDynamicParameter) {
2010            params[segment[0]] = segment[1];
2011        }
2012        params = getSelectedParams(parallelRoute, params);
2013    }
2014    return params;
2015}
2016function useParams() {
2017    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("useParams");
2018    const globalLayoutRouter = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
2019    const pathParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
2020    return (0, _react.useMemo)(()=>{
2021        // When it's under app router
2022        if (globalLayoutRouter == null ? void 0 : globalLayoutRouter.tree) {
2023            return getSelectedParams(globalLayoutRouter.tree);
2024        }
2025        // When it's under client side pages router
2026        return pathParams;
2027    }, [
2028        globalLayoutRouter == null ? void 0 : globalLayoutRouter.tree,
2029        pathParams
2030    ]);
2031}
2032// TODO-APP: handle parallel routes
2033/**
2034 * Get the canonical parameters from the current level to the leaf node.
2035 */ function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first, segmentPath) {
2036    if (first === void 0) first = true;
2037    if (segmentPath === void 0) segmentPath = [];
2038    let node;
2039    if (first) {
2040        // Use the provided parallel route key on the first parallel route
2041        node = tree[1][parallelRouteKey];
2042    } else {
2043        // After first parallel route prefer children, if there's no children pick the first parallel route.
2044        const parallelRoutes = tree[1];
2045        var _parallelRoutes_children;
2046        node = (_parallelRoutes_children = parallelRoutes.children) != null ? _parallelRoutes_children : Object.values(parallelRoutes)[0];
2047    }
2048    if (!node) return segmentPath;
2049    const segment = node[0];
2050    const segmentValue = (0, _getsegmentvalue.getSegmentValue)(segment);
2051    if (!segmentValue || segmentValue.startsWith(_segment.PAGE_SEGMENT_KEY)) {
2052        return segmentPath;
2053    }
2054    segmentPath.push(segmentValue);
2055    return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
2056}
2057function useSelectedLayoutSegments(parallelRouteKey) {
2058    if (parallelRouteKey === void 0) parallelRouteKey = "children";
2059    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("use

2059SelectedLayoutSegments");
2060    const { tree } = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
2061    return getSelectedLayoutSegmentPath(tree, parallelRouteKey);
2062}
2063function useSelectedLayoutSegment(parallelRouteKey) {
2064    if (parallelRouteKey === void 0) parallelRouteKey = "children";
2065    (0, _clienthookinservercomponenterror.clientHookInServerComponentError)("useSelectedLayoutSegment");
2066    const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
2067    if (selectedLayoutSegments.length === 0) {
2068        return null;
2069    }
2070    return selectedLayoutSegments[0];
2071}
2072if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2073    Object.defineProperty(exports.default, "__esModule", {
2074        value: true
2075    });
2076    Object.assign(exports.default, exports);
2077    module.exports = exports.default;
2078} //# sourceMappingURL=navigation.js.map
2079
2080
2081/***/ }),
2082
2083/***/ 213:
2084/***/ (function(module, exports, __webpack_require__) {
2085
2086"use strict";
2087/* __next_internal_client_entry_do_not_use__  cjs */ 
2088Object.defineProperty(exports, "__esModule", ({
2089    value: true
2090}));
2091Object.defineProperty(exports, "NotFoundBoundary", ({
2092    enumerable: true,
2093    get: function() {
2094        return NotFoundBoundary;
2095    }
2096}));
2097const _interop_require_default = __webpack_require__(7295);
2098const _jsxruntime = __webpack_require__(1411);
2099const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
2100const _navigation = __webpack_require__(9960);
2101class NotFoundErrorBoundary extends _react.default.Component {
2102    static getDerivedStateFromError(error) {
2103        if ((error == null ? void 0 : error.digest) === "NEXT_NOT_FOUND") {
2104            return {
2105                notFoundTriggered: true
2106            };
2107        }
2108        // Re-throw if error is not for 404
2109        throw error;
2110    }
2111    static getDerivedStateFromProps(props, state) {
2112        /**
2113     * Handles reset of the error boundary when a navigation happens.
2114     * Ensures the error boundary does not stay enabled when navigating to a new page.
2115     * Approach of setState in render is safe as it checks the previous pathname and then overrides
2116     * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
2117     */ if (props.pathname !== state.previousPathname && state.notFoundTriggered) {
2118            return {
2119                notFoundTriggered: false,
2120                previousPathname: props.pathname
2121            };
2122        }
2123        return {
2124            notFoundTriggered: state.notFoundTriggered,
2125            previousPathname: props.pathname
2126        };
2127    }
2128    render() {
2129        if (this.state.notFoundTriggered) {
2130            return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
2131                children: [
2132                    /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
2133                        name: "robots",
2134                        content: "noindex"
2135                    }),
2136                     false && /*#__PURE__*/ 0,
2137                    this.props.notFoundStyles,
2138                    this.props.notFound
2139                ]
2140            });
2141        }
2142        return this.props.children;
2143    }
2144    constructor(props){
2145        super(props);
2146        this.state = {
2147            notFoundTriggered: !!props.asNotFound,
2148            previousPathname: props.pathname
2149        };
2150    }
2151}
2152function NotFoundBoundary(param) {
2153    let { notFound, notFoundStyles, asNotFound, children } = param;
2154    const pathname = (0, _navigation.usePathname)();
2155    return notFound ? /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFoundErrorBoundary, {
2156        pathname: pathname,
2157        notFound: notFound,
2158        notFoundStyles: notFoundStyles,
2159        asNotFound: asNotFound,
2160        children: children
2161    }) : /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
2162        children: children
2163    });
2164}
2165if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2166    Object.defineProperty(exports.default, "__esModule", {
2167        value: true
2168    });

2169    Object.assign(exports.default, exports);
2170    module.exports = exports.default;
2171} //# sourceMappingURL=not-found-boundary.js.map
2172
2173
2174/***/ }),
2175
2176/***/ 7309:
2177/***/ (function(module, exports) {
2178
2179"use strict";
2180
2181Object.defineProperty(exports, "__esModule", ({
2182    value: true
2183}));
21840 && (0);
2185function _export(target, all) {
2186    for(var name in all)Object.defineProperty(target, name, {
2187        enumerable: true,
2188        get: all[name]
2189    });
2190}
2191_export(exports, {
2192    notFound: function() {
2193        return notFound;
2194    },
2195    isNotFoundError: function() {
2196        return isNotFoundError;
2197    }
2198});
2199const NOT_FOUND_ERROR_CODE = "NEXT_NOT_FOUND";
2200function notFound() {
2201    // eslint-disable-next-line no-throw-literal
2202    const error = new Error(NOT_FOUND_ERROR_CODE);
2203    error.digest = NOT_FOUND_ERROR_CODE;
2204    throw error;
2205}
2206function isNotFoundError(error) {
2207    return (error == null ? void 0 : error.digest) === NOT_FOUND_ERROR_CODE;
2208}
2209if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2210    Object.defineProperty(exports.default, "__esModule", {
2211        value: true
2212    });
2213    Object.assign(exports.default, exports);
2214    module.exports = exports.default;
2215} //# sourceMappingURL=not-found.js.map
2216
2217
2218/***/ }),
2219
2220/***/ 9236:
2221/***/ (function(module, exports, __webpack_require__) {
2222
2223"use strict";
2224/*
2225    This is a simple promise queue that allows you to limit the number of concurrent promises
2226    that are running at any given time. It's used to limit the number of concurrent
2227    prefetch requests that are being made to the server but could be used for other
2228    things as well.
2229*/ 
2230Object.defineProperty(exports, "__esModule", ({
2231    value: true
2232}));
2233Object.defineProperty(exports, "PromiseQueue", ({
2234    enumerable: true,
2235    get: function() {
2236        return PromiseQueue;
2237    }
2238}));
2239const _class_private_field_loose_base = __webpack_require__(9382);
2240const _class_private_field_loose_key = __webpack_require__(7666);
2241var _maxConcurrency = /*#__PURE__*/ _class_private_field_loose_key._("_maxConcurrency"), _runningCount = /*#__PURE__*/ _class_private_field_loose_key._("_runningCount"), _queue = /*#__PURE__*/ _class_private_field_loose_key._("_queue"), _processNext = /*#__PURE__*/ _class_private_field_loose_key._("_processNext");
2242class PromiseQueue {
2243    enqueue(promiseFn) {
2244        let taskResolve;
2245        let taskReject;
2246        const taskPromise = new Promise((resolve, reject)=>{
2247            taskResolve = resolve;
2248            taskReject = reject;
2249        });
2250        const task = async ()=>{
2251            try {
2252                _class_private_field_loose_base._(this, _runningCount)[_runningCount]++;
2253                const result = await promiseFn();
2254                taskResolve(result);
2255            } catch (error) {
2256                taskReject(error);
2257            } finally{
2258                _class_private_field_loose_base._(this, _runningCount)[_runningCount]--;
2259                _class_private_field_loose_base._(this, _processNext)[_processNext]();
2260            }
2261        };
2262        const enqueueResult = {
2263            promiseFn: taskPromise,
2264            task
2265        };
2266        // wonder if we should take a LIFO approach here
2267        _class_private_field_loose_base._(this, _queue)[_queue].push(enqueueResult);
2268        _class_private_field_loose_base._(this, _processNext)[_processNext]();
2269        return taskPromise;
2270    }
2271    bump(promiseFn) {
2272        const index = _class_private_field_loose_base._(this, _queue)[_queue].findIndex((item)=>item.promiseFn === promiseFn);
2273        if (index > -1) {
2274            const bumpedItem = _class_private_field_loose_base._(this, _queue)[_queue].splice(index, 1)[0];
2275            _class_private_field_loose_base._(this, _queue)[_queue].unshift(bumpedItem);
2276            _class_private_field_loose_base._(this, _processNext)[_processNext](true);
2277        }
2278    }
2279    constructor(maxConcurrency = 5){
2280        Object.defineProperty(this, _processNext, {
2281            value: processNext
2282        });
2283        Object.defineProperty(this, _maxConcurrency, {
2284            writable: true,
2285            value: void 0
2286        });
2287        Object.defineProperty(this, _runningCount, {
2288            writable: true,
2289            value: void 0
2290        });
2291        Object.defineProperty(this, _queue, {
2292            writable: true,
2293            value: void 0
2294        });
2295        _class_private_field_loose_base._(this, _maxConcurrency)[_maxConcurrency

2295] = maxConcurrency;
2296        _class_private_field_loose_base._(this, _runningCount)[_runningCount] = 0;
2297        _class_private_field_loose_base._(this, _queue)[_queue] = [];
2298    }
2299}
2300function processNext(forced) {
2301    if (forced === void 0) forced = false;
2302    if ((_class_private_field_loose_base._(this, _runningCount)[_runningCount] < _class_private_field_loose_base._(this, _maxConcurrency)[_maxConcurrency] || forced) && _class_private_field_loose_base._(this, _queue)[_queue].length > 0) {
2303        var _class_private_field_loose_base__queue_shift;
2304        (_class_private_field_loose_base__queue_shift = _class_private_field_loose_base._(this, _queue)[_queue].shift()) == null ? void 0 : _class_private_field_loose_base__queue_shift.task();
2305    }
2306}
2307if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2308    Object.defineProperty(exports.default, "__esModule", {
2309        value: true
2310    });
2311    Object.assign(exports.default, exports);
2312    module.exports = exports.default;
2313} //# sourceMappingURL=promise-queue.js.map
2314
2315
2316/***/ }),
2317
2318/***/ 5813:
2319/***/ (function(module, exports, __webpack_require__) {
2320
2321"use strict";
2322/* __next_internal_client_entry_do_not_use__  cjs */ 
2323Object.defineProperty(exports, "__esModule", ({
2324    value: true
2325}));
23260 && (0);
2327function _export(target, all) {
2328    for(var name in all)Object.defineProperty(target, name, {
2329        enumerable: true,
2330        get: all[name]
2331    });
2332}
2333_export(exports, {
2334    RedirectErrorBoundary: function() {
2335        return RedirectErrorBoundary;
2336    },
2337    RedirectBoundary: function() {
2338        return RedirectBoundary;
2339    }
2340});
2341const _interop_require_wildcard = __webpack_require__(3589);
2342const _jsxruntime = __webpack_require__(1411);
2343const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
2344const _navigation = __webpack_require__(9960);
2345const _redirect = __webpack_require__(50);
2346function HandleRedirect(param) {
2347    let { redirect, reset, redirectType } = param;
2348    const router = (0, _navigation.useRouter)();
2349    (0, _react.useEffect)(()=>{
2350        _react.default.startTransition(()=>{
2351            if (redirectType === _redirect.RedirectType.push) {
2352                router.push(redirect, {});
2353            } else {
2354                router.replace(redirect, {});
2355            }
2356            reset();
2357        });
2358    }, [
2359        redirect,
2360        redirectType,
2361        reset,
2362        router
2363    ]);
2364    return null;
2365}
2366class RedirectErrorBoundary extends _react.default.Component {
2367    static getDerivedStateFromError(error) {
2368        if ((0, _redirect.isRedirectError)(error)) {
2369            const url = (0, _redirect.getURLFromRedirectError)(error);
2370            const redirectType = (0, _redirect.getRedirectTypeFromError)(error);
2371            return {
2372                redirect: url,
2373                redirectType
2374            };
2375        }
2376        // Re-throw if error is not for redirect
2377        throw error;
2378    }
2379    render() {
2380        const { redirect, redirectType } = this.state;
2381        if (redirect !== null && redirectType !== null) {
2382            return /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleRedirect, {
2383                redirect: redirect,
2384                redirectType: redirectType,
2385                reset: ()=>this.setState({
2386                        redirect: null
2387                    })
2388            });
2389        }
2390        return this.props.children;
2391    }
2392    constructor(props){
2393        super(props);
2394        this.state = {
2395            redirect: null,
2396            redirectType: null
2397        };
2398    }
2399}
2400function RedirectBoundary(param) {
2401    let { children } = param;
2402    const router = (0, _navigation.useRouter)();
2403    return /*#__PURE__*/ (0, _jsxruntime.jsx)(RedirectErrorBoundary, {
2404        router: router,
2405        children: children
2406    });
2407}
2408if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2409    Object.defineProperty(exports.default, "__esModule", {
2410        value: true
2411    });

2412    Object.assign(exports.default, exports);
2413    module.exports = exports.default;
2414} //# sourceMappingURL=redirect-boundary.js.map
2415
2416
2417/***/ }),
2418
2419/***/ 402:
2420/***/ (function(module, exports) {
2421
2422"use strict";
2423
2424Object.defineProperty(exports, "__esModule", ({
2425    value: true
2426}));
2427Object.defineProperty(exports, "RedirectStatusCode", ({
2428    enumerable: true,
2429    get: function() {
2430        return RedirectStatusCode;
2431    }
2432}));
2433var RedirectStatusCode;
2434(function(RedirectStatusCode) {
2435    RedirectStatusCode[RedirectStatusCode["SeeOther"] = 303] = "SeeOther";
2436    RedirectStatusCode[RedirectStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
2437    RedirectStatusCode[RedirectStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
2438})(RedirectStatusCode || (RedirectStatusCode = {}));
2439if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2440    Object.defineProperty(exports.default, "__esModule", {
2441        value: true
2442    });
2443    Object.assign(exports.default, exports);
2444    module.exports = exports.default;
2445} //# sourceMappingURL=redirect-status-code.js.map
2446
2447
2448/***/ }),
2449
2450/***/ 50:
2451/***/ (function(module, exports, __webpack_require__) {
2452
2453"use strict";
2454
2455Object.defineProperty(exports, "__esModule", ({
2456    value: true
2457}));
24580 && (0);
2459function _export(target, all) {
2460    for(var name in all)Object.defineProperty(target, name, {
2461        enumerable: true,
2462        get: all[name]
2463    });
2464}
2465_export(exports, {
2466    RedirectType: function() {
2467        return RedirectType;
2468    },
2469    getRedirectError: function() {
2470        return getRedirectError;
2471    },
2472    redirect: function() {
2473        return redirect;
2474    },
2475    permanentRedirect: function() {
2476        return permanentRedirect;
2477    },
2478    isRedirectError: function() {
2479        return isRedirectError;
2480    },
2481    getURLFromRedirectError: function() {
2482        return getURLFromRedirectError;
2483    },
2484    getRedirectTypeFromError: function() {
2485        return getRedirectTypeFromError;
2486    },
2487    getRedirectStatusCodeFromError: function() {
2488        return getRedirectStatusCodeFromError;
2489    }
2490});
2491const _requestasyncstorageexternal = __webpack_require__(7899);
2492const _actionasyncstorageexternal = __webpack_require__(1828);
2493const _redirectstatuscode = __webpack_require__(402);
2494const REDIRECT_ERROR_CODE = "NEXT_REDIRECT";
2495var RedirectType;
2496(function(RedirectType) {
2497    RedirectType["push"] = "push";
2498    RedirectType["replace"] = "replace";
2499})(RedirectType || (RedirectType = {}));
2500function getRedirectError(url, type, statusCode) {
2501    if (statusCode === void 0) statusCode = _redirectstatuscode.RedirectStatusCode.TemporaryRedirect;
2502    const error = new Error(REDIRECT_ERROR_CODE);
2503    error.digest = REDIRECT_ERROR_CODE + ";" + type + ";" + url + ";" + statusCode + ";";
2504    const requestStore = _requestasyncstorageexternal.requestAsyncStorage.getStore();
2505    if (requestStore) {
2506        error.mutableCookies = requestStore.mutableCookies;
2507    }
2508    return error;
2509}
2510function redirect(url, type) {
2511    if (type === void 0) type = "replace";
2512    const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
2513    throw getRedirectError(url, type, // as we don't want the POST request to follow the redirect,
2514    // as it could result in erroneous re-submissions.
2515    (actionStore == null ? void 0 : actionStore.isAction) ? _redirectstatuscode.RedirectStatusCode.SeeOther : _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
2516}
2517function permanentRedirect(url, type) {
2518    if (type === void 0) type = "replace";
2519    const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
2520    throw getRedirectError(url, type, // as we don't want the POST request to follow the redirect,
2521    // as it could result in erroneous re-submissions.
2522    (actionStore == null ? void 0 : actionStore.isAction) ? _redirectstatuscode.RedirectStatusCode.SeeOther : _redirectstatuscode.RedirectStatusCode.PermanentRedirect);
2523}
2524function isRedirectError(error) {
2525    if (typeof (error == null ? void 0 : error.digest) !== "string") return false;

2526    const [errorCode, type, destination, status] = error.digest.split(";", 4);
2527    const statusCode = Number(status);
2528    return errorCode === REDIRECT_ERROR_CODE && (type === "replace" || type === "push") && typeof destination === "string" && !isNaN(statusCode) && statusCode in _redirectstatuscode.RedirectStatusCode;
2529}
2530function getURLFromRedirectError(error) {
2531    if (!isRedirectError(error)) return null;
2532    // Slices off the beginning of the digest that contains the code and the
2533    // separating ';'.
2534    return error.digest.split(";", 3)[2];
2535}
2536function getRedirectTypeFromError(error) {
2537    if (!isRedirectError(error)) {
2538        throw new Error("Not a redirect error");
2539    }
2540    return error.digest.split(";", 2)[1];
2541}
2542function getRedirectStatusCodeFromError(error) {
2543    if (!isRedirectError(error)) {
2544        throw new Error("Not a redirect error");
2545    }
2546    return Number(error.digest.split(";", 4)[3]);
2547}
2548if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2549    Object.defineProperty(exports.default, "__esModule", {
2550        value: true
2551    });
2552    Object.assign(exports.default, exports);
2553    module.exports = exports.default;
2554} //# sourceMappingURL=redirect.js.map
2555
2556
2557/***/ }),
2558
2559/***/ 1433:
2560/***/ (function(module, exports, __webpack_require__) {
2561
2562"use strict";
2563/* __next_internal_client_entry_do_not_use__  cjs */ 
2564Object.defineProperty(exports, "__esModule", ({
2565    value: true
2566}));
2567Object.defineProperty(exports, "default", ({
2568    enumerable: true,
2569    get: function() {
2570        return RenderFromTemplateContext;
2571    }
2572}));
2573const _interop_require_wildcard = __webpack_require__(3589);
2574const _jsxruntime = __webpack_require__(1411);
2575const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
2576const _approutercontextsharedruntime = __webpack_require__(1214);
2577function RenderFromTemplateContext() {
2578    const children = (0, _react.useContext)(_approutercontextsharedruntime.TemplateContext);
2579    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
2580        children: children
2581    });
2582}
2583if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2584    Object.defineProperty(exports.default, "__esModule", {
2585        value: true
2586    });
2587    Object.assign(exports.default, exports);
2588    module.exports = exports.default;
2589} //# sourceMappingURL=render-from-template-context.js.map
2590
2591
2592/***/ }),
2593
2594/***/ 7899:
2595/***/ (function(module, exports, __webpack_require__) {
2596
2597"use strict";
2598
2599Object.defineProperty(exports, "__esModule", ({
2600    value: true
2601}));
2602Object.defineProperty(exports, "requestAsyncStorage", ({
2603    enumerable: true,
2604    get: function() {
2605        return requestAsyncStorage;
2606    }
2607}));
2608const _asynclocalstorage = __webpack_require__(2532);
2609const requestAsyncStorage = (0, _asynclocalstorage.createAsyncLocalStorage)();
2610if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2611    Object.defineProperty(exports.default, "__esModule", {
2612        value: true
2613    });
2614    Object.assign(exports.default, exports);
2615    module.exports = exports.default;
2616} //# sourceMappingURL=request-async-storage.external.js.map
2617
2618
2619/***/ }),
2620
2621/***/ 2732:
2622/***/ (function(module, exports, __webpack_require__) {
2623
2624"use strict";
2625
2626Object.defineProperty(exports, "__esModule", ({
2627    value: true
2628}));
2629Object.defineProperty(exports, "applyFlightData", ({
2630    enumerable: true,
2631    get: function() {
2632        return applyFlightData;
2633    }
2634}));
2635const _filllazyitemstillleafwithhead = __webpack_require__(3866);
2636const _fillcachewithnewsubtreedata = __webpack_require__(4268);
2637function applyFlightData(existingCache, cache, flightDataPath, wasPrefetched) {
2638    if (wasPrefetched === void 0) wasPrefetched = false;
2639    // The one before last item is the router state tree patch
2640    const [treePatch, cacheNodeSeedData, head] = flightDataPath.slice(-3);
2641    // Handles case where prefetch only returns the router tree patch without rendered components.
2642    if (cacheNodeSeedData === null) {
2643        return false;

2644    }
2645    if (flightDataPath.length === 3) {
2646        const rsc = cacheNodeSeedData[2];
2647        cache.rsc = rsc;
2648        // This is a PPR-only field. When PPR is enabled, we shouldn't hit
2649        // this path during a navigation, but until PPR is fully implemented
2650        // yet it's possible the existing node does have a non-null
2651        // `prefetchRsc`. As an incremental step, we'll just de-opt to the
2652        // old behavior â no PPR value.
2653        cache.prefetchRsc = null;
2654        (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(cache, existingCache, treePatch, cacheNodeSeedData, head, wasPrefetched);
2655    } else {
2656        // Copy rsc for the root node of the cache.
2657        cache.rsc = existingCache.rsc;
2658        // This is a PPR-only field. Unlike the previous branch, since we're
2659        // just cloning the existing cache node, we might as well keep the
2660        // PPR value, if it exists.
2661        cache.prefetchRsc = existingCache.prefetchRsc;
2662        cache.parallelRoutes = new Map(existingCache.parallelRoutes);
2663        // Create a copy of the existing cache with the rsc applied.
2664        (0, _fillcachewithnewsubtreedata.fillCacheWithNewSubTreeData)(cache, existingCache, flightDataPath, wasPrefetched);
2665    }
2666    return true;
2667}
2668if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2669    Object.defineProperty(exports.default, "__esModule", {
2670        value: true
2671    });
2672    Object.assign(exports.default, exports);
2673    module.exports = exports.default;
2674} //# sourceMappingURL=apply-flight-data.js.map
2675
2676
2677/***/ }),
2678
2679/***/ 817:
2680/***/ (function(module, exports, __webpack_require__) {
2681
2682"use strict";
2683
2684Object.defineProperty(exports, "__esModule", ({
2685    value: true
2686}));
26870 && (0);
2688function _export(target, all) {
2689    for(var name in all)Object.defineProperty(target, name, {
2690        enumerable: true,
2691        get: all[name]
2692    });
2693}
2694_export(exports, {
2695    applyRouterStatePatchToFullTree: function() {
2696        return applyRouterStatePatchToFullTree;
2697    },
2698    applyRouterStatePatchToTreeSkipDefault: function() {
2699        return applyRouterStatePatchToTreeSkipDefault;
2700    }
2701});
2702const _segment = __webpack_require__(1956);
2703const _matchsegments = __webpack_require__(1118);
2704/**
2705 * Deep merge of the two router states. Parallel route keys are preserved if the patch doesn't have them.
2706 */ function applyPatch(initialTree, patchTree, applyPatchToDefaultSegment) {
2707    if (applyPatchToDefaultSegment === void 0) applyPatchToDefaultSegment = false;
2708    const [initialSegment, initialParallelRoutes] = initialTree;
2709    const [patchSegment, patchParallelRoutes] = patchTree;
2710    // if the applied patch segment is __DEFAULT__ then it can be ignored in favor of the initial tree
2711    // this is because the __DEFAULT__ segment is used as a placeholder on navigation
2712    // however, there are cases where we _do_ want to apply the patch to the default segment,
2713    // such as when revalidating the router cache with router.refresh/revalidatePath
2714    if (!applyPatchToDefaultSegment && patchSegment === _segment.DEFAULT_SEGMENT_KEY && initialSegment !== _segment.DEFAULT_SEGMENT_KEY) {
2715        return initialTree;
2716    }
2717    if ((0, _matchsegments.matchSegment)(initialSegment, patchSegment)) {
2718        const newParallelRoutes = {};
2719        for(const key in initialParallelRoutes){
2720            const isInPatchTreeParallelRoutes = typeof patchParallelRoutes[key] !== "undefined";
2721            if (isInPatchTreeParallelRoutes) {
2722                newParallelRoutes[key] = applyPatch(initialParallelRoutes[key], patchParallelRoutes[key], applyPatchToDefaultSegment);
2723            } else {
2724                newParallelRoutes[key] = initialParallelRoutes[key];
2725            }
2726        }
2727        for(const key in patchParallelRoutes){
2728            if (newParallelRoutes[key]) {
2729                continue;
2730            }
2731            newParallelRoutes[key] = patchParallelRoutes[key];
2732        }
2733        const tree = [
2734            initialSegment,
2735            newParallelRoutes
2736        ];
2737        if (initialTree[2]) {
2738            tree[2] = initialTree[2];
2739        }
2740        if (initialTree[3]) {
2741            tree[3] = initialTree[3];
2742        }
2743        if (initialTree[4]) {
2744            tree[4] = initialTree[4];
2745        }
2746        return tree;
2747    }
2748    return patchTree;
2749}
2750function applyRouterStatePatchToTreeImpl(flightSegmentPath, flightRouterState, treePatch, applyPatchDefaultSegment) {

2751    if (applyPatchDefaultSegment === void 0) applyPatchDefaultSegment = false;
2752    const [segment, parallelRoutes, , , isRootLayout] = flightRouterState;
2753    // Root refresh
2754    if (flightSegmentPath.length === 1) {
2755        const tree = applyPatch(flightRouterState, treePatch, applyPatchDefaultSegment);
2756        return tree;
2757    }
2758    const [currentSegment, parallelRouteKey] = flightSegmentPath;
2759    // Tree path returned from the server should always match up with the current tree in the browser
2760    if (!(0, _matchsegments.matchSegment)(currentSegment, segment)) {
2761        return null;
2762    }
2763    const lastSegment = flightSegmentPath.length === 2;
2764    let parallelRoutePatch;
2765    if (lastSegment) {
2766        parallelRoutePatch = applyPatch(parallelRoutes[parallelRouteKey], treePatch, applyPatchDefaultSegment);
2767    } else {
2768        parallelRoutePatch = applyRouterStatePatchToTreeImpl(flightSegmentPath.slice(2), parallelRoutes[parallelRouteKey], treePatch, applyPatchDefaultSegment);
2769        if (parallelRoutePatch === null) {
2770            return null;
2771        }
2772    }
2773    const tree = [
2774        flightSegmentPath[0],
2775        {
2776            ...parallelRoutes,
2777            [parallelRouteKey]: parallelRoutePatch
2778        }
2779    ];
2780    // Current segment is the root layout
2781    if (isRootLayout) {
2782        tree[4] = true;
2783    }
2784    return tree;
2785}
2786function applyRouterStatePatchToFullTree(flightSegmentPath, flightRouterState, treePatch) {
2787    return applyRouterStatePatchToTreeImpl(flightSegmentPath, flightRouterState, treePatch, true);
2788}
2789function applyRouterStatePatchToTreeSkipDefault(flightSegmentPath, flightRouterState, treePatch) {
2790    return applyRouterStatePatchToTreeImpl(flightSegmentPath, flightRouterState, treePatch, false);
2791}
2792if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2793    Object.defineProperty(exports.default, "__esModule", {
2794        value: true
2795    });
2796    Object.assign(exports.default, exports);
2797    module.exports = exports.default;
2798} //# sourceMappingURL=apply-router-state-patch-to-tree.js.map
2799
2800
2801/***/ }),
2802
2803/***/ 9650:
2804/***/ (function(module, exports, __webpack_require__) {
2805
2806"use strict";
2807
2808Object.defineProperty(exports, "__esModule", ({
2809    value: true
2810}));
28110 && (0);
2812function _export(target, all) {
2813    for(var name in all)Object.defineProperty(target, name, {
2814        enumerable: true,
2815        get: all[name]
2816    });
2817}
2818_export(exports, {
2819    extractPathFromFlightRouterState: function() {
2820        return extractPathFromFlightRouterState;
2821    },
2822    computeChangedPath: function() {
2823        return computeChangedPath;
2824    }
2825});
2826const _interceptionroutes = __webpack_require__(5859);
2827const _segment = __webpack_require__(1956);
2828const _matchsegments = __webpack_require__(1118);
2829const removeLeadingSlash = (segment)=>{
2830    return segment[0] === "/" ? segment.slice(1) : segment;
2831};
2832const segmentToPathname = (segment)=>{
2833    if (typeof segment === "string") {
2834        return segment;
2835    }
2836    return segment[1];
2837};
2838function normalizeSegments(segments) {
2839    return segments.reduce((acc, segment)=>{
2840        segment = removeLeadingSlash(segment);
2841        if (segment === "" || (0, _segment.isGroupSegment)(segment)) {
2842            return acc;
2843        }
2844        return acc + "/" + segment;
2845    }, "") || "/";
2846}
2847function extractPathFromFlightRouterState(flightRouterState) {
2848    const segment = Array.isArray(flightRouterState[0]) ? flightRouterState[0][1] : flightRouterState[0];
2849    if (segment === _segment.DEFAULT_SEGMENT_KEY || _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>segment.startsWith(m))) return undefined;
2850    if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) return "";
2851    const segments = [
2852        segment
2853    ];
2854    var _flightRouterState_;
2855    const parallelRoutes = (_flightRouterState_ = flightRouterState[1]) != null ? _flightRouterState_ : {};
2856    const childrenPath = parallelRoutes.children ? extractPathFromFlightRouterState(parallelRoutes.children) : undefined;
2857    if (childrenPath !== undefined) {
2858        segments.push(childrenPath);
2859    } else {
2860        for (const [key, value] of Object.entries(parallelRoutes)){
2861            if (key === "children") continue;
2862            const childPath = extractPathFromFlightRouterState(value);
2863            if (childPath !== undefined) {
2864                segments.push(childPath);
2865            }
2866        }
2867    }
2868    return normalizeSegments(segments);
2869}
2870function computeChangedPathImpl(treeA, treeB) {
2871    const [segmentA, parallelRoutesA] = treeA;
2872    const [segmentB, parallelRoutesB] = treeB;
2873    const normalizedSegmentA = segmentToPathname(segmentA);
2874    const normalizedSegmentB = segmentToPathname(segmentB);
2875    if (_interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>normalizedSegmentA.startsWith(m) || normalizedSegmentB.startsWith(m))) {
2876        return "";
2877    }
2878    if (!(0, _matchsegments.matchSegment)(segmentA, segmentB)) {
2879        var _extractPathFromFlightRouterState;
2880        // once we find where the tree changed, we compute the rest of the path by traversing the tree
2881        return (_extractPathFromFlightRouterState = extractPathFromFlightRouterState(treeB)) != null ? _extractPathFromFlightRouterState : "";
2882    }
2883    for(const parallelRouterKey in parallelRoutesA){
2884        if (parallelRoutesB[parallelRouterKey]) {
2885            const changedPath = computeChangedPathImpl(parallelRoutesA[parallelRouterKey], parallelRoutesB[parallelRouterKey]);
2886            if (changedPath !== null) {
2887                return segmentToPathname(segmentB) + "/" + changedPath;
2888            }
2889        }
2890    }
2891    return null;
2892}
2893function computeChangedPath(treeA, treeB) {
2894    const changedPath = computeChangedPathImpl(treeA, treeB);
2895    if (changedPath == null || changedPath === "/") {
2896        return changedPath;
2897    }
2898    // lightweight normalization to remove route groups
2899    return normalizeSegments(changedPath.split("/"));
2900}
2901if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2902    Object.defineProperty(exports.default, "__esModule", {
2903        value: true
2904    });

2905    Object.assign(exports.default, exports);
2906    module.exports = exports.default;
2907} //# sourceMappingURL=compute-changed-path.js.map
2908
2909
2910/***/ }),
2911
2912/***/ 6690:
2913/***/ (function(module, exports) {
2914
2915"use strict";
2916
2917Object.defineProperty(exports, "__esModule", ({
2918    value: true
2919}));
2920Object.defineProperty(exports, "createHrefFromUrl", ({
2921    enumerable: true,
2922    get: function() {
2923        return createHrefFromUrl;
2924    }
2925}));
2926function createHrefFromUrl(url, includeHash) {
2927    if (includeHash === void 0) includeHash = true;
2928    return url.pathname + url.search + (includeHash ? url.hash : "");
2929}
2930if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2931    Object.defineProperty(exports.default, "__esModule", {
2932        value: true
2933    });
2934    Object.assign(exports.default, exports);
2935    module.exports = exports.default;
2936} //# sourceMappingURL=create-href-from-url.js.map
2937
2938
2939/***/ }),
2940
2941/***/ 8661:
2942/***/ (function(module, exports, __webpack_require__) {
2943
2944"use strict";
2945
2946Object.defineProperty(exports, "__esModule", ({
2947    value: true
2948}));
2949Object.defineProperty(exports, "createInitialRouterState", ({
2950    enumerable: true,
2951    get: function() {
2952        return createInitialRouterState;
2953    }
2954}));
2955const _createhreffromurl = __webpack_require__(6690);
2956const _filllazyitemstillleafwithhead = __webpack_require__(3866);
2957const _computechangedpath = __webpack_require__(9650);
2958function createInitialRouterState(param) {
2959    let { buildId, initialTree, initialSeedData, initialCanonicalUrl, initialParallelRoutes, isServer, location, initialHead } = param;
2960    const rsc = initialSeedData[2];
2961    const cache = {
2962        lazyData: null,
2963        rsc: rsc,
2964        prefetchRsc: null,
2965        // The cache gets seeded during the first render. `initialParallelRoutes` ensures the cache from the first render is there during the second render.
2966        parallelRoutes: isServer ? new Map() : initialParallelRoutes
2967    };
2968    // When the cache hasn't been seeded yet we fill the cache with the head.
2969    if (initialParallelRoutes === null || initialParallelRoutes.size === 0) {
2970        (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(cache, undefined, initialTree, initialSeedData, initialHead);
2971    }
2972    var _ref;
2973    return {
2974        buildId,
2975        tree: initialTree,
2976        cache,
2977        prefetchCache: new Map(),
2978        pushRef: {
2979            pendingPush: false,
2980            mpaNavigation: false,
2981            // First render needs to preserve the previous window.history.state
2982            // to avoid it being overwritten on navigation back/forward with MPA Navigation.
2983            preserveCustomHistoryState: true
2984        },
2985        focusAndScrollRef: {
2986            apply: false,
2987            onlyHashChange: false,
2988            hashFragment: null,
2989            segmentPaths: []
2990        },
2991        canonicalUrl: // This is safe to do as canonicalUrl can't be rendered, it's only used to control the history updates in the useEffect further down in this file.
2992        location ? (0, _createhreffromurl.createHrefFromUrl)(location) : initialCanonicalUrl,
2993        nextUrl: (_ref = (0, _computechangedpath.extractPathFromFlightRouterState)(initialTree) || (location == null ? void 0 : location.pathname)) != null ? _ref : null
2994    };
2995}
2996if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
2997    Object.defineProperty(exports.default, "__esModule", {
2998        value: true
2999    });
3000    Object.assign(exports.default, exports);
3001    module.exports = exports.default;
3002} //# sourceMappingURL=create-initial-router-state.js.map
3003
3004
3005/***/ }),
3006
3007/***/ 7310:
3008/***/ (function(module, exports, __webpack_require__) {
3009
3010"use strict";
3011
3012Object.defineProperty(exports, "__esModule", ({
3013    value: true
3014}));
3015Object.defineProperty(exports, "createRouterCacheKey", ({
3016    enumerable: true,
3017    get: function() {
3018        return createRouterCacheKey;
3019    }
3020}));
3021const _segment = __webpack_require__(1956);
3022function createRouterCacheKey(segment, withoutSearchParameters) {
3023    if (withoutSearchParameters === void 0) withoutSearchParameters = false;

3024    // if the segment is an array, it means it's a dynamic segment
3025    // for example, ['lang', 'en', 'd']. We need to convert it to a string to store it as a cache node key.
3026    if (Array.isArray(segment)) {
3027        return (segment[0] + "|" + segment[1] + "|" + segment[2]).toLowerCase();
3028    }
3029    // Page segments might have search parameters, ie __PAGE__?foo=bar
3030    // When `withoutSearchParameters` is true, we only want to return the page segment
3031    if (withoutSearchParameters && segment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
3032        return _segment.PAGE_SEGMENT_KEY;
3033    }
3034    return segment;
3035}
3036if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3037    Object.defineProperty(exports.default, "__esModule", {
3038        value: true
3039    });
3040    Object.assign(exports.default, exports);
3041    module.exports = exports.default;
3042} //# sourceMappingURL=create-router-cache-key.js.map
3043
3044
3045/***/ }),
3046
3047/***/ 5501:
3048/***/ (function(module, exports, __webpack_require__) {
3049
3050"use strict";
3051/* __next_internal_client_entry_do_not_use__  cjs */ 
3052Object.defineProperty(exports, "__esModule", ({
3053    value: true
3054}));
3055Object.defineProperty(exports, "fetchServerResponse", ({
3056    enumerable: true,
3057    get: function() {
3058        return fetchServerResponse;
3059    }
3060}));
3061const _approuterheaders = __webpack_require__(5767);
3062const _approuter = __webpack_require__(9985);
3063const _appcallserver = __webpack_require__(714);
3064const _routerreducertypes = __webpack_require__(1606);
3065const _hash = __webpack_require__(3178);
3066// @ts-ignore
3067// eslint-disable-next-line import/no-extraneous-dependencies
3068// import { createFromFetch } from 'react-server-dom-webpack/client'
3069const { createFromFetch } =  false ? 0 : __webpack_require__(5552);
3070function doMpaNavigation(url) {
3071    return [
3072        (0, _approuter.urlToUrlWithoutFlightMarker)(url).toString(),
3073        undefined
3074    ];
3075}
3076async function fetchServerResponse(url, flightRouterState, nextUrl, currentBuildId, prefetchKind) {
3077    const headers = {
3078        // Enable flight response
3079        [_approuterheaders.RSC_HEADER]: "1",
3080        // Provide the current router state
3081        [_approuterheaders.NEXT_ROUTER_STATE_TREE]: encodeURIComponent(JSON.stringify(flightRouterState))
3082    };
3083    /**
3084   * Three cases:
3085   * - `prefetchKind` is `undefined`, it means it's a normal navigation, so we want to prefetch the page data fully
3086   * - `prefetchKind` is `full` - we want to prefetch the whole page so same as above
3087   * - `prefetchKind` is `auto` - if the page is dynamic, prefetch the page data partially, if static prefetch the page data fully
3088   */ if (prefetchKind === _routerreducertypes.PrefetchKind.AUTO) {
3089        headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = "1";
3090    }
3091    if (nextUrl) {
3092        headers[_approuterheaders.NEXT_URL] = nextUrl;
3093    }
3094    const uniqueCacheQuery = (0, _hash.hexHash)([
3095        headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] || "0",
3096        headers[_approuterheaders.NEXT_ROUTER_STATE_TREE],
3097        headers[_approuterheaders.NEXT_URL]
3098    ].join(","));
3099    try {
3100        let fetchUrl = new URL(url);
3101        if (true) {
3102            if (false) {}
3103        }
3104        // Add unique cache query to avoid caching conflicts on CDN which don't respect to Vary header
3105        fetchUrl.searchParams.set(_approuterheaders.NEXT_RSC_UNION_QUERY, uniqueCacheQuery);
3106        const res = await fetch(fetchUrl, {
3107            // Backwards compat for older browsers. `same-origin` is the default in modern browsers.
3108            credentials: "same-origin",
3109            headers
3110        });
3111        const responseUrl = (0, _approuter.urlToUrlWithoutFlightMarker)(res.url);
3112        const canonicalUrl = res.redirected ? responseUrl : undefined;
3113        const contentType = res.headers.get("content-type") || "";
3114        const postponed = !!res.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER);
3115        let isFlightResponse = contentType === _approuterheaders.RSC_CONTENT_TYPE_HEADER;
3116        if (true) {
3117            if (false) {}
3118        }
3119        // If fetch returns something different than flight response handle it like a mpa navigation
3120        // If the fetch was not 200, we also handle it like a mpa navigation
3121        if (!isFlightResponse || !res.ok) {
3122            // in case the original URL came with a hash, preserve it before redirecting to the new URL
3123            if (url.hash) {
3124                responseUrl.hash = url.hash;
3125            }
3126            return doMpaNavigation(responseUrl.toString());
3127        }
3128        // Handle the `fetch` readable stream that can be unwrapped by `React.use`.
3129        const [buildId, flightData] = await createFromFetch(Promise.resolve(res), {
3130            callServer: _appcallserver.callServer
3131        });
3132        if (currentBuildId !== buildId) {
3133            return doMpaNavigation(res.url);
3134        }
3135        return [
3136            flightData,
3137            canonicalUrl,
3138            postponed
3139        ];
3140    } catch (err) {
3141        console.error("Failed to fetch RSC payload for " + url + ". Falling back to browser navigation.", err);
3142        // If fetch fails handle it like a mpa navigation
3143        // TODO-APP: Add a test for the case where a CORS request fails, e.g. external url redirect coming from the response.
3144        // See https://github.com/vercel/next.js/issues/43605#issuecomment-1451617521 for a reproduction.
3145        return [
3146            url.toString(),
3147            undefined
3148        ];
3149    }
3150}
3151if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3152    Object.defineProperty(exports.default, "__esModule", {
3153        value: true
3154    });

3155    Object.assign(exports.default, exports);
3156    module.exports = exports.default;
3157} //# sourceMappingURL=fetch-server-response.js.map
3158
3159
3160/***/ }),
3161
3162/***/ 4005:
3163/***/ (function(module, exports, __webpack_require__) {
3164
3165"use strict";
3166
3167Object.defineProperty(exports, "__esModule", ({
3168    value: true
3169}));
3170Object.defineProperty(exports, "fillCacheWithDataProperty", ({
3171    enumerable: true,
3172    get: function() {
3173        return fillCacheWithDataProperty;
3174    }
3175}));
3176const _createroutercachekey = __webpack_require__(7310);
3177function fillCacheWithDataProperty(newCache, existingCache, flightSegmentPath, fetchResponse) {
3178    const isLastEntry = flightSegmentPath.length <= 2;
3179    const [parallelRouteKey, segment] = flightSegmentPath;
3180    const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
3181    const existingChildSegmentMap = existingCache.parallelRoutes.get(parallelRouteKey);
3182    let childSegmentMap = newCache.parallelRoutes.get(parallelRouteKey);
3183    if (!childSegmentMap || childSegmentMap === existingChildSegmentMap) {
3184        childSegmentMap = new Map(existingChildSegmentMap);
3185        newCache.parallelRoutes.set(parallelRouteKey, childSegmentMap);
3186    }
3187    const existingChildCacheNode = existingChildSegmentMap == null ? void 0 : existingChildSegmentMap.get(cacheKey);
3188    let childCacheNode = childSegmentMap.get(cacheKey);
3189    // In case of last segment start off the fetch at this level and don't copy further down.
3190    if (isLastEntry) {
3191        if (!childCacheNode || !childCacheNode.lazyData || childCacheNode === existingChildCacheNode) {
3192            childSegmentMap.set(cacheKey, {
3193                lazyData: fetchResponse(),
3194                rsc: null,
3195                prefetchRsc: null,
3196                parallelRoutes: new Map()
3197            });
3198        }
3199        return;
3200    }
3201    if (!childCacheNode || !existingChildCacheNode) {
3202        // Start fetch in the place where the existing cache doesn't have the data yet.
3203        if (!childCacheNode) {
3204            childSegmentMap.set(cacheKey, {
3205                lazyData: fetchResponse(),
3206                rsc: null,
3207                prefetchRsc: null,
3208                parallelRoutes: new Map()
3209            });
3210        }
3211        return;
3212    }
3213    if (childCacheNode === existingChildCacheNode) {
3214        childCacheNode = {
3215            lazyData: childCacheNode.lazyData,
3216            rsc: childCacheNode.rsc,
3217            prefetchRsc: childCacheNode.prefetchRsc,
3218            parallelRoutes: new Map(childCacheNode.parallelRoutes)
3219        };
3220        childSegmentMap.set(cacheKey, childCacheNode);
3221    }
3222    return fillCacheWithDataProperty(childCacheNode, existingChildCacheNode, flightSegmentPath.slice(2), fetchResponse);
3223}
3224if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3225    Object.defineProperty(exports.default, "__esModule", {
3226        value: true
3227    });
3228    Object.assign(exports.default, exports);
3229    module.exports = exports.default;
3230} //# sourceMappingURL=fill-cache-with-data-property.js.map
3231
3232
3233/***/ }),
3234
3235/***/ 4268:
3236/***/ (function(module, exports, __webpack_require__) {
3237
3238"use strict";
3239
3240Object.defineProperty(exports, "__esModule", ({
3241    value: true
3242}));
3243Object.defineProperty(exports, "fillCacheWithNewSubTreeData", ({
3244    enumerable: true,
3245    get: function() {
3246        return fillCacheWithNewSubTreeData;
3247    }
3248}));
3249const _invalidatecachebyrouterstate = __webpack_require__(4560);
3250const _filllazyitemstillleafwithhead = __webpack_require__(3866);
3251const _createroutercachekey = __webpack_require__(7310);
3252function fillCacheWithNewSubTreeData(newCache, existingCache, flightDataPath, wasPrefetched) {
3253    const isLastEntry = flightDataPath.length <= 5;
3254    const [parallelRouteKey, segment] = flightDataPath;
3255    const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
3256    const existingChildSegmentMap = existingCache.parallelRoutes.get(parallelRouteKey);
3257    if (!existingChildSegmentMap) {
3258        // Bailout because the existing cache does not have the path to the leaf node

3259        // Will trigger lazy fetch in layout-router because of missing segment
3260        return;
3261    }
3262    let childSegmentMap = newCache.parallelRoutes.get(parallelRouteKey);
3263    if (!childSegmentMap || childSegmentMap === existingChildSegmentMap) {
3264        childSegmentMap = new Map(existingChildSegmentMap);
3265        newCache.parallelRoutes.set(parallelRouteKey, childSegmentMap);
3266    }
3267    const existingChildCacheNode = existingChildSegmentMap.get(cacheKey);
3268    let childCacheNode = childSegmentMap.get(cacheKey);
3269    if (isLastEntry) {
3270        if (!childCacheNode || !childCacheNode.lazyData || childCacheNode === existingChildCacheNode) {
3271            const seedData = flightDataPath[3];
3272            const rsc = seedData[2];
3273            childCacheNode = {
3274                lazyData: null,
3275                rsc,
3276                prefetchRsc: null,
3277                // Ensure segments other than the one we got data for are preserved.
3278                parallelRoutes: existingChildCacheNode ? new Map(existingChildCacheNode.parallelRoutes) : new Map()
3279            };
3280            if (existingChildCacheNode) {
3281                (0, _invalidatecachebyrouterstate.invalidateCacheByRouterState)(childCacheNode, existingChildCacheNode, flightDataPath[2]);
3282            }
3283            (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(childCacheNode, existingChildCacheNode, flightDataPath[2], seedData, flightDataPath[4], wasPrefetched);
3284            childSegmentMap.set(cacheKey, childCacheNode);
3285        }
3286        return;
3287    }
3288    if (!childCacheNode || !existingChildCacheNode) {
3289        // Bailout because the existing cache does not have the path to the leaf node
3290        // Will trigger lazy fetch in layout-router because of missing segment
3291        return;
3292    }
3293    if (childCacheNode === existingChildCacheNode) {
3294        childCacheNode = {
3295            lazyData: childCacheNode.lazyData,
3296            rsc: childCacheNode.rsc,
3297            prefetchRsc: childCacheNode.prefetchRsc,
3298            parallelRoutes: new Map(childCacheNode.parallelRoutes)
3299        };
3300        childSegmentMap.set(cacheKey, childCacheNode);
3301    }
3302    fillCacheWithNewSubTreeData(childCacheNode, existingChildCacheNode, flightDataPath.slice(2), wasPrefetched);
3303}
3304if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3305    Object.defineProperty(exports.default, "__esModule", {
3306        value: true
3307    });
3308    Object.assign(exports.default, exports);
3309    module.exports = exports.default;
3310} //# sourceMappingURL=fill-cache-with-new-subtree-data.js.map
3311
3312
3313/***/ }),
3314
3315/***/ 3866:
3316/***/ (function(module, exports, __webpack_require__) {
3317
3318"use strict";
3319
3320Object.defineProperty(exports, "__esModule", ({
3321    value: true
3322}));
3323Object.defineProperty(exports, "fillLazyItemsTillLeafWithHead", ({
3324    enumerable: true,
3325    get: function() {
3326        return fillLazyItemsTillLeafWithHead;
3327    }
3328}));
3329const _createroutercachekey = __webpack_require__(7310);
3330function fillLazyItemsTillLeafWithHead(newCache, existingCache, routerState, cacheNodeSeedData, head, wasPrefetched) {
3331    const isLastSegment = Object.keys(routerState[1]).length === 0;
3332    if (isLastSegment) {
3333        newCache.head = head;
3334        return;
3335    }
3336    // Remove segment that we got data for so that it is filled in during rendering of rsc.
3337    for(const key in routerState[1]){
3338        const parallelRouteState = routerState[1][key];
3339        const segmentForParallelRoute = parallelRouteState[0];
3340        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segmentForParallelRoute);
3341        // TODO: We should traverse the cacheNodeSeedData tree instead of the router
3342        // state tree. Ideally, they would always be the same shape, but because of
3343        // the loading.js pattern, cacheNodeSeedData sometimes only represents a
3344        // partial tree. That's why this node is sometimes null. Once PPR lands,
3345        // loading.js will no longer have special behavior and we can traverse the
3346        // data tree instead.
3347        //
3348        // We should also consider merging the router state tree and the data tree
3349        // in the response format, so that we don't have to send the keys twice.
3350        // Then the client can convert them into separate representations.
3351        const parallelSeedData = cacheNodeSeedData !== null && cacheNodeSeedData[1][key] !== undefined ? cacheNodeSeedData[1][key] : null;
3352        if (existingCache) {
3353            const existingParallelRoutesCacheNode = existingCache.parallelRoutes.get(key);
3354            if (existingParallelRoutesCacheNode) {
3355                let parallelRouteCacheNode = new Map(existingParallelRoutesCacheNode);
3356                const existingCacheNode = parallelRouteCacheNode.get(cacheKey);
3357                let newCacheNode;
3358                if (parallelSeedData !== null) {
3359                    // New data was sent from the server.
3360                    const seedNode = parallelSeedData[2];
3361                    newCacheNode = {
3362                        lazyData: null,
3363                        rsc: seedNode,
3364                        // This is a PPR-only field. When PPR is enabled, we shouldn't hit
3365                        // this path during a navigation, but until PPR is fully implemented
3366                        // yet it's possible the existing node does have a non-null
3367                        // `prefetchRsc`. As an incremental step, we'll just de-opt to the
3368                        // old behavior â no PPR value.
3369                        prefetchRsc: null,
3370                        parallelRoutes: new Map(existingCacheNode == null ? void 0 : existingCacheNode.parallelRoutes)
3371                    };
3372                } else if (wasPrefetched && existingCacheNode) {
3373                    // No new data was sent from the server, but the existing cache node
3374                    // was prefetched, so we should reuse that.
3375                    newCacheNode = {
3376                        lazyData: existingCacheNode.lazyData,
3377                        rsc: existingCacheNode.rsc,
3378                        // This is a PPR-only field. Unlike the previous branch, since we're
3379                        // just cloning the existing cache node, we might as well keep the
3380                        // PPR value, if it exists.
3381                        prefetchRsc: existingCacheNode.prefetchRsc,
3382                        parallelRoutes: new Map(existingCacheNode.parallelRoutes)
3383                    };
3384                } else {
3385                    // No data available for this node. This will trigger a lazy fetch
3386                    // during render.
3387                    newCacheNode = {
3388                        lazyData: null,
3389                        rsc: null,
3390                        prefetchRsc: null,
3391                        parallelRoutes: new Map(existingCacheNode == null ? void 0 : existingCacheNode.parallelRoutes)
3392                    };
3393                }
3394                // Overrides the cache key with the new cache node.
3395                parallelRouteCacheNode.set(cacheKey, newCacheNode);
3396                // Traverse deeper to apply the head / fill lazy items till the head.
3397                fillLazyItemsTillLeafWithHead(newCacheNode, existingCacheNode, parallelRouteState, parallelSeedData ? parallelSeedData : null, head, wasPrefetched);
3398                newCache.parallelRoutes.set(key, parallelRouteCacheNode);
3399                continue;
3400            }
3401        }
3402        let newCacheNode;
3403        if (parallelSeedData !== null) {
3404            // New data was sent from the server.
3405            const seedNode = parallelSeedData[2];
3406            newCacheNode = {
3407                lazyData: null,
3408                rsc: seedNode,
3409                prefetchRsc: null,
3410                parallelRoutes: new Map()
3411            };
3412        } else {
3413            // No data available for this node. This will trigger a lazy fetch
3414            // during render.
3415            newCacheNode = {
3416                lazyData: null,
3417                rsc: null,
3418                prefetchRsc: null,
3419                parallelRoutes: new Map()
3420            };
3421        }
3422        const existingParallelRoutes = newCache.parallelRoutes.get(key);
3423        if (existingParallelRoutes) {
3424            existingParallelRoutes.set(cacheKey, newCacheNode);
3425        } else {
3426            newCache.parallelRoutes.set(key, new Map([
3427                [
3428                    cacheKey,
3429                    newCacheNode
3430                ]
3431            ]));
3432        }
3433        fillLazyItemsTillLeafWithHead(newCacheNode, undefined, parallelRouteState, parallelSeedData, head, wasPrefetched);
3434    }
3435}
3436if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3437    Object.defineProperty(exports.default, "__esModule", {
3438        value: true
3439    });

3440    Object.assign(exports.default, exports);
3441    module.exports = exports.default;
3442} //# sourceMappingURL=fill-lazy-items-till-leaf-with-head.js.map
3443
3444
3445/***/ }),
3446
3447/***/ 450:
3448/***/ (function(module, exports) {
3449
3450"use strict";
3451
3452Object.defineProperty(exports, "__esModule", ({
3453    value: true
3454}));
34550 && (0);
3456function _export(target, all) {
3457    for(var name in all)Object.defineProperty(target, name, {
3458        enumerable: true,
3459        get: all[name]
3460    });
3461}
3462_export(exports, {
3463    PrefetchCacheEntryStatus: function() {
3464        return PrefetchCacheEntryStatus;
3465    },
3466    getPrefetchEntryCacheStatus: function() {
3467        return getPrefetchEntryCacheStatus;
3468    }
3469});
3470const FIVE_MINUTES = 5 * 60 * 1000;
3471const THIRTY_SECONDS = 30 * 1000;
3472var PrefetchCacheEntryStatus;
3473(function(PrefetchCacheEntryStatus) {
3474    PrefetchCacheEntryStatus["fresh"] = "fresh";
3475    PrefetchCacheEntryStatus["reusable"] = "reusable";
3476    PrefetchCacheEntryStatus["expired"] = "expired";
3477    PrefetchCacheEntryStatus["stale"] = "stale";
3478})(PrefetchCacheEntryStatus || (PrefetchCacheEntryStatus = {}));
3479function getPrefetchEntryCacheStatus(param) {
3480    let { kind, prefetchTime, lastUsedTime } = param;
3481    // if the cache entry was prefetched or read less than 30s ago, then we want to re-use it
3482    if (Date.now() < (lastUsedTime != null ? lastUsedTime : prefetchTime) + THIRTY_SECONDS) {
3483        return lastUsedTime ? "reusable" : "fresh";
3484    }
3485    // if the cache entry was prefetched less than 5 mins ago, then we want to re-use only the loading state
3486    if (kind === "auto") {
3487        if (Date.now() < prefetchTime + FIVE_MINUTES) {
3488            return "stale";
3489        }
3490    }
3491    // if the cache entry was prefetched less than 5 mins ago and was a "full" prefetch, then we want to re-use it "full
3492    if (kind === "full") {
3493        if (Date.now() < prefetchTime + FIVE_MINUTES) {
3494            return "reusable";
3495        }
3496    }
3497    return "expired";
3498}
3499if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3500    Object.defineProperty(exports.default, "__esModule", {
3501        value: true
3502    });
3503    Object.assign(exports.default, exports);
3504    module.exports = exports.default;
3505} //# sourceMappingURL=get-prefetch-cache-entry-status.js.map
3506
3507
3508/***/ }),
3509
3510/***/ 8056:
3511/***/ (function(module, exports, __webpack_require__) {
3512
3513"use strict";
3514
3515Object.defineProperty(exports, "__esModule", ({
3516    value: true
3517}));
3518Object.defineProperty(exports, "handleMutable", ({
3519    enumerable: true,
3520    get: function() {
3521        return handleMutable;
3522    }
3523}));
3524const _computechangedpath = __webpack_require__(9650);
3525function isNotUndefined(value) {
3526    return typeof value !== "undefined";
3527}
3528function handleMutable(state, mutable) {
3529    var _mutable_canonicalUrl;
3530    var _mutable_shouldScroll;
3531    // shouldScroll is true by default, can override to false.
3532    const shouldScroll = (_mutable_shouldScroll = mutable.shouldScroll) != null ? _mutable_shouldScroll : true;
3533    let nextUrl = state.nextUrl;
3534    if (isNotUndefined(mutable.patchedTree)) {
3535        // If we received a patched tree, we need to compute the changed path.
3536        const changedPath = (0, _computechangedpath.computeChangedPath)(state.tree, mutable.patchedTree);
3537        if (changedPath) {
3538            // If the tree changed, we need to update the nextUrl
3539            nextUrl = changedPath;
3540        } else if (!nextUrl) {
3541            // if the tree ends up being the same (ie, no changed path), and we don't have a nextUrl, then we should use the canonicalUrl
3542            nextUrl = state.canonicalUrl;
3543        }
3544    // otherwise this will be a no-op and continue to use the existing nextUrl
3545    }
3546    var _mutable_scrollableSegments;
3547    return {
3548        buildId: state.buildId,
3549        // Set href.
3550        canonicalUrl: isNotUndefined(mutable.canonicalUrl) ? mutable.canonicalUrl === state.canonicalUrl ? state.canonicalUrl : mutable.canonicalUrl : state.canonicalUrl,
3551        pushRef: {
3552            pendingPush: isNotUndefined(mutable.pendingPush) ? mutable.pendingPush : state.pushRef.pendingPush,
3553            mpaNavigation: isNotUndefined(mutable.mpaNavigation) ? mutable.mpaNavigation : state.pushRef.mpaNavigation,
3554            preserveCustomHistoryState: isNotUndefined(mutable.preserveCustomHistoryState) ? mutable.preserveCustomHistoryState : state.pushRef.preserveCustomHistoryState
3555        },
3556        // All navigation requires scroll and focus management to trigger.
3557        focusAndScrollRef: {
3558            apply: shouldScroll ? isNotUndefined(mutable == null ? void 0 : mutable.scrollableSegments) ? true : state.focusAndScrollRef.apply : false,
3559            onlyHashChange: !!mutable.hashFragment && state.canonicalUrl.split("#", 1)[0] === ((_mutable_c

3559anonicalUrl = mutable.canonicalUrl) == null ? void 0 : _mutable_canonicalUrl.split("#", 1)[0]),
3560            hashFragment: shouldScroll ? mutable.hashFragment && mutable.hashFragment !== "" ? decodeURIComponent(mutable.hashFragment.slice(1)) : state.focusAndScrollRef.hashFragment : null,
3561            segmentPaths: shouldScroll ? (_mutable_scrollableSegments = mutable == null ? void 0 : mutable.scrollableSegments) != null ? _mutable_scrollableSegments : state.focusAndScrollRef.segmentPaths : []
3562        },
3563        // Apply cache.
3564        cache: mutable.cache ? mutable.cache : state.cache,
3565        prefetchCache: mutable.prefetchCache ? mutable.prefetchCache : state.prefetchCache,
3566        // Apply patched router state.
3567        tree: isNotUndefined(mutable.patchedTree) ? mutable.patchedTree : state.tree,
3568        nextUrl
3569    };
3570}
3571if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3572    Object.defineProperty(exports.default, "__esModule", {
3573        value: true
3574    });
3575    Object.assign(exports.default, exports);
3576    module.exports = exports.default;
3577} //# sourceMappingURL=handle-mutable.js.map
3578
3579
3580/***/ }),
3581
3582/***/ 5284:
3583/***/ (function(module, exports, __webpack_require__) {
3584
3585"use strict";
3586
3587Object.defineProperty(exports, "__esModule", ({
3588    value: true
3589}));
3590Object.defineProperty(exports, "invalidateCacheBelowFlightSegmentPath", ({
3591    enumerable: true,
3592    get: function() {
3593        return invalidateCacheBelowFlightSegmentPath;
3594    }
3595}));
3596const _createroutercachekey = __webpack_require__(7310);

3597function invalidateCacheBelowFlightSegmentPath(newCache, existingCache, flightSegmentPath) {
3598    const isLastEntry = flightSegmentPath.length <= 2;
3599    const [parallelRouteKey, segment] = flightSegmentPath;
3600    const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
3601    const existingChildSegmentMap = existingCache.parallelRoutes.get(parallelRouteKey);
3602    if (!existingChildSegmentMap) {
3603        // Bailout because the existing cache does not have the path to the leaf node
3604        // Will trigger lazy fetch in layout-router because of missing segment
3605        return;
3606    }
3607    let childSegmentMap = newCache.parallelRoutes.get(parallelRouteKey);
3608    if (!childSegmentMap || childSegmentMap === existingChildSegmentMap) {
3609        childSegmentMap = new Map(existingChildSegmentMap);
3610        newCache.parallelRoutes.set(parallelRouteKey, childSegmentMap);
3611    }
3612    // In case of last entry don't copy further down.
3613    if (isLastEntry) {
3614        childSegmentMap.delete(cacheKey);
3615        return;
3616    }
3617    const existingChildCacheNode = existingChildSegmentMap.get(cacheKey);
3618    let childCacheNode = childSegmentMap.get(cacheKey);
3619    if (!childCacheNode || !existingChildCacheNode) {
3620        // Bailout because the existing cache does not have the path to the leaf node
3621        // Will trigger lazy fetch in layout-router because of missing segment
3622        return;
3623    }
3624    if (childCacheNode === existingChildCacheNode) {
3625        childCacheNode = {
3626            lazyData: childCacheNode.lazyData,
3627            rsc: childCacheNode.rsc,
3628            prefetchRsc: childCacheNode.prefetchRsc,
3629            parallelRoutes: new Map(childCacheNode.parallelRoutes)
3630        };
3631        childSegmentMap.set(cacheKey, childCacheNode);
3632    }
3633    invalidateCacheBelowFlightSegmentPath(childCacheNode, existingChildCacheNode, flightSegmentPath.slice(2));
3634}
3635if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3636    Object.defineProperty(exports.default, "__esModule", {
3637        value: true
3638    });
3639    Object.assign(exports.default, exports);
3640    module.exports = exports.default;
3641} //# sourceMappingURL=invalidate-cache-below-flight-segmentpath.js.map
3642
3643
3644/***/ }),
3645
3646/***/ 4560:
3647/***/ (function(module, exports, __webpack_require__) {
3648
3649"use strict";
3650
3651Object.defineProperty(exports, "__esModule", ({
3652    value: true
3653}));
3654Object.defineProperty(exports, "invalidateCacheByRouterState", ({
3655    enumerable: true,
3656    get: function() {
3657        return invalidateCacheByRouterState;
3658    }
3659}));
3660const _createroutercachekey = __webpack_require__(7310);

3661function invalidateCacheByRouterState(newCache, existingCache, routerState) {
3662    // Remove segment that we got data for so that it is filled in during rendering of rsc.
3663    for(const key in routerState[1]){
3664        const segmentForParallelRoute = routerState[1][key][0];
3665        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segmentForParallelRoute);
3666        const existingParallelRoutesCacheNode = existingCache.parallelRoutes.get(key);
3667        if (existingParallelRoutesCacheNode) {
3668            let parallelRouteCacheNode = new Map(existingParallelRoutesCacheNode);
3669            parallelRouteCacheNode.delete(cacheKey);
3670            newCache.parallelRoutes.set(key, parallelRouteCacheNode);
3671        }
3672    }
3673}
3674if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3675    Object.defineProperty(exports.default, "__esModule", {
3676        value: true
3677    });
3678    Object.assign(exports.default, exports);
3679    module.exports = exports.default;
3680} //# sourceMappingURL=invalidate-cache-by-router-state.js.map
3681
3682
3683/***/ }),
3684
3685/***/ 3828:
3686/***/ (function(module, exports) {
3687
3688"use strict";
3689
3690Object.defineProperty(exports, "__esModule", ({
3691    value: true
3692}));
3693Object.defineProperty(exports, "isNavigatingToNewRootLayout", ({
3694    enumerable: true,
3695    get: function() {
3696        return isNavigatingToNewRootLayout;
3697    }
3698}));
3699function isNavigatingToNewRootLayout(currentTree, nextTree) {
3700    // Compare segments
3701    const currentTreeSegment = currentTree[0];
3702    const nextTreeSegment = nextTree[0];
3703    // If any segment is different before we find the root layout, the root layout has changed.
3704    // E.g. /same/(group1)/layout.js -> /same/(group2)/layout.js
3705    // First segment is 'same' for both, keep looking. (group1) changed to (group2) before the root layout was found, it must have changed.
3706    if (Array.isArray(currentTreeSegment) && Array.isArray(nextTreeSegment)) {
3707        // Compare dynamic param name and type but ignore the value, different values would not affect the current root layout
3708        // /[name] - /slug1 and /slug2, both values (slug1 & slug2) still has the same layout /[name]/layout.js
3709        if (currentTreeSegment[0] !== nextTreeSegment[0] || currentTreeSegment[2] !== nextTreeSegment[2]) {
3710            return true;
3711        }
3712    } else if (currentTreeSegment !== nextTreeSegment) {
3713        return true;
3714    }
3715    // Current tree root layout found
3716    if (currentTree[4]) {
3717        // If the next tree doesn't have the root layout flag, it must have changed.
3718        return !nextTree[4];
3719    }
3720    // Current tree  didn't have its root layout here, must have changed.
3721    if (nextTree[4]) {
3722        return true;
3723    }
3724    // We can't assume it's `parallelRoutes.children` here in case the root layout is `app/@something/layout.js`
3725    // But it's not possible to be more than one parallelRoutes before the root layout is found
3726    // TODO-APP: change to traverse all parallel routes
3727    const currentTreeChild = Object.values(currentTree[1])[0];
3728    const nextTreeChild = Object.values(nextTree[1])[0];
3729    if (!currentTreeChild || !nextTreeChild) return true;
3730    return isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild);
3731}
3732if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3733    Object.defineProperty(exports.default, "__esModule", {
3734        value: true
3735    });
3736    Object.assign(exports.default, exports);
3737    module.exports = exports.default;
3738} //# sourceMappingURL=is-navigating-to-new-root-layout.js.map
3739
3740
3741/***/ }),
3742
3743/***/ 1413:
3744/***/ (function(module, exports, __webpack_require__) {
3745
3746"use strict";
3747
3748Object.defineProperty(exports, "__esModule", ({
3749    value: true
3750}));
3751Object.defineProperty(exports, "fastRefreshReducer", ({
3752    enumerable: true,
3753    get: function() {
3754        return fastRefreshReducer;
3755    }
3756}));
3757const _fetchserverresponse = __webpack_require__(5501);
3758const _createhreffromurl = __webpack_require__(6690);
3759const _applyrouterstatepatchtotree = __webpack_require__(817);
3760const _isnavigatingtonewrootlayout = __webpack_require__(3828);
3761const _navigatereducer = __webpack_require__(5556);
3762const _handlemutable = __webpack_require__(8056);
3763const _applyflightdata = __webpack_require__(2732);
3764const _approuter = __webpack_require__(9985);
3765// A version of refresh reducer that keeps the cache around instead of wiping all of it.
3766function fastRefreshReducerImpl(state, action) {
3767    const { origin } = action;
3768    const mutable = {};
3769    const href = state.canonicalUrl;
3770    mutable.preserveCustomHistoryState = false;

3771    const cache = (0, _approuter.createEmptyCacheNode)();
3772    // TODO-APP: verify that `href` is not an external url.
3773    // Fetch data from the root of the tree.
3774    cache.lazyData = (0, _fetchserverresponse.fetchServerResponse)(new URL(href, origin), [
3775        state.tree[0],
3776        state.tree[1],
3777        state.tree[2],
3778        "refetch"
3779    ], state.nextUrl, state.buildId);
3780    return cache.lazyData.then((param)=>{
3781        let [flightData, canonicalUrlOverride] = param;
3782        // Handle case when navigating to page in `pages` from `app`
3783        if (typeof flightData === "string") {
3784            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
3785        }
3786        // Remove cache.lazyData as it has been resolved at this point.
3787        cache.lazyData = null;
3788        let currentTree = state.tree;
3789        let currentCache = state.cache;
3790        for (const flightDataPath of flightData){
3791            // FlightDataPath with more than two items means unexpected Flight data was returned
3792            if (flightDataPath.length !== 3) {
3793                // TODO-APP: handle this case better
3794                console.log("REFRESH FAILED");
3795                return state;
3796            }
3797            // Given the path can only have two items the items are only the router state and rsc for the root.
3798            const [treePatch] = flightDataPath;
3799            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)([
3800                ""
3801            ], currentTree, treePatch);
3802            if (newTree === null) {
3803                throw new Error("SEGMENT MISMATCH");
3804            }
3805            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
3806                return (0, _navigatereducer.handleExternalUrl)(state, mutable, href, state.pushRef.pendingPush);
3807            }
3808            const canonicalUrlOverrideHref = canonicalUrlOverride ? (0, _createhreffromurl.createHrefFromUrl)(canonicalUrlOverride) : undefined;
3809            if (canonicalUrlOverride) {
3810                mutable.canonicalUrl = canonicalUrlOverrideHref;
3811            }
3812            const applied = (0, _applyflightdata.applyFlightData)(currentCache, cache, flightDataPath);
3813            if (applied) {
3814                mutable.cache = cache;
3815                currentCache = cache;
3816            }
3817            mutable.patchedTree = newTree;
3818            mutable.canonicalUrl = href;
3819            currentTree = newTree;
3820        }
3821        return (0, _handlemutable.handleMutable)(state, mutable);
3822    }, ()=>state);
3823}
3824function fastRefreshReducerNoop(state, _action) {
3825    return state;
3826}
3827const fastRefreshReducer =  true ? fastRefreshReducerNoop : 0;
3828if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3829    Object.defineProperty(exports.default, "__esModule", {
3830        value: true
3831    });
3832    Object.assign(exports.default, exports);
3833    module.exports = exports.default;
3834} //# sourceMappingURL=fast-refresh-reducer.js.map
3835
3836
3837/***/ }),
3838
3839/***/ 8521:
3840/***/ (function(module, exports, __webpack_require__) {
3841
3842"use strict";
3843
3844Object.defineProperty(exports, "__esModule", ({
3845    value: true
3846}));
3847Object.defineProperty(exports, "findHeadInCache", ({
3848    enumerable: true,
3849    get: function() {
3850        return findHeadInCache;
3851    }
3852}));
3853const _createroutercachekey = __webpack_require__(7310);
3854function findHeadInCache(cache, parallelRoutes) {
3855    const isLastItem = Object.keys(parallelRoutes).length === 0;
3856    if (isLastItem) {
3857        return cache.head;
3858    }
3859    for(const key in parallelRoutes){
3860        const [segment, childParallelRoutes] = parallelRoutes[key];
3861        const childSegmentMap = cache.parallelRoutes.get(key);
3862        if (!childSegmentMap) {
3863            continue;
3864        }
3865        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
3866        const cacheNode = childSegmentMap.get(cacheKey);
3867        if (!cacheNode) {
3868            continue;
3869        }
3870        const item = findHeadInCache(cacheNode, childParallelRoutes);
3871        if (item) {
3872            return item;
3873        }
3874    }
3875    return undefined;
3876}
3877if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3878    Object.defineProperty(exports.default, "__esModule", {
3879        value: true
3880    });

3881    Object.assign(exports.default, exports);
3882    module.exports = exports.default;
3883} //# sourceMappingURL=find-head-in-cache.js.map
3884
3885
3886/***/ }),
3887
3888/***/ 1846:
3889/***/ (function(module, exports) {
3890
3891"use strict";
3892
3893Object.defineProperty(exports, "__esModule", ({
3894    value: true
3895}));
3896Object.defineProperty(exports, "getSegmentValue", ({
3897    enumerable: true,
3898    get: function() {
3899        return getSegmentValue;
3900    }
3901}));
3902function getSegmentValue(segment) {
3903    return Array.isArray(segment) ? segment[1] : segment;
3904}
3905if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
3906    Object.defineProperty(exports.default, "__esModule", {
3907        value: true
3908    });
3909    Object.assign(exports.default, exports);
3910    module.exports = exports.default;
3911} //# sourceMappingURL=get-segment-value.js.map
3912
3913
3914/***/ }),
3915
3916/***/ 5556:
3917/***/ (function(module, exports, __webpack_require__) {
3918
3919"use strict";
3920
3921Object.defineProperty(exports, "__esModule", ({
3922    value: true
3923}));
39240 && (0);
3925function _export(target, all) {
3926    for(var name in all)Object.defineProperty(target, name, {
3927        enumerable: true,
3928        get: all[name]
3929    });
3930}
3931_export(exports, {
3932    handleExternalUrl: function() {
3933        return handleExternalUrl;
3934    },
3935    navigateReducer: function() {
3936        return navigateReducer;
3937    }
3938});
3939const _fetchserverresponse = __webpack_require__(5501);
3940const _createhreffromurl = __webpack_require__(6690);
3941const _invalidatecachebelowflightsegmentpath = __webpack_require__(5284);
3942const _fillcachewithdataproperty = __webpack_require__(4005);
3943const _applyrouterstatepatchtotree = __webpack_require__(817);
3944const _shouldhardnavigate = __webpack_require__(7533);
3945const _isnavigatingtonewrootlayout = __webpack_require__(3828);
3946const _routerreducertypes = __webpack_require__(1606);
3947const _handlemutable = __webpack_require__(8056);
3948const _applyflightdata = __webpack_require__(2732);
3949const _getprefetchcacheentrystatus = __webpack_require__(450);
3950const _pruneprefetchcache = __webpack_require__(4626);
3951const _prefetchreducer = __webpack_require__(88);
3952const _approuter = __webpack_require__(9985);
3953const _segment = __webpack_require__(1956);
3954function handleExternalUrl(state, mutable, url, pendingPush) {
3955    mutable.mpaNavigation = true;
3956    mutable.canonicalUrl = url;
3957    mutable.pendingPush = pendingPush;
3958    mutable.scrollableSegments = undefined;
3959    return (0, _handlemutable.handleMutable)(state, mutable);
3960}
3961function generateSegmentsFromPatch(flightRouterPatch) {
3962    const segments = [];
3963    const [segment, parallelRoutes] = flightRouterPatch;
3964    if (Object.keys(parallelRoutes).length === 0) {
3965        return [
3966            [
3967                segment
3968            ]
3969        ];
3970    }
3971    for (const [parallelRouteKey, parallelRoute] of Object.entries(parallelRoutes)){
3972        for (const childSegment of generateSegmentsFromPatch(parallelRoute)){
3973            // If the segment is empty, it means we are at the root of the tree
3974            if (segment === "") {
3975                segments.push([
3976                    parallelRouteKey,
3977                    ...childSegment
3978                ]);
3979            } else {
3980                segments.push([
3981                    segment,
3982                    parallelRouteKey,
3983                    ...childSegment
3984                ]);
3985            }
3986        }
3987    }
3988    return segments;
3989}
3990function addRefetchToLeafSegments(newCache, currentCache, flightSegmentPath, treePatch, data) {
3991    let appliedPatch = false;
3992    newCache.rsc = currentCache.rsc;
3993    newCache.prefetchRsc = currentCache.prefetchRsc;
3994    newCache.parallelRoutes = new Map(currentCache.parallelRoutes);
3995    const segmentPathsToFill = generateSegmentsFromPatch(treePatch).map((segment)=>[
3996            ...flightSegmentPath,
3997            ...segment
3998        ]);
3999    for (const segmentPaths of segmentPathsToFill){
4000        (0, _fillcachewithdataproperty.fillCacheWithDataProperty)(newCache, currentCache, segmentPaths, data);
4001        appliedPatch = true;
4002    }
4003    return appliedPatch;
4004}
4005const navigateReducer =  false ? 0 : navigateReducer_noPPR;
4006// This is the implementation when PPR is disabled. We can assume its behavior
4007// is relatively stable because it's been running in production for a while.
4008function navigateReducer_noPPR(state, action) {
4009    const { url, isExternalUrl, navigateType, shouldScroll } = action;
4010    const mutable = {};
4011    const { hash } = url;
4012    const href = (0, _createhreffromurl.createHrefFromUrl)(url);
4013    const pendingPush = navigateType === "push";

4014    // we want to prune the prefetch cache on every navigation to avoid it growing too large
4015    (0, _pruneprefetchcache.prunePrefetchCache)(state.prefetchCache);
4016    mutable.preserveCustomHistoryState = false;
4017    if (isExternalUrl) {
4018        return handleExternalUrl(state, mutable, url.toString(), pendingPush);
4019    }
4020    let prefetchValues = state.prefetchCache.get((0, _createhreffromurl.createHrefFromUrl)(url, false));
4021    // If we don't have a prefetch value, we need to create one
4022    if (!prefetchValues) {
4023        const data = (0, _fetchserverresponse.fetchServerResponse)(url, state.tree, state.nextUrl, state.buildId, // in order to simulate the behavior of the prefetch cache
4024         false ? 0 : undefined);
4025        const newPrefetchValue = {
4026            data,
4027            // this will make sure that the entry will be discarded after 30s
4028            kind:  false ? 0 : _routerreducertypes.PrefetchKind.TEMPORARY,
4029            prefetchTime: Date.now(),
4030            treeAtTimeOfPrefetch: state.tree,
4031            lastUsedTime: null
4032        };
4033        state.prefetchCache.set((0, _createhreffromurl.createHrefFromUrl)(url, false), newPrefetchValue);
4034        prefetchValues = newPrefetchValue;
4035    }
4036    const prefetchEntryCacheStatus = (0, _getprefetchcacheentrystatus.getPrefetchEntryCacheStatus)(prefetchValues);
4037    // The one before last item is the router state tree patch
4038    const { treeAtTimeOfPrefetch, data } = prefetchValues;
4039    _prefetchreducer.prefetchQueue.bump(data);
4040    return data.then((param)=>{
4041        let [flightData, canonicalUrlOverride, postponed] = param;
4042        // we only want to mark this once
4043        if (prefetchValues && !prefetchValues.lastUsedTime) {
4044            // important: we should only mark the cache node as dirty after we unsuspend from the call above
4045            prefetchValues.lastUsedTime = Date.now();
4046        }
4047        // Handle case when navigating to page in `pages` from `app`
4048        if (typeof flightData === "string") {
4049            return handleExternalUrl(state, mutable, flightData, pendingPush);
4050        }
4051        let currentTree = state.tree;
4052        let currentCache = state.cache;
4053        let scrollableSegments = [];
4054        for (const flightDataPath of flightData){
4055            const flightSegmentPath = flightDataPath.slice(0, -4);
4056            // The one before last item is the router state tree patch
4057            const treePatch = flightDataPath.slice(-3)[0];
4058            // TODO-APP: remove ''
4059            const flightSegmentPathWithLeadingEmpty = [
4060                "",
4061                ...flightSegmentPath
4062            ];
4063            // Create new tree based on the flightSegmentPath and router state patch
4064            let newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)(flightSegmentPathWithLeadingEmpty, currentTree, treePatch);
4065            // If the tree patch can't be applied to the current tree then we use the tree at time of prefetch
4066            // TODO-APP: This should instead fill in the missing pieces in `currentTree` with the data from `treeAtTimeOfPrefetch`, then apply the patch.
4067            if (newTree === null) {
4068                newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)(flightSegmentPathWithLeadingEmpty, treeAtTimeOfPrefetch, treePatch);
4069            }
4070            if (newTree !== null) {
4071                if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
4072                    return handleExternalUrl(state, mutable, href, pendingPush);
4073                }
4074                const cache = (0, _approuter.createEmptyCacheNode)();
4075                let applied = (0, _applyflightdata.applyFlightData)(currentCache, cache, flightDataPath, (prefetchValues == null ? void 0 : prefetchValues.kind) === "auto" && prefetchEntryCacheStatus === _getprefetchcacheentrystatus.PrefetchCacheEntryStatus.reusable);
4076                if (!applied && prefetchEntryCacheStatus === _getprefetchcacheentrystatus.PrefetchCacheEntryStatus.stale || // TODO-APP: If the prefetch was postponed, we don't want to apply it
4077                // until we land router changes to handle the postponed case.
4078                postponed) {
4079                    applied = addRefetchToLeafSegments(cache, currentCache, flightSegmentPath, treePatch, ()=>(0, _fetchserverresponse.fetchServerResponse)(url, currentTree, state.nextUrl, state.buildId));
4080                }
4081                const hardNavigate = (0, _shouldhardnavigate.shouldHardNavigate)(flightSegmentPathWithLeadingEmpty, currentTree);
4082                if (hardNavigate) {
4083                    // Copy rsc for the root node of the cache.
4084                    cache.rsc = currentCache.rsc;
4085                    cache.prefetchRsc = currentCache.prefetchRsc;
4086                    (0, _invalidatecachebelowflightsegmentpath.invalidateCacheBelowFlightSegmentPath)(cache, currentCache, flightSegmentPath);
4087                    // Ensure the existing cache value is used when the cache was not invalidated.
4088                    mutable.cache = cache;
4089                } else if (applied) {
4090                    mutable.cache = cache;
4091                }
4092                currentCache = cache;
4093                currentTree = newTree;
4094                for (const subSegment of generateSegmentsFromPatch(treePatch)){
4095                    const scrollableSegmentPath = [
4096                        ...flightSegmentPath,
4097                        ...subSegment
4098                    ];
4099                    // Filter out the __DEFAULT__ paths as they shouldn't be scrolled to in this case.
4100                    if (scrollableSegmentPath[scrollableSegmentPath.length - 1] !== _segment.DEFAULT_SEGMENT_KEY) {
4101                        scrollableSegments.push(scrollableSegmentPath);
4102                    }
4103                }
4104            }
4105        }
4106        mutable.patchedTree = currentTree;
4107        mutable.canonicalUrl = canonicalUrlOverride ? (0, _createhreffromurl.createHrefFromUrl)(canonicalUrlOverride) : href;
4108        mutable.pendingPush = pendingPush;
4109        mutable.scrollableSegments = scrollableSegments;
4110        mutable.hashFragment = hash;
4111        mutable.shouldScroll = shouldScroll;
4112        return (0, _handlemutable.handleMutable)(state, mutable);
4113    }, ()=>state);
4114}
4115// This is the experimental PPR implementation. It's closer to the behavior we
4116// want, but is likelier to include accidental regressions because it rewrites
4117// existing functionality.
4118function navigateReducer_PPR(state, action) {
4119    const { url, isExternalUrl, navigateType, shouldScroll } = action;
4120    const mutable = {};
4121    const { hash } = url;
4122    const href = (0, _createhreffromurl.createHrefFromUrl)(url);
4123    const pendingPush = navigateType === "push";

4124    // we want to prune the prefetch cache on every navigation to avoid it growing too large
4125    (0, _pruneprefetchcache.prunePrefetchCache)(state.prefetchCache);
4126    mutable.preserveCustomHistoryState = false;
4127    if (isExternalUrl) {
4128        return handleExternalUrl(state, mutable, url.toString(), pendingPush);
4129    }
4130    let prefetchValues = state.prefetchCache.get((0, _createhreffromurl.createHrefFromUrl)(url, false));
4131    // If we don't have a prefetch value, we need to create one
4132    if (!prefetchValues) {
4133        const data = (0, _fetchserverresponse.fetchServerResponse)(url, state.tree, state.nextUrl, state.buildId, // in order to simulate the behavior of the prefetch cache
4134         false ? 0 : undefined);
4135        const newPrefetchValue = {
4136            data,
4137            // this will make sure that the entry will be discarded after 30s
4138            kind:  false ? 0 : _routerreducertypes.PrefetchKind.TEMPORARY,
4139            prefetchTime: Date.now(),
4140            treeAtTimeOfPrefetch: state.tree,
4141            lastUsedTime: null
4142        };
4143        state.prefetchCache.set((0, _createhreffromurl.createHrefFromUrl)(url, false), newPrefetchValue);
4144        prefetchValues = newPrefetchValue;
4145    }
4146    const prefetchEntryCacheStatus = (0, _getprefetchcacheentrystatus.getPrefetchEntryCacheStatus)(prefetchValues);
4147    // The one before last item is the router state tree patch
4148    const { treeAtTimeOfPrefetch, data } = prefetchValues;
4149    _prefetchreducer.prefetchQueue.bump(data);
4150    return data.then((param)=>{
4151        let [flightData, canonicalUrlOverride, postponed] = param;
4152        // we only want to mark this once
4153        if (prefetchValues && !prefetchValues.lastUsedTime) {
4154            // important: we should only mark the cache node as dirty after we unsuspend from the call above
4155            prefetchValues.lastUsedTime = Date.now();
4156        }
4157        // Handle case when navigating to page in `pages` from `app`
4158        if (typeof flightData === "string") {
4159            return handleExternalUrl(state, mutable, flightData, pendingPush);
4160        }
4161        let currentTree = state.tree;
4162        let currentCache = state.cache;
4163        let scrollableSegments = [];
4164        for (const flightDataPath of flightData){
4165            const flightSegmentPath = flightDataPath.slice(0, -4);
4166            // The one before last item is the router state tree patch
4167            const treePatch = flightDataPath.slice(-3)[0];
4168            // TODO-APP: remove ''
4169            const flightSegmentPathWithLeadingEmpty = [
4170                "",
4171                ...flightSegmentPath
4172            ];
4173            // Create new tree based on the flightSegmentPath and router state patch
4174            let newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)(flightSegmentPathWithLeadingEmpty, currentTree, treePatch);
4175            // If the tree patch can't be applied to the current tree then we use the tree at time of prefetch
4176            // TODO-APP: This should instead fill in the missing pieces in `currentTree` with the data from `treeAtTimeOfPrefetch`, then apply the patch.
4177            if (newTree === null) {
4178                newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)(flightSegmentPathWithLeadingEmpty, treeAtTimeOfPrefetch, treePatch);
4179            }
4180            if (newTree !== null) {
4181                if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
4182                    return handleExternalUrl(state, mutable, href, pendingPush);
4183                }
4184                const cache = (0, _approuter.createEmptyCacheNode)();
4185                let applied = (0, _applyflightdata.applyFlightData)(currentCache, cache, flightDataPath, (prefetchValues == null ? void 0 : prefetchValues.kind) === "auto" && prefetchEntryCacheStatus === _getprefetchcacheentrystatus.PrefetchCacheEntryStatus.reusable);
4186                if (!applied && prefetchEntryCacheStatus === _getprefetchcacheentrystatus.PrefetchCacheEntryStatus.stale || // TODO-APP: If the prefetch was postponed, we don't want to apply it
4187                // until we land router changes to handle the postponed case.
4188                postponed) {
4189                    applied = addRefetchToLeafSegments(cache, currentCache, flightSegmentPath, treePatch, ()=>(0, _fetchserverresponse.fetchServerResponse)(url, currentTree, state.nextUrl, state.buildId));
4190                }
4191                const hardNavigate = (0, _shouldhardnavigate.shouldHardNavigate)(flightSegmentPathWithLeadingEmpty, currentTree);
4192                if (hardNavigate) {
4193                    // Copy rsc for the root node of the cache.
4194                    cache.rsc = currentCache.rsc;
4195                    cache.prefetchRsc = currentCache.prefetchRsc;
4196                    (0, _invalidatecachebelowflightsegmentpath.invalidateCacheBelowFlightSegmentPath)(cache, currentCache, flightSegmentPath);
4197                    // Ensure the existing cache value is used when the cache was not invalidated.
4198                    mutable.cache = cache;
4199                } else if (applied) {
4200                    mutable.cache = cache;
4201                }
4202                currentCache = cache;
4203                currentTree = newTree;
4204                for (const subSegment of generateSegmentsFromPatch(treePatch)){
4205                    const scrollableSegmentPath = [
4206                        ...flightSegmentPath,
4207                        ...subSegment
4208                    ];
4209                    // Filter out the __DEFAULT__ paths as they shouldn't be scrolled to in this case.
4210                    if (scrollableSegmentPath[scrollableSegmentPath.length - 1] !== _segment.DEFAULT_SEGMENT_KEY) {
4211                        scrollableSegments.push(scrollableSegmentPath);
4212                    }
4213                }
4214            }
4215        }
4216        mutable.patchedTree = currentTree;
4217        mutable.canonicalUrl = canonicalUrlOverride ? (0, _createhreffromurl.createHrefFromUrl)(canonicalUrlOverride) : href;
4218        mutable.pendingPush = pendingPush;
4219        mutable.scrollableSegments = scrollableSegments;
4220        mutable.hashFragment = hash;
4221        mutable.shouldScroll = shouldScroll;
4222        return (0, _handlemutable.handleMutable)(state, mutable);
4223    }, ()=>state);
4224}
4225if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4226    Object.defineProperty(exports.default, "__esModule", {
4227        value: true
4228    });

4229    Object.assign(exports.default, exports);
4230    module.exports = exports.default;
4231} //# sourceMappingURL=navigate-reducer.js.map
4232
4233
4234/***/ }),
4235
4236/***/ 88:
4237/***/ (function(module, exports, __webpack_require__) {
4238
4239"use strict";
4240
4241Object.defineProperty(exports, "__esModule", ({
4242    value: true
4243}));
42440 && (0);
4245function _export(target, all) {
4246    for(var name in all)Object.defineProperty(target, name, {
4247        enumerable: true,
4248        get: all[name]
4249    });
4250}
4251_export(exports, {
4252    prefetchQueue: function() {
4253        return prefetchQueue;
4254    },
4255    prefetchReducer: function() {
4256        return prefetchReducer;
4257    }
4258});
4259const _createhreffromurl = __webpack_require__(6690);
4260const _fetchserverresponse = __webpack_require__(5501);
4261const _routerreducertypes = __webpack_require__(1606);
4262const _pruneprefetchcache = __webpack_require__(4626);
4263const _approuterheaders = __webpack_require__(5767);
4264const _promisequeue = __webpack_require__(9236);
4265const prefetchQueue = new _promisequeue.PromiseQueue(5);
4266function prefetchReducer(state, action) {
4267    // let's prune the prefetch cache before we do anything else
4268    (0, _pruneprefetchcache.prunePrefetchCache)(state.prefetchCache);
4269    const { url } = action;
4270    url.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
4271    const href = (0, _createhreffromurl.createHrefFromUrl)(url, false);
4272    const cacheEntry = state.prefetchCache.get(href);
4273    if (cacheEntry) {
4274        /**
4275     * If the cache entry present was marked as temporary, it means that we prefetched it from the navigate reducer,
4276     * where we didn't have the prefetch intent. We want to update it to the new, more accurate, kind here.
4277     */ if (cacheEntry.kind === _routerreducertypes.PrefetchKind.TEMPORARY) {
4278            state.prefetchCache.set(href, {
4279                ...cacheEntry,
4280                kind: action.kind
4281            });
4282        }
4283        /**
4284     * if the prefetch action was a full prefetch and that the current cache entry wasn't one, we want to re-prefetch,
4285     * otherwise we can re-use the current cache entry
4286     **/ if (!(cacheEntry.kind === _routerreducertypes.PrefetchKind.AUTO && action.kind === _routerreducertypes.PrefetchKind.FULL)) {
4287            return state;
4288        }
4289    }
4290    // fetchServerResponse is intentionally not awaited so that it can be unwrapped in the navigate-reducer
4291    const serverResponse = prefetchQueue.enqueue(()=>(0, _fetchserverresponse.fetchServerResponse)(url, state.tree, state.nextUrl, state.buildId, action.kind));
4292    // Create new tree based on the flightSegmentPath and router state patch
4293    state.prefetchCache.set(href, {
4294        // Create new tree based on the flightSegmentPath and router state patch
4295        treeAtTimeOfPrefetch: state.tree,
4296        data: serverResponse,
4297        kind: action.kind,
4298        prefetchTime: Date.now(),
4299        lastUsedTime: null
4300    });
4301    return state;
4302}
4303if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4304    Object.defineProperty(exports.default, "__esModule", {
4305        value: true
4306    });
4307    Object.assign(exports.default, exports);
4308    module.exports = exports.default;
4309} //# sourceMappingURL=prefetch-reducer.js.map
4310
4311
4312/***/ }),
4313
4314/***/ 4626:
4315/***/ (function(module, exports, __webpack_require__) {
4316
4317"use strict";
4318
4319Object.defineProperty(exports, "__esModule", ({
4320    value: true
4321}));
4322Object.defineProperty(exports, "prunePrefetchCache", ({
4323    enumerable: true,
4324    get: function() {
4325        return prunePrefetchCache;
4326    }
4327}));
4328const _getprefetchcacheentrystatus = __webpack_require__(450);
4329function prunePrefetchCache(prefetchCache) {
4330    for (const [href, prefetchCacheEntry] of prefetchCache){
4331        if ((0, _getprefetchcacheentrystatus.getPrefetchEntryCacheStatus)(prefetchCacheEntry) === _getprefetchcacheentrystatus.PrefetchCacheEntryStatus.expired) {
4332            prefetchCache.delete(href);
4333        }
4334    }
4335}
4336if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4337    Object.defineProperty(exports.default, "__esModule", {
4338        value: true
4339    });

4340    Object.assign(exports.default, exports);
4341    module.exports = exports.default;
4342} //# sourceMappingURL=prune-prefetch-cache.js.map
4343
4344
4345/***/ }),
4346
4347/***/ 9266:
4348/***/ (function(module, exports, __webpack_require__) {
4349
4350"use strict";
4351
4352Object.defineProperty(exports, "__esModule", ({
4353    value: true
4354}));
4355Object.defineProperty(exports, "refreshReducer", ({
4356    enumerable: true,
4357    get: function() {
4358        return refreshReducer;
4359    }
4360}));
4361const _fetchserverresponse = __webpack_require__(5501);
4362const _createhreffromurl = __webpack_require__(6690);
4363const _applyrouterstatepatchtotree = __webpack_require__(817);
4364const _isnavigatingtonewrootlayout = __webpack_require__(3828);
4365const _navigatereducer = __webpack_require__(5556);
4366const _handlemutable = __webpack_require__(8056);
4367const _filllazyitemstillleafwithhead = __webpack_require__(3866);
4368const _approuter = __webpack_require__(9985);
4369function refreshReducer(state, action) {
4370    const { origin } = action;
4371    const mutable = {};
4372    const href = state.canonicalUrl;
4373    let currentTree = state.tree;
4374    mutable.preserveCustomHistoryState = false;
4375    const cache = (0, _approuter.createEmptyCacheNode)();
4376    // TODO-APP: verify that `href` is not an external url.
4377    // Fetch data from the root of the tree.
4378    cache.lazyData = (0, _fetchserverresponse.fetchServerResponse)(new URL(href, origin), [
4379        currentTree[0],
4380        currentTree[1],
4381        currentTree[2],
4382        "refetch"
4383    ], state.nextUrl, state.buildId);
4384    return cache.lazyData.then((param)=>{
4385        let [flightData, canonicalUrlOverride] = param;
4386        // Handle case when navigating to page in `pages` from `app`
4387        if (typeof flightData === "string") {
4388            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
4389        }
4390        // Remove cache.lazyData as it has been resolved at this point.
4391        cache.lazyData = null;
4392        for (const flightDataPath of flightData){
4393            // FlightDataPath with more than two items means unexpected Flight data was returned
4394            if (flightDataPath.length !== 3) {
4395                // TODO-APP: handle this case better
4396                console.log("REFRESH FAILED");
4397                return state;
4398            }
4399            // Given the path can only have two items the items are only the router state and rsc for the root.
4400            const [treePatch] = flightDataPath;
4401            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToFullTree)([
4402                ""
4403            ], currentTree, treePatch);
4404            if (newTree === null) {
4405                throw new Error("SEGMENT MISMATCH");
4406            }
4407            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
4408                return (0, _navigatereducer.handleExternalUrl)(state, mutable, href, state.pushRef.pendingPush);
4409            }
4410            const canonicalUrlOverrideHref = canonicalUrlOverride ? (0, _createhreffromurl.createHrefFromUrl)(canonicalUrlOverride) : undefined;
4411            if (canonicalUrlOverride) {
4412                mutable.canonicalUrl = canonicalUrlOverrideHref;
4413            }
4414            // The one before last item is the router state tree patch
4415            const [cacheNodeSeedData, head] = flightDataPath.slice(-2);
4416            // Handles case where prefetch only returns the router tree patch without rendered components.
4417            if (cacheNodeSeedData !== null) {

4418                const rsc = cacheNodeSeedData[2];
4419                cache.rsc = rsc;
4420                cache.prefetchRsc = null;
4421                (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(cache, undefined, treePatch, cacheNodeSeedData, head);
4422                mutable.cache = cache;
4423                mutable.prefetchCache = new Map();
4424            }
4425            mutable.patchedTree = newTree;
4426            mutable.canonicalUrl = href;
4427            currentTree = newTree;
4428        }
4429        return (0, _handlemutable.handleMutable)(state, mutable);
4430    }, ()=>state);
4431}
4432if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4433    Object.defineProperty(exports.default, "__esModule", {
4434        value: true
4435    });
4436    Object.assign(exports.default, exports);
4437    module.exports = exports.default;
4438} //# sourceMappingURL=refresh-reducer.js.map
4439
4440
4441/***/ }),
4442
4443/***/ 190:
4444/***/ (function(module, exports, __webpack_require__) {
4445
4446"use strict";
4447
4448Object.defineProperty(exports, "__esModule", ({
4449    value: true
4450}));
4451Object.defineProperty(exports, "restoreReducer", ({
4452    enumerable: true,
4453    get: function() {
4454        return restoreReducer;
4455    }
4456}));
4457const _createhreffromurl = __webpack_require__(6690);
4458const _computechangedpath = __webpack_require__(9650);
4459function restoreReducer(state, action) {
4460    const { url, tree } = action;
4461    const href = (0, _createhreffromurl.createHrefFromUrl)(url);
4462    var _extractPathFromFlightRouterState;
4463    return {
4464        buildId: state.buildId,
4465        // Set canonical url
4466        canonicalUrl: href,
4467        pushRef: {
4468            pendingPush: false,
4469            mpaNavigation: false,
4470            // Ensures that the custom history state that was set is preserved when applying this update.
4471            preserveCustomHistoryState: true
4472        },
4473        focusAndScrollRef: state.focusAndScrollRef,
4474        cache: state.cache,
4475        prefetchCache: state.prefetchCache,
4476        // Restore provided tree
4477        tree: tree,
4478        nextUrl: (_extractPathFromFlightRouterState = (0, _computechangedpath.extractPathFromFlightRouterState)(tree)) != null ? _extractPathFromFlightRouterState : url.pathname
4479    };
4480}
4481if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4482    Object.defineProperty(exports.default, "__esModule", {
4483        value: true
4484    });
4485    Object.assign(exports.default, exports);
4486    module.exports = exports.default;
4487} //# sourceMappingURL=restore-reducer.js.map
4488
4489
4490/***/ }),
4491
4492/***/ 7216:
4493/***/ (function(module, exports, __webpack_require__) {
4494
4495"use strict";
4496
4497Object.defineProperty(exports, "__esModule", ({
4498    value: true
4499}));
4500Object.defineProperty(exports, "serverActionReducer", ({
4501    enumerable: true,
4502    get: function() {
4503        return serverActionReducer;
4504    }
4505}));
4506const _appcallserver = __webpack_require__(714);
4507const _approuterheaders = __webpack_require__(5767);
4508const _addbasepath = __webpack_require__(5733);
4509const _createhreffromurl = __webpack_require__(6690);
4510const _navigatereducer = __webpack_require__(5556);
4511const _applyrouterstatepatchtotree = __webpack_require__(817);
4512const _isnavigatingtonewrootlayout = __webpack_require__(3828);
4513const _handlemutable = __webpack_require__(8056);
4514const _filllazyitemstillleafwithhead = __webpack_require__(3866);
4515const _approuter = __webpack_require__(9985);
4516const _computechangedpath = __webpack_require__(9650);
4517// // eslint-disable-next-line import/no-extraneous-dependencies
4518// import { createFromFetch } from 'react-server-dom-webpack/client'
4519// // eslint-disable-next-line import/no-extraneous-dependencies
4520// import { encodeReply } from 'react-server-dom-webpack/client'
4521const { createFromFetch, encodeReply } =  false ? 0 : __webpack_require__(5552);
4522async function fetchServerAction(state, param) {
4523    let { actionId, actionArgs } = param;
4524    const body = await encodeReply(actionArgs);
4525    const newNextUrl = (0, _computechangedpath.extractPathFromFlightRouterState)(state.tree);
4526    // only pass along the `nextUrl` param (used for interception routes) if it exists and
4527    // if it's different from the current `nextUrl`. This indicates the route has already been intercepted,

4528    // and so the action should be as well. Otherwise the server action might be intercepted
4529    // with the wrong action id (ie, one that corresponds with the intercepted route)
4530    const includeNextUrl = state.nextUrl && state.nextUrl !== newNextUrl;
4531    const res = await fetch("", {
4532        method: "POST",
4533        headers: {
4534            Accept: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
4535            [_approuterheaders.ACTION]: actionId,
4536            [_approuterheaders.NEXT_ROUTER_STATE_TREE]: encodeURIComponent(JSON.stringify(state.tree)),
4537            ... false ? 0 : {},
4538            ...includeNextUrl ? {
4539                [_approuterheaders.NEXT_URL]: state.nextUrl
4540            } : {}
4541        },
4542        body
4543    });
4544    const location = res.headers.get("x-action-redirect");
4545    let revalidatedParts;
4546    try {
4547        const revalidatedHeader = JSON.parse(res.headers.get("x-action-revalidated") || "[[],0,0]");
4548        revalidatedParts = {
4549            paths: revalidatedHeader[0] || [],
4550            tag: !!revalidatedHeader[1],
4551            cookie: revalidatedHeader[2]
4552        };
4553    } catch (e) {
4554        revalidatedParts = {
4555            paths: [],
4556            tag: false,
4557            cookie: false
4558        };
4559    }
4560    const redirectLocation = location ? new URL((0, _addbasepath.addBasePath)(location), new URL(state.canonicalUrl, window.location.href)) : undefined;
4561    let isFlightResponse = res.headers.get("content-type") === _approuterheaders.RSC_CONTENT_TYPE_HEADER;
4562    if (isFlightResponse) {
4563        const response = await createFromFetch(Promise.resolve(res), {
4564            callServer: _appcallserver.callServer
4565        });
4566        if (location) {
4567            // if it was a redirection, then result is just a regular RSC payload
4568            const [, actionFlightData] = response != null ? response : [];
4569            return {
4570                actionFlightData: actionFlightData,
4571                redirectLocation,
4572                revalidatedParts
4573            };
4574        }
4575        // otherwise it's a tuple of [actionResult, actionFlightData]
4576        const [actionResult, [, actionFlightData]] = response != null ? response : [];
4577        return {
4578            actionResult,
4579            actionFlightData,
4580            redirectLocation,
4581            revalidatedParts
4582        };
4583    }
4584    return {
4585        redirectLocation,
4586        revalidatedParts
4587    };
4588}
4589function serverActionReducer(state, action) {
4590    const { resolve, reject } = action;
4591    const mutable = {};
4592    const href = state.canonicalUrl;
4593    let currentTree = state.tree;
4594    mutable.preserveCustomHistoryState = false;
4595    mutable.inFlightServerAction = fetchServerAction(state, action);
4596    // suspends until the server action is resolved.
4597    return mutable.inFlightServerAction.then((param)=>{
4598        let { actionResult, actionFlightData: flightData, redirectLocation } = param;
4599        // Make sure the redirection is a push instead of a replace.
4600        // Issue: https://github.com/vercel/next.js/issues/53911
4601        if (redirectLocation) {
4602            state.pushRef.pendingPush = true;
4603            mutable.pendingPush = true;
4604        }
4605        if (!flightData) {
4606            if (!mutable.actionResultResolved) {
4607                resolve(actionResult);
4608                mutable.actionResultResolved = true;
4609            }
4610            // If there is a redirect but no flight data we need to do a mpaNavigation.
4611            if (redirectLocation) {
4612                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectLocation.href, state.pushRef.pendingPush);
4613            }
4614            return state;
4615        }
4616        if (typeof flightData === "string") {
4617            // Handle case when navigating to page in `pages` from `app`
4618            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
4619        }
4620        // Remove cache.data as it has been resolved at this point.
4621        mutable.inFlightServerAction = null;
4622        for (const flightDataPath of flightData){
4623            // FlightDataPath with more than two items means unexpected Flight data was returned
4624            if (flightDataPath.length !== 3) {
4625                // TODO-APP: handle this case better
4626                console.log("SERVER ACTION APPLY FAILED");
4627                return state;
4628            }

4629            // Given the path can only have two items the items are only the router state and rsc for the root.
4630            const [treePatch] = flightDataPath;
4631            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToFullTree)([
4632                ""
4633            ], currentTree, treePatch);
4634            if (newTree === null) {
4635                throw new Error("SEGMENT MISMATCH");
4636            }
4637            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
4638                return (0, _navigatereducer.handleExternalUrl)(state, mutable, href, state.pushRef.pendingPush);
4639            }
4640            // The one before last item is the router state tree patch
4641            const [cacheNodeSeedData, head] = flightDataPath.slice(-2);
4642            const rsc = cacheNodeSeedData !== null ? cacheNodeSeedData[2] : null;
4643            // Handles case where prefetch only returns the router tree patch without rendered components.
4644            if (rsc !== null) {
4645                const cache = (0, _approuter.createEmptyCacheNode)();
4646                cache.rsc = rsc;
4647                cache.prefetchRsc = null;
4648                (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(cache, undefined, treePatch, cacheNodeSeedData, head);
4649                mutable.cache = cache;
4650                mutable.prefetchCache = new Map();
4651            }
4652            mutable.patchedTree = newTree;
4653            mutable.canonicalUrl = href;
4654            currentTree = newTree;
4655        }
4656        if (redirectLocation) {
4657            const newHref = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
4658            mutable.canonicalUrl = newHref;
4659        }
4660        if (!mutable.actionResultResolved) {
4661            resolve(actionResult);
4662            mutable.actionResultResolved = true;
4663        }
4664        return (0, _handlemutable.handleMutable)(state, mutable);
4665    }, (e)=>{
4666        if (e.status === "rejected") {
4667            if (!mutable.actionResultResolved) {
4668                reject(e.reason);
4669                mutable.actionResultResolved = true;
4670            }
4671            // When the server action is rejected we don't update the state and instead call the reject handler of the promise.
4672            return state;
4673        }
4674        throw e;
4675    });
4676}
4677if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4678    Object.defineProperty(exports.default, "__esModule", {
4679        value: true
4680    });
4681    Object.assign(exports.default, exports);
4682    module.exports = exports.default;
4683} //# sourceMappingURL=server-action-reducer.js.map
4684
4685
4686/***/ }),
4687
4688/***/ 7723:
4689/***/ (function(module, exports, __webpack_require__) {
4690
4691"use strict";
4692
4693Object.defineProperty(exports, "__esModule", ({
4694    value: true
4695}));
4696Object.defineProperty(exports, "serverPatchReducer", ({
4697    enumerable: true,
4698    get: function() {
4699        return serverPatchReducer;
4700    }
4701}));
4702const _createhreffromurl = __webpack_require__(6690);
4703const _applyrouterstatepatchtotree = __webpack_require__(817);
4704const _isnavigatingtonewrootlayout = __webpack_require__(3828);
4705const _navigatereducer = __webpack_require__(5556);
4706const _applyflightdata = __webpack_require__(2732);
4707const _handlemutable = __webpack_require__(8056);
4708const _approuter = __webpack_require__(9985);
4709function serverPatchReducer(state, action) {
4710    const { flightData, overrideCanonicalUrl } = action;
4711    const mutable = {};
4712    mutable.preserveCustomHistoryState = false;
4713    // Handle case when navigating to page in `pages` from `app`
4714    if (typeof flightData === "string") {
4715        return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
4716    }
4717    let currentTree = state.tree;
4718    let currentCache = state.cache;
4719    for (const flightDataPath of flightData){
4720        // Slices off the last segment (which is at -4) as it doesn't exist in the tree yet
4721        const flightSegmentPath = flightDataPath.slice(0, -4);
4722        const [treePatch] = flightDataPath.slice(-3, -2);
4723        const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTreeSkipDefault)([
4724            "",
4725            ...flightSegmentPath
4726        ], currentTree, treePatch);
4727        if (newTree === null) {
4728            throw new Error("SEGMENT MISMATCH");
4729        }

4730        if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
4731            return (0, _navigatereducer.handleExternalUrl)(state, mutable, state.canonicalUrl, state.pushRef.pendingPush);
4732        }
4733        const canonicalUrlOverrideHref = overrideCanonicalUrl ? (0, _createhreffromurl.createHrefFromUrl)(overrideCanonicalUrl) : undefined;
4734        if (canonicalUrlOverrideHref) {
4735            mutable.canonicalUrl = canonicalUrlOverrideHref;
4736        }
4737        const cache = (0, _approuter.createEmptyCacheNode)();
4738        (0, _applyflightdata.applyFlightData)(currentCache, cache, flightDataPath);
4739        mutable.patchedTree = newTree;
4740        mutable.cache = cache;
4741        currentCache = cache;
4742        currentTree = newTree;
4743    }
4744    return (0, _handlemutable.handleMutable)(state, mutable);
4745}
4746if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4747    Object.defineProperty(exports.default, "__esModule", {
4748        value: true
4749    });
4750    Object.assign(exports.default, exports);
4751    module.exports = exports.default;
4752} //# sourceMappingURL=server-patch-reducer.js.map
4753
4754
4755/***/ }),
4756
4757/***/ 1606:
4758/***/ (function(module, exports) {
4759
4760"use strict";
4761
4762Object.defineProperty(exports, "__esModule", ({
4763    value: true
4764}));
47650 && (0);
4766function _export(target, all) {
4767    for(var name in all)Object.defineProperty(target, name, {
4768        enumerable: true,
4769        get: all[name]
4770    });
4771}
4772_export(exports, {
4773    PrefetchKind: function() {
4774        return PrefetchKind;
4775    },
4776    ACTION_REFRESH: function() {
4777        return ACTION_REFRESH;
4778    },
4779    ACTION_NAVIGATE: function() {
4780        return ACTION_NAVIGATE;
4781    },
4782    ACTION_RESTORE: function() {
4783        return ACTION_RESTORE;
4784    },
4785    ACTION_SERVER_PATCH: function() {
4786        return ACTION_SERVER_PATCH;
4787    },
4788    ACTION_PREFETCH: function() {
4789        return ACTION_PREFETCH;
4790    },
4791    ACTION_FAST_REFRESH: function() {
4792        return ACTION_FAST_REFRESH;
4793    },
4794    ACTION_SERVER_ACTION: function() {
4795        return ACTION_SERVER_ACTION;
4796    },
4797    isThenable: function() {
4798        return isThenable;
4799    }
4800});
4801const ACTION_REFRESH = "refresh";
4802const ACTION_NAVIGATE = "navigate";
4803const ACTION_RESTORE = "restore";
4804const ACTION_SERVER_PATCH = "server-patch";
4805const ACTION_PREFETCH = "prefetch";
4806const ACTION_FAST_REFRESH = "fast-refresh";
4807const ACTION_SERVER_ACTION = "server-action";
4808var PrefetchKind;
4809(function(PrefetchKind) {
4810    PrefetchKind["AUTO"] = "auto";
4811    PrefetchKind["FULL"] = "full";
4812    PrefetchKind["TEMPORARY"] = "temporary";
4813})(PrefetchKind || (PrefetchKind = {}));
4814function isThenable(value) {
4815    // TODO: We don't gain anything from this abstraction. It's unsound, and only
4816    // makes sense in the specific places where we use it. So it's better to keep
4817    // the type coercion inline, instead of leaking this to other places in
4818    // the codebase.
4819    return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
4820}
4821if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4822    Object.defineProperty(exports.default, "__esModule", {
4823        value: true
4824    });
4825    Object.assign(exports.default, exports);
4826    module.exports = exports.default;
4827} //# sourceMappingURL=router-reducer-types.js.map
4828
4829
4830/***/ }),
4831
4832/***/ 490:
4833/***/ (function(module, exports, __webpack_require__) {
4834
4835"use strict";
4836
4837Object.defineProperty(exports, "__esModule", ({
4838    value: true
4839}));
4840Object.defineProperty(exports, "reducer", ({
4841    enumerable: true,
4842    get: function() {
4843        return reducer;
4844    }
4845}));
4846const _routerreducertypes = __webpack_require__(1606);
4847const _navigatereducer = __webpack_require__(5556);
4848const _serverpatchreducer = __webpack_require__(7723);
4849const _restorereducer = __webpack_require__(190);
4850const _refreshreducer = __webpack_require__(9266);
4851const _prefetchreducer = __webpack_require__(88);
4852const _fastrefreshreducer = __webpack_require__(1413);
4853const _serveractionreducer = __webpack_require__(7216);
4854/**
4855 * Reducer that handles the app-router state updates.
4856 */ function clientReducer(state, action) {
4857    switch(action.type){
4858        case _routerreducertypes.ACTION_NAVIGATE:
4859            {
4860                return (0, _navigatereducer.navigateReducer)(state, action);
4861            }
4862        case _routerreducertypes.ACTION_SERVER_PATCH:
4863            {
4864                return (0, _serverpatchreducer.serverPatchReducer)(state, action);
4865            }
4866        case _routerreducertypes.ACTION_RESTORE:
4867            {
4868                return (0, _restorereducer.restoreReducer)(state, action);
4869            }
4870        case _routerreducertypes.ACTION_REFRESH:
4871            {
4872                return (0, _refreshreducer.refreshReducer)(state, action);
4873            }
4874        case _routerreducertypes.ACTION_FAST_REFRESH:
4875            {
4876                return (0, _fastrefreshreducer.fastRefreshReducer)(state, action);
4877            }
4878        case _routerreducertypes.ACTION_PREFETCH:
4879            {
4880                return (0, _prefetchreducer.prefetchReducer)(state, action);
4881            }
4882        case _routerreducertypes.ACTION_SERVER_ACTION:
4883            {
4884                return (0, _serveractionreducer.serverActionReducer)(state, action);
4885            }
4886        // This case should never be hit as dispatch is strongly typed.
4887        default:
4888            throw new Error("Unknown action");
4889    }
4890}
4891function serverReducer(state, _action) {
4892    return state;
4893}
4894const reducer =  false ? 0 : clientReducer;
4895if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4896    Object.defineProperty(exports.default, "__esModule", {
4897        value: true
4898    });

4899    Object.assign(exports.default, exports);
4900    module.exports = exports.default;
4901} //# sourceMappingURL=router-reducer.js.map
4902
4903
4904/***/ }),
4905
4906/***/ 7533:
4907/***/ (function(module, exports, __webpack_require__) {
4908
4909"use strict";
4910
4911Object.defineProperty(exports, "__esModule", ({
4912    value: true
4913}));
4914Object.defineProperty(exports, "shouldHardNavigate", ({
4915    enumerable: true,
4916    get: function() {
4917        return shouldHardNavigate;
4918    }
4919}));
4920const _matchsegments = __webpack_require__(1118);
4921function shouldHardNavigate(flightSegmentPath, flightRouterState) {
4922    const [segment, parallelRoutes] = flightRouterState;
4923    // TODO-APP: Check if `as` can be replaced.
4924    const [currentSegment, parallelRouteKey] = flightSegmentPath;
4925    // Check if current segment matches the existing segment.
4926    if (!(0, _matchsegments.matchSegment)(currentSegment, segment)) {
4927        // If dynamic parameter in tree doesn't match up with segment path a hard navigation is triggered.
4928        if (Array.isArray(currentSegment)) {
4929            return true;
4930        }
4931        // If the existing segment did not match soft navigation is triggered.
4932        return false;
4933    }
4934    const lastSegment = flightSegmentPath.length <= 2;
4935    if (lastSegment) {
4936        return false;
4937    }
4938    return shouldHardNavigate(flightSegmentPath.slice(2), parallelRoutes[parallelRouteKey]);
4939}
4940if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4941    Object.defineProperty(exports.default, "__esModule", {
4942        value: true
4943    });
4944    Object.assign(exports.default, exports);
4945    module.exports = exports.default;
4946} //# sourceMappingURL=should-hard-navigate.js.map
4947
4948
4949/***/ }),
4950
4951/***/ 8223:
4952/***/ (function(module, exports, __webpack_require__) {
4953
4954"use strict";
4955
4956Object.defineProperty(exports, "__esModule", ({
4957    value: true
4958}));
4959Object.defineProperty(exports, "createSearchParamsBailoutProxy", ({
4960    enumerable: true,
4961    get: function() {
4962        return createSearchParamsBailoutProxy;
4963    }
4964}));
4965const _staticgenerationbailout = __webpack_require__(7433);
4966function createSearchParamsBailoutProxy() {
4967    return new Proxy({}, {
4968        get (_target, prop) {
4969            // React adds some properties on the object when serializing for client components
4970            if (typeof prop === "string") {
4971                (0, _staticgenerationbailout.staticGenerationBailout)("searchParams." + prop);
4972            }
4973        }
4974    });
4975}
4976if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
4977    Object.defineProperty(exports.default, "__esModule", {
4978        value: true
4979    });
4980    Object.assign(exports.default, exports);
4981    module.exports = exports.default;
4982} //# sourceMappingURL=searchparams-bailout-proxy.js.map
4983
4984
4985/***/ }),
4986
4987/***/ 5300:
4988/***/ (function(module, exports, __webpack_require__) {
4989
4990"use strict";
4991
4992Object.defineProperty(exports, "__esModule", ({
4993    value: true
4994}));
4995Object.defineProperty(exports, "staticGenerationAsyncStorage", ({
4996    enumerable: true,
4997    get: function() {
4998        return staticGenerationAsyncStorage;
4999    }
5000}));
5001const _asynclocalstorage = __webpack_require__(2532);
5002const staticGenerationAsyncStorage = (0, _asynclocalstorage.createAsyncLocalStorage)();
5003if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5004    Object.defineProperty(exports.default, "__esModule", {
5005        value: true
5006    });
5007    Object.assign(exports.default, exports);
5008    module.exports = exports.default;
5009} //# sourceMappingURL=static-generation-async-storage.external.js.map
5010
5011
5012/***/ }),
5013
5014/***/ 7433:
5015/***/ (function(module, exports, __webpack_require__) {
5016
5017"use strict";
5018
5019Object.defineProperty(exports, "__esModule", ({
5020    value: true
5021}));
5022Object.defineProperty(exports, "staticGenerationBailout", ({
5023    enumerable: true,
5024    get: function() {
5025        return staticGenerationBailout;
5026    }
5027}));
5028const _hooksservercontext = __webpack_require__(3459);
5029const _staticgenerationasyncstorageexternal = __webpack_require__(5300);

5030class StaticGenBailoutError extends Error {
5031    constructor(...args){
5032        super(...args);
5033        this.code = "NEXT_STATIC_GEN_BAILOUT";
5034    }
5035}
5036function formatErrorMessage(reason, opts) {
5037    const { dynamic, link } = opts || {};
5038    const suffix = link ? " See more info here: " + link : "";
5039    return "Page" + (dynamic ? ' with `dynamic = "' + dynamic + '"`' : "") + " couldn't be rendered statically because it used `" + reason + "`." + suffix;
5040}
5041const staticGenerationBailout = (reason, param)=>{
5042    let { dynamic, link } = param === void 0 ? {} : param;
5043    const staticGenerationStore = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.getStore();
5044    if (!staticGenerationStore) return false;
5045    if (staticGenerationStore.forceStatic) {
5046        return true;
5047    }
5048    if (staticGenerationStore.dynamicShouldError) {
5049        throw new StaticGenBailoutError(formatErrorMessage(reason, {
5050            link,
5051            dynamic: dynamic != null ? dynamic : "error"
5052        }));
5053    }
5054    const message = formatErrorMessage(reason, {
5055        dynamic,
5056        // this error should be caught by Next to bail out of static generation
5057        // in case it's uncaught, this link provides some additional context as to why
5058        link: "https://nextjs.org/docs/messages/dynamic-server-error"
5059    });
5060    // If postpone is available, we should postpone the render.
5061    staticGenerationStore.postpone == null ? void 0 : staticGenerationStore.postpone.call(staticGenerationStore, reason);
5062    // As this is a bailout, we don't want to revalidate, so set the revalidate
5063    // to 0.
5064    staticGenerationStore.revalidate = 0;
5065    if (staticGenerationStore.isStaticGeneration) {
5066        const err = new _hooksservercontext.DynamicServerError(message);
5067        staticGenerationStore.dynamicUsageDescription = reason;
5068        staticGenerationStore.dynamicUsageStack = err.stack;
5069        throw err;
5070    }
5071    return false;
5072};
5073if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5074    Object.defineProperty(exports.default, "__esModule", {
5075        value: true
5076    });
5077    Object.assign(exports.default, exports);
5078    module.exports = exports.default;
5079} //# sourceMappingURL=static-generation-bailout.js.map
5080
5081
5082/***/ }),
5083
5084/***/ 3606:
5085/***/ (function(module, exports, __webpack_require__) {
5086
5087"use strict";
5088/* __next_internal_client_entry_do_not_use__  cjs */ 
5089Object.defineProperty(exports, "__esModule", ({
5090    value: true
5091}));
5092Object.defineProperty(exports, "default", ({
5093    enumerable: true,
5094    get: function() {
5095        return StaticGenerationSearchParamsBailoutProvider;
5096    }
5097}));
5098const _interop_require_default = __webpack_require__(7295);
5099const _jsxruntime = __webpack_require__(1411);
5100const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
5101const _searchparamsbailoutproxy = __webpack_require__(8223);
5102function StaticGenerationSearchParamsBailoutProvider(param) {
5103    let { Component, propsForComponent, isStaticGeneration } = param;
5104    if (isStaticGeneration) {
5105        const searchParams = (0, _searchparamsbailoutproxy.createSearchParamsBailoutProxy)();
5106        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
5107            searchParams: searchParams,
5108            ...propsForComponent
5109        });
5110    }
5111    return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
5112        ...propsForComponent
5113    });
5114}
5115if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5116    Object.defineProperty(exports.default, "__esModule", {
5117        value: true
5118    });
5119    Object.assign(exports.default, exports);
5120    module.exports = exports.default;
5121} //# sourceMappingURL=static-generation-searchparams-bailout-provider.js.map
5122
5123
5124/***/ }),
5125
5126/***/ 766:
5127/***/ (function(module, exports, __webpack_require__) {
5128
5129"use strict";
5130
5131Object.defineProperty(exports, "__esModule", ({
5132    value: true
5133}));
51340 && (0);
5135function _export(target, all) {
5136    for(var name in all)Object.defineProperty(target, name, {
5137        enumerable: true,
5138        get: all[name]
5139    });
5140}
5141_export(exports, {
5142    useUnwrapState: function() {
5143        return useUnwrapState;
5144    },
5145    useReducerWithReduxDevtools: function() {
5146        return useReducerWithReduxDevtools;
5147    }
5148});
5149const _interop_require_wildcard = __webpack_require__(3589);
5150const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
5151const _routerreducertypes = __webpack_require__(1606);
5152const _actionqueue = __webpack_require__(8811);
5153function normalizeRouterState(val) {
5154    if (val instanceof Map) {
5155        const obj = {};
5156        for (const [key, value] of val.entries()){
5157            if (typeof value === "function") {
5158                obj[key] = "fn()";
5159                continue;
5160            }
5161            if (typeof value === "object" && value !== null) {
5162                if (value.$$typeof) {
5163                    obj[key] = value.$$typeof.toString();
5164                    continue;
5165                }
5166                if (value._bundlerConfig) {
5167                    obj[key] = "FlightData";
5168                    continue;
5169                }
5170            }
5171            obj[key] = normalizeRouterState(value);
5172        }
5173        return obj;
5174    }
5175    if (typeof val === "object" && val !== null) {
5176        const obj = {};
5177        for(const key in val){
5178            const value = val[key];
5179            if (typeof value === "function") {
5180                obj[key] = "fn()";
5181                continue;
5182            }
5183            if (typeof value === "object" && value !== null) {
5184                if (value.$$typeof) {
5185                    obj[key] = value.$$typeof.toString();
5186                    continue;
5187                }
5188                if (value.hasOwnProperty("_bundlerConfig")) {
5189                    obj[key] = "FlightData";
5190                    continue;
5191                }
5192            }
5193            obj[key] = normalizeRouterState(value);
5194        }
5195        return obj;
5196    }
5197    if (Array.isArray(val)) {
5198        return val.map(normalizeRouterState);
5199    }
5200    return val;
5201}
5202function useUnwrapState(state) {
5203    // reducer actions can be async, so sometimes we need to suspend until the state is resolved
5204    if ((0, _routerreducertypes.isThenable)(state)) {
5205        const result = (0, _react.use)(state);
5206        return result;
5207    }
5208    return state;
5209}
5210function useReducerWithReduxDevtoolsNoop(initialState) {
5211    return [
5212        initialState,
5213        ()=>{},
5214        ()=>{}
5215    ];
5216}
5217function useReducerWithReduxDevtoolsImpl(initialState) {
5218    const [state, setState] = _react.default.useState(initialState);
5219    const actionQueue = (0, _react.useContext)(_actionqueue.ActionQueueContext);
5220    if (!actionQueue) {
5221        throw new Error("Invariant: Missing ActionQueueContext");
5222    }
5223    const devtoolsConnectionRef = (0, _react.useRef)();
5224    const enabledRef = (0, _react.useRef)();
5225    (0, _react.useEffect)(()=>{
5226        if (devtoolsConnectionRef.current || enabledRef.current === false) {
5227            return;
5228        }
5229        if (enabledRef.current === undefined && typeof window.__REDUX_DEVTOOLS_EXTENSION__ === "undefined") {
5230            enabledRef.current = false;

5231            return;
5232        }
5233        devtoolsConnectionRef.current = window.__REDUX_DEVTOOLS_EXTENSION__.connect({
5234            instanceId: 8000,
5235            name: "next-router"
5236        });
5237        if (devtoolsConnectionRef.current) {
5238            devtoolsConnectionRef.current.init(normalizeRouterState(initialState));
5239            if (actionQueue) {
5240                actionQueue.devToolsInstance = devtoolsConnectionRef.current;
5241            }
5242        }
5243        return ()=>{
5244            devtoolsConnectionRef.current = undefined;
5245        };
5246    }, [
5247        initialState,
5248        actionQueue
5249    ]);
5250    const dispatch = (0, _react.useCallback)((action)=>{
5251        if (!actionQueue.state) {
5252            // we lazy initialize the mutable action queue state since the data needed
5253            // to generate the state is not available when the actionQueue context is created
5254            actionQueue.state = initialState;
5255        }
5256        actionQueue.dispatch(action, setState);
5257    }, [
5258        actionQueue,
5259        initialState
5260    ]);
5261    // Sync is called after a state update in the HistoryUpdater,
5262    // for debugging purposes. Since the reducer state may be a Promise,
5263    // we let the app router use() it and sync on the resolved value if
5264    // something changed.
5265    // Using the `state` here would be referentially unstable and cause
5266    // undesirable re-renders and history updates.
5267    const sync = (0, _react.useCallback)((resolvedState)=>{
5268        if (devtoolsConnectionRef.current) {
5269            devtoolsConnectionRef.current.send({
5270                type: "RENDER_SYNC"
5271            }, normalizeRouterState(resolvedState));
5272        }
5273    }, []);
5274    return [
5275        state,
5276        dispatch,
5277        sync
5278    ];
5279}
5280const useReducerWithReduxDevtools =  true ? useReducerWithReduxDevtoolsImpl : 0;
5281if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5282    Object.defineProperty(exports.default, "__esModule", {
5283        value: true
5284    });
5285    Object.assign(exports.default, exports);
5286    module.exports = exports.default;
5287} //# sourceMappingURL=use-reducer-with-devtools.js.map
5288
5289
5290/***/ }),
5291
5292/***/ 1152:
5293/***/ (function(module, exports, __webpack_require__) {
5294
5295"use strict";
5296
5297Object.defineProperty(exports, "__esModule", ({
5298    value: true
5299}));
5300Object.defineProperty(exports, "hasBasePath", ({
5301    enumerable: true,
5302    get: function() {
5303        return hasBasePath;
5304    }
5305}));
5306const _pathhasprefix = __webpack_require__(1666);
5307const basePath =  false || "";
5308function hasBasePath(path) {
5309    return (0, _pathhasprefix.pathHasPrefix)(path, basePath);
5310}
5311if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5312    Object.defineProperty(exports.default, "__esModule", {
5313        value: true
5314    });
5315    Object.assign(exports.default, exports);
5316    module.exports = exports.default;
5317} //# sourceMappingURL=has-base-path.js.map
5318
5319
5320/***/ }),
5321
5322/***/ 9926:
5323/***/ (function(module, exports, __webpack_require__) {
5324
5325"use strict";
5326
5327Object.defineProperty(exports, "__esModule", ({
5328    value: true
5329}));
5330Object.defineProperty(exports, "normalizePathTrailingSlash", ({
5331    enumerable: true,
5332    get: function() {
5333        return normalizePathTrailingSlash;
5334    }
5335}));
5336const _removetrailingslash = __webpack_require__(6632);
5337const _parsepath = __webpack_require__(5322);
5338const normalizePathTrailingSlash = (path)=>{
5339    if (!path.startsWith("/") || undefined) {
5340        return path;
5341    }
5342    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
5343    if (false) {}
5344    return "" + (0, _removetrailingslash.removeTrailingSlash)(pathname) + query + hash;
5345};
5346if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5347    Object.defineProperty(exports.default, "__esModule", {
5348        value: true
5349    });
5350    Object.assign(exports.default, exports);
5351    module.exports = exports.default;
5352} //# sourceMappingURL=normalize-trailing-slash.js.map
5353
5354
5355/***/ }),
5356
5357/***/ 8325:
5358/***/ (function(module, exports, __webpack_require__) {
5359
5360"use strict";
5361
5362Object.defineProperty(exports, "__esModule", ({
5363    value: true
5364}));
5365Object.defineProperty(exports, "default", ({
5366    enumerable: true,
5367    get: function() {
5368        return onRecoverableError;
5369    }
5370}));
5371const _nossrerror = __webpack_require__(6103);
5372function onRecoverableError(err) {
5373    // Using default react onRecoverableError
5374    // x-ref: https://github.com/facebook/react/blob/d4bc16a7d69eb2ea38a88c8ac0b461d5f72cdcab/packages/react-dom/src/client/ReactDOMRoot.js#L83
5375    const defaultOnRecoverableError = typeof reportError === "function" ? reportError : (error)=>{
5376        window.console.error(error);
5377    };
5378    // Skip certain custom errors which are not expected to be reported on client
5379    if ((0, _nossrerror.isBailoutCSRError)(err)) return;
5380    defaultOnRecoverableError(err);
5381}
5382if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5383    Object.defineProperty(exports.default, "__esModule", {
5384        value: true
5385    });

5386    Object.assign(exports.default, exports);
5387    module.exports = exports.default;
5388} //# sourceMappingURL=on-recoverable-error.js.map
5389
5390
5391/***/ }),
5392
5393/***/ 657:
5394/***/ (function(module, exports, __webpack_require__) {
5395
5396"use strict";
5397
5398Object.defineProperty(exports, "__esModule", ({
5399    value: true
5400}));
5401Object.defineProperty(exports, "removeBasePath", ({
5402    enumerable: true,
5403    get: function() {
5404        return removeBasePath;
5405    }
5406}));
5407const _hasbasepath = __webpack_require__(1152);
5408const basePath =  false || "";
5409function removeBasePath(path) {
5410    if (false) {}
5411    // Can't trim the basePath if it has zero length!
5412    if (basePath.length === 0) return path;
5413    path = path.slice(basePath.length);
5414    if (!path.startsWith("/")) path = "/" + path;
5415    return path;
5416}
5417if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
5418    Object.defineProperty(exports.default, "__esModule", {
5419        value: true
5420    });
5421    Object.assign(exports.default, exports);
5422    module.exports = exports.default;
5423} //# sourceMappingURL=remove-base-path.js.map
5424
5425
5426/***/ }),
5427
5428/***/ 1214:
5429/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5430
5431"use strict";
5432/* __next_internal_client_entry_do_not_use__  cjs */ 
5433Object.defineProperty(exports, "__esModule", ({
5434    value: true
5435}));
54360 && (0);
5437function _export(target, all) {
5438    for(var name in all)Object.defineProperty(target, name, {
5439        enumerable: true,
5440        get: all[name]
5441    });
5442}
5443_export(exports, {
5444    AppRouterContext: function() {
5445        return AppRouterContext;
5446    },
5447    LayoutRouterContext: function() {
5448        return LayoutRouterContext;
5449    },
5450    GlobalLayoutRouterContext: function() {
5451        return GlobalLayoutRouterContext;
5452    },
5453    TemplateContext: function() {
5454        return TemplateContext;
5455    }
5456});
5457const _interop_require_default = __webpack_require__(7295);
5458const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
5459const AppRouterContext = _react.default.createContext(null);
5460const LayoutRouterContext = _react.default.createContext(null);
5461const GlobalLayoutRouterContext = _react.default.createContext(null);
5462const TemplateContext = _react.default.createContext(null);
5463if (false) {} //# sourceMappingURL=app-router-context.shared-runtime.js.map
5464
5465
5466/***/ }),
5467
5468/***/ 3178:
5469/***/ (function(__unused_webpack_module, exports) {
5470
5471"use strict";

5472// http://www.cse.yorku.ca/~oz/hash.html
5473// More specifically, 32-bit hash via djbxor
5474// (ref: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765#gistcomment-3367765)
5475// This is due to number type differences between rust for turbopack to js number types,
5476// where rust does not have easy way to repreesnt js's 53-bit float number type for the matching
5477// overflow behavior. This is more `correct` in terms of having canonical hash across different runtime / implementation
5478// as can gaurantee determinstic output from 32bit hash.
5479
5480Object.defineProperty(exports, "__esModule", ({
5481    value: true
5482}));
54830 && (0);
5484function _export(target, all) {
5485    for(var name in all)Object.defineProperty(target, name, {
5486        enumerable: true,
5487        get: all[name]
5488    });
5489}
5490_export(exports, {
5491    djb2Hash: function() {
5492        return djb2Hash;
5493    },
5494    hexHash: function() {
5495        return hexHash;
5496    }
5497});
5498function djb2Hash(str) {
5499    let hash = 5381;
5500    for(let i = 0; i < str.length; i++){
5501        const char = str.charCodeAt(i);
5502        hash = (hash << 5) + hash + char & 0xffffffff;
5503    }
5504    return hash >>> 0;
5505}
5506function hexHash(str) {
5507    return djb2Hash(str).toString(36).slice(0, 5);
5508} //# sourceMappingURL=hash.js.map
5509
5510
5511/***/ }),
5512
5513/***/ 6061:
5514/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5515
5516"use strict";
5517
5518Object.defineProperty(exports, "__esModule", ({
5519    value: true
5520}));
5521Object.defineProperty(exports, "HeadManagerContext", ({
5522    enumerable: true,
5523    get: function() {
5524        return HeadManagerContext;
5525    }
5526}));
5527const _interop_require_default = __webpack_require__(7295);
5528const _react = /*#__PURE__*/ _interop_require_default._(__webpack_require__(9988));
5529const HeadManagerContext = _react.default.createContext({});
5530if (false) {} //# sourceMappingURL=head-manager-context.shared-runtime.js.map
5531
5532
5533/***/ }),
5534
5535/***/ 8581:
5536/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5537
5538"use strict";
5539/* __next_internal_client_entry_do_not_use__  cjs */ 
5540Object.defineProperty(exports, "__esModule", ({
5541    value: true
5542}));
55430 && (0);
5544function _export(target, all) {
5545    for(var name in all)Object.defineProperty(target, name, {
5546        enumerable: true,
5547        get: all[name]
5548    });
5549}
5550_export(exports, {
5551    SearchParamsContext: function() {
5552        return SearchParamsContext;
5553    },
5554    PathnameContext: function() {
5555        return PathnameContext;
5556    },
5557    PathParamsContext: function() {
5558        return PathParamsContext;
5559    }
5560});
5561const _react = __webpack_require__(9988);
5562const SearchParamsContext = (0, _react.createContext)(null);
5563const PathnameContext = (0, _react.createContext)(null);
5564const PathParamsContext = (0, _react.createContext)(null);
5565if (false) {} //# sourceMappingURL=hooks-client-context.shared-runtime.js.map
5566
5567
5568/***/ }),
5569
5570/***/ 6103:
5571/***/ (function(__unused_webpack_module, exports) {
5572
5573"use strict";

5574// This has to be a shared module which is shared between client component error boundary and dynamic component
5575
5576Object.defineProperty(exports, "__esModule", ({
5577    value: true
5578}));
55790 && (0);
5580function _export(target, all) {
5581    for(var name in all)Object.defineProperty(target, name, {
5582        enumerable: true,
5583        get: all[name]
5584    });
5585}
5586_export(exports, {
5587    NEXT_DYNAMIC_NO_SSR_CODE: function() {
5588        return NEXT_DYNAMIC_NO_SSR_CODE;
5589    },
5590    throwWithNoSSR: function() {
5591        return throwWithNoSSR;
5592    },
5593    isBailoutCSRError: function() {
5594        return isBailoutCSRError;
5595    }
5596});
5597const NEXT_DYNAMIC_NO_SSR_CODE = "NEXT_DYNAMIC_NO_SSR_CODE";
5598function throwWithNoSSR() {
5599    const error = new Error(NEXT_DYNAMIC_NO_SSR_CODE);
5600    error.digest = NEXT_DYNAMIC_NO_SSR_CODE;
5601    throw error;
5602}
5603function isBailoutCSRError(err) {
5604    return (err == null ? void 0 : err.digest) === NEXT_DYNAMIC_NO_SSR_CODE;
5605} //# sourceMappingURL=no-ssr-error.js.map
5606
5607
5608/***/ }),
5609
5610/***/ 18:
5611/***/ (function(__unused_webpack_module, exports) {
5612
5613"use strict";
5614/**
5615 * For a given page path, this function ensures that there is a leading slash.
5616 * If there is not a leading slash, one is added, otherwise it is noop.
5617 */ 
5618Object.defineProperty(exports, "__esModule", ({
5619    value: true
5620}));
5621Object.defineProperty(exports, "ensureLeadingSlash", ({
5622    enumerable: true,
5623    get: function() {
5624        return ensureLeadingSlash;
5625    }
5626}));
5627function ensureLeadingSlash(path) {
5628    return path.startsWith("/") ? path : "/" + path;
5629} //# sourceMappingURL=ensure-leading-slash.js.map
5630
5631
5632/***/ }),
5633
5634/***/ 8811:
5635/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5636
5637"use strict";
5638
5639Object.defineProperty(exports, "__esModule", ({
5640    value: true
5641}));
56420 && (0);
5643function _export(target, all) {
5644    for(var name in all)Object.defineProperty(target, name, {
5645        enumerable: true,
5646        get: all[name]
5647    });
5648}
5649_export(exports, {
5650    ActionQueueContext: function() {
5651        return ActionQueueContext;
5652    },
5653    createMutableActionQueue: function() {
5654        return createMutableActionQueue;
5655    }
5656});
5657const _interop_require_wildcard = __webpack_require__(3589);
5658const _routerreducertypes = __webpack_require__(1606);
5659const _routerreducer = __webpack_require__(490);
5660const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
5661const ActionQueueContext = _react.default.createContext(null);
5662function runRemainingActions(actionQueue, setState) {
5663    if (actionQueue.pending !== null) {
5664        actionQueue.pending = actionQueue.pending.next;
5665        if (actionQueue.pending !== null) {
5666            // eslint-disable-next-line @typescript-eslint/no-use-before-define
5667            runAction({
5668                actionQueue,
5669                action: actionQueue.pending,
5670                setState
5671            });
5672        }
5673    }
5674}
5675async function runAction(param) {
5676    let { actionQueue, action, setState } = param;
5677    const prevState = actionQueue.state;
5678    if (!prevState) {
5679        // This shouldn't happen as the state is initialized in the dispatcher if it's not set
5680        throw new Error("Invariant: Router state not initialized");
5681    }
5682    actionQueue.pending = action;
5683    const payload = action.payload;
5684    const actionResult = actionQueue.action(prevState, payload);
5685    function handleResult(nextState) {
5686        // if we discarded this action, the state should also be discarded
5687        if (action.discarded) {
5688            // if a refresh is needed, we only want to trigger it once the action queue is empty
5689            if (actionQueue.needsRefresh && actionQueue.pending === null) {
5690                actionQueue.needsRefresh = false;
5691                actionQueue.dispatch({
5692                    type: _routerreducertypes.ACTION_REFRESH,
5693                    origin: window.location.origin
5694                }, setState);
5695            }
5696            return;
5697        }
5698        actionQueue.state = nextState;
5699        if (actionQueue.devToolsInstance) {
5700            actionQueue.devToolsInstance.send(payload, nextState);
5701        }

5702        runRemainingActions(actionQueue, setState);
5703        action.resolve(nextState);
5704    }
5705    // if the action is a promise, set up a callback to resolve it
5706    if ((0, _routerreducertypes.isThenable)(actionResult)) {
5707        actionResult.then(handleResult, (err)=>{
5708            runRemainingActions(actionQueue, setState);
5709            action.reject(err);
5710        });
5711    } else {
5712        handleResult(actionResult);
5713    }
5714}
5715function dispatchAction(actionQueue, payload, setState) {
5716    let resolvers = {
5717        resolve: setState,
5718        reject: ()=>{}
5719    };
5720    // most of the action types are async with the exception of restore
5721    // it's important that restore is handled quickly since it's fired on the popstate event
5722    // and we don't want to add any delay on a back/forward nav
5723    // this only creates a promise for the async actions
5724    if (payload.type !== _routerreducertypes.ACTION_RESTORE) {
5725        // Create the promise and assign the resolvers to the object.
5726        const deferredPromise = new Promise((resolve, reject)=>{
5727            resolvers = {
5728                resolve,
5729                reject
5730            };
5731        });
5732        (0, _react.startTransition)(()=>{
5733            // we immediately notify React of the pending promise -- the resolver is attached to the action node
5734            // and will be called when the associated action promise resolves
5735            setState(deferredPromise);
5736        });
5737    }
5738    const newAction = {
5739        payload,
5740        next: null,
5741        resolve: resolvers.resolve,
5742        reject: resolvers.reject
5743    };
5744    // Check if the queue is empty
5745    if (actionQueue.pending === null) {
5746        // The queue is empty, so add the action and start it immediately
5747        // Mark this action as the last in the queue
5748        actionQueue.last = newAction;
5749        runAction({
5750            actionQueue,
5751            action: newAction,
5752            setState
5753        });
5754    } else if (payload.type === _routerreducertypes.ACTION_NAVIGATE) {
5755        // Navigations take priority over any pending actions.
5756        // Mark the pending action as discarded (so the state is never applied) and start the navigation action immediately.
5757        actionQueue.pending.discarded = true;
5758        // Mark this action as the last in the queue
5759        actionQueue.last = newAction;
5760        // if the pending action was a server action, mark the queue as needing a refresh once events are processed
5761        if (actionQueue.pending.payload.type === _routerreducertypes.ACTION_SERVER_ACTION) {
5762            actionQueue.needsRefresh = true;
5763        }
5764        runAction({
5765            actionQueue,
5766            action: newAction,
5767            setState
5768        });
5769    } else {
5770        // The queue is not empty, so add the action to the end of the queue
5771        // It will be started by runRemainingActions after the previous action finishes
5772        if (actionQueue.last !== null) {
5773            actionQueue.last.next = newAction;
5774        }
5775        actionQueue.last = newAction;
5776    }
5777}
5778function createMutableActionQueue() {
5779    const actionQueue = {
5780        state: null,
5781        dispatch: (payload, setState)=>dispatchAction(actionQueue, payload, setState),
5782        action: async (state, action)=>{
5783            if (state === null) {
5784                throw new Error("Invariant: Router state not initialized");
5785            }
5786            const result = (0, _routerreducer.reducer)(state, action);
5787            return result;
5788        },
5789        pending: null,
5790        last: null
5791    };
5792    return actionQueue;
5793} //# sourceMappingURL=action-queue.js.map
5794
5795
5796/***/ }),
5797
5798/***/ 3952:
5799/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5800
5801"use strict";
5802
5803Object.defineProperty(exports, "__esModule", ({
5804    value: true
5805}));
5806Object.defineProperty(exports, "addPathPrefix", ({
5807    enumerable: true,
5808    get: function() {
5809        return addPathPrefix;
5810    }
5811}));
5812const _parsepath = __webpack_require__(5322);
5813function addPathPrefix(path, prefix) {
5814    if (!path.startsWith("/") || !prefix) {
5815        return path;
5816    }
5817    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
5818    return "" + prefix + pathname + query + hash;
5819} //# sourceMappingURL=add-path-prefix.js.map
5820
5821
5822/***/ }),
5823
5824/***/ 8640:
5825/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5826
5827"use strict";
5828
5829Object.defineProperty(exports, "__esModule", ({
5830    value: true
5831}));
58320 && (0);
5833function _export(target, all) {
5834    for(var name in all)Object.defineProperty(target, name, {
5835        enumerable: true,
5836        get: all[name]
5837    });
5838}
5839_export(exports, {
5840    normalizeAppPath: function() {
5841        return normalizeAppPath;
5842    },
5843    normalizeRscURL: function() {
5844        return normalizeRscURL;
5845    }
5846});
5847const _ensureleadingslash = __webpack_require__(18);
5848const _segment = __webpack_require__(1956);
5849function normalizeAppPath(route) {
5850    return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment, index, segments)=>{
5851        // Empty segments are ignored.
5852        if (!segment) {
5853            return pathname;
5854        }
5855        // Groups are ignored.
5856        if ((0, _segment.isGroupSegment)(segment)) {
5857            return pathname;
5858        }
5859        // Parallel segments are ignored.
5860        if (segment[0] === "@") {
5861            return pathname;
5862        }
5863        // The last segment (if it's a leaf) should be ignored.
5864        if ((segment === "page" || segment === "route") && index === segments.length - 1) {
5865            return pathname;
5866        }
5867        return pathname + "/" + segment;
5868    }, ""));
5869}
5870function normalizeRscURL(url) {
5871    return url.replace(/\.rsc($|\?)/, "$1");
5872}

5872 //# sourceMappingURL=app-paths.js.map
5873
5874
5875/***/ }),
5876
5877/***/ 4875:
5878/***/ (function(__unused_webpack_module, exports) {
5879
5880"use strict";
5881/**
5882 * Run function with `scroll-behavior: auto` applied to `<html/>`.
5883 * This css change will be reverted after the function finishes.
5884 */ 
5885Object.defineProperty(exports, "__esModule", ({
5886    value: true
5887}));
5888Object.defineProperty(exports, "handleSmoothScroll", ({
5889    enumerable: true,
5890    get: function() {
5891        return handleSmoothScroll;
5892    }
5893}));
5894function handleSmoothScroll(fn, options) {
5895    if (options === void 0) options = {};
5896    // if only the hash is changed, we don't need to disable smooth scrolling
5897    // we only care to prevent smooth scrolling when navigating to a new page to avoid jarring UX
5898    if (options.onlyHashChange) {
5899        fn();
5900        return;
5901    }
5902    const htmlElement = document.documentElement;
5903    const existing = htmlElement.style.scrollBehavior;
5904    htmlElement.style.scrollBehavior = "auto";
5905    if (!options.dontForceLayout) {
5906        // In Chrome-based browsers we need to force reflow before calling `scrollTo`.
5907        // Otherwise it will not pickup the change in scrollBehavior
5908        // More info here: https://github.com/vercel/next.js/issues/40719#issuecomment-1336248042
5909        htmlElement.getClientRects();
5910    }
5911    fn();
5912    htmlElement.style.scrollBehavior = existing;
5913} //# sourceMappingURL=handle-smooth-scroll.js.map
5914
5915
5916/***/ }),
5917
5918/***/ 1778:
5919/***/ (function(__unused_webpack_module, exports) {
5920
5921"use strict";
5922
5923Object.defineProperty(exports, "__esModule", ({
5924    value: true
5925}));
5926Object.defineProperty(exports, "isBot", ({
5927    enumerable: true,
5928    get: function() {
5929        return isBot;
5930    }
5931}));
5932function isBot(userAgent) {
5933    return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(userAgent);
5934} //# sourceMappingURL=is-bot.js.map
5935
5936
5937/***/ }),
5938
5939/***/ 5322:
5940/***/ (function(__unused_webpack_module, exports) {
5941
5942"use strict";
5943/**
5944 * Given a path this function will find the pathname, query and hash and return
5945 * them. This is useful to parse full paths on the client side.
5946 * @param path A path to parse e.g. /foo/bar?id=1#hash
5947 */ 
5948Object.defineProperty(exports, "__esModule", ({
5949    value: true
5950}));
5951Object.defineProperty(exports, "parsePath", ({
5952    enumerable: true,
5953    get: function() {
5954        return parsePath;
5955    }
5956}));
5957function parsePath(path) {
5958    const hashIndex = path.indexOf("#");
5959    const queryIndex = path.indexOf("?");
5960    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
5961    if (hasQuery || hashIndex > -1) {
5962        return {
5963            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
5964            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : "",
5965            hash: hashIndex > -1 ? path.slice(hashIndex) : ""
5966        };
5967    }
5968    return {
5969        pathname: path,
5970        query: "",
5971        hash: ""
5972    };
5973} //# sourceMappingURL=parse-path.js.map
5974
5975
5976/***/ }),
5977
5978/***/ 1666:
5979/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
5980
5981"use strict";
5982
5983Object.defineProperty(exports, "__esModule", ({
5984    value: true
5985}));
5986Object.defineProperty(exports, "pathHasPrefix", ({
5987    enumerable: true,
5988    get: function() {
5989        return pathHasPrefix;
5990    }
5991}));
5992const _parsepath = __webpack_require__(5322);
5993function pathHasPrefix(path, prefix) {
5994    if (typeof path !== "string") {
5995        return false;
5996    }
5997    const { pathname } = (0, _parsepath.parsePath)(path);
5998    return pathname === prefix || pathname.startsWith(prefix + "/");
5999} //# sourceMappingURL=path-has-prefix.js.map
6000
6001
6002/***/ }),
6003
6004/***/ 6632:
6005/***/ (function(__unused_webpack_module, exports) {
6006
6007"use strict";
6008/**
6009 * Removes the trailing slash for a given route or page path. Preserves the
6010 * root page. Examples:
6011 *   - `/foo/bar/` -> `/foo/bar`
6012 *   - `/foo/bar` -> `/foo/bar`
6013 *   - `/` -> `/`
6014 */ 
6015Object.defineProperty(exports, "__esModule", ({
6016    value: true
6017}));
6018Object.defineProperty(exports, "removeTrailingSlash", ({
6019    enumerable: true,
6020    get: function() {
6021        return removeTrailingSlash;
6022    }
6023}));
6024function removeTrailingSlash(route) {
6025    return route.replace(/\/$/, "") || "/";
6026} //# sourceMappingURL=remove-trailing-slash.js.map
6027
6028
6029/***/ }),
6030
6031/***/ 1956:

6032/***/ (function(__unused_webpack_module, exports) {
6033
6034"use strict";
6035
6036Object.defineProperty(exports, "__esModule", ({
6037    value: true
6038}));
60390 && (0);
6040function _export(target, all) {
6041    for(var name in all)Object.defineProperty(target, name, {
6042        enumerable: true,
6043        get: all[name]
6044    });
6045}
6046_export(exports, {
6047    isGroupSegment: function() {
6048        return isGroupSegment;
6049    },
6050    PAGE_SEGMENT_KEY: function() {
6051        return PAGE_SEGMENT_KEY;
6052    },
6053    DEFAULT_SEGMENT_KEY: function() {
6054        return DEFAULT_SEGMENT_KEY;
6055    }
6056});
6057function isGroupSegment(segment) {
6058    // Use array[0] for performant purpose
6059    return segment[0] === "(" && segment.endsWith(")");
6060}
6061const PAGE_SEGMENT_KEY = "__PAGE__";
6062const DEFAULT_SEGMENT_KEY = "__DEFAULT__"; //# sourceMappingURL=segment.js.map
6063
6064
6065/***/ }),
6066
6067/***/ 2342:
6068/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6069
6070"use strict";
6071/* __next_internal_client_entry_do_not_use__  cjs */ 
6072Object.defineProperty(exports, "__esModule", ({
6073    value: true
6074}));
60750 && (0);
6076function _export(target, all) {
6077    for(var name in all)Object.defineProperty(target, name, {
6078        enumerable: true,
6079        get: all[name]
6080    });
6081}
6082_export(exports, {
6083    ServerInsertedHTMLContext: function() {
6084        return ServerInsertedHTMLContext;
6085    },
6086    useServerInsertedHTML: function() {
6087        return useServerInsertedHTML;
6088    }
6089});
6090const _interop_require_wildcard = __webpack_require__(3589);
6091const _react = /*#__PURE__*/ _interop_require_wildcard._(__webpack_require__(9988));
6092const ServerInsertedHTMLContext = /*#__PURE__*/ _react.default.createContext(null);
6093function useServerInsertedHTML(callback) {
6094    const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
6095    // Should have no effects on client where there's no flush effects provider
6096    if (addInsertedServerHTMLCallback) {
6097        addInsertedServerHTMLCallback(callback);
6098    }
6099} //# sourceMappingURL=server-inserted-html.shared-runtime.js.map
6100
6101
6102/***/ }),
6103
6104/***/ 2532:
6105/***/ (function(module, exports) {
6106
6107"use strict";
6108
6109Object.defineProperty(exports, "__esModule", ({
6110    value: true
6111}));
6112Object.defineProperty(exports, "createAsyncLocalStorage", ({
6113    enumerable: true,
6114    get: function() {
6115        return createAsyncLocalStorage;
6116    }
6117}));
6118const sharedAsyncLocalStorageNotAvailableError = new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available");
6119class FakeAsyncLocalStorage {
6120    disable() {
6121        throw sharedAsyncLocalStorageNotAvailableError;
6122    }
6123    getStore() {
6124        // This fake implementation of AsyncLocalStorage always returns `undefined`.
6125        return undefined;
6126    }
6127    run() {
6128        throw sharedAsyncLocalStorageNotAvailableError;
6129    }
6130    exit() {
6131        throw sharedAsyncLocalStorageNotAvailableError;
6132    }
6133    enterWith() {
6134        throw sharedAsyncLocalStorageNotAvailableError;
6135    }
6136}
6137const maybeGlobalAsyncLocalStorage = globalThis.AsyncLocalStorage;
6138function createAsyncLocalStorage() {
6139    if (maybeGlobalAsyncLocalStorage) {
6140        return new maybeGlobalAsyncLocalStorage();
6141    }
6142    return new FakeAsyncLocalStorage();
6143}
6144if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
6145    Object.defineProperty(exports.default, "__esModule", {
6146        value: true
6147    });
6148    Object.assign(exports.default, exports);
6149    module.exports = exports.default;
6150} //# sourceMappingURL=async-local-storage.js.map
6151
6152
6153/***/ }),
6154
6155/***/ 1626:
6156/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6157
6158"use strict";
6159
6160
6161var m = __webpack_require__(7897);
6162if (true) {
6163  exports.createRoot = m.createRoot;
6164  exports.hydrateRoot = m.hydrateRoot;
6165} else { var i; }
6166
6167
6168/***/ }),
6169
6170/***/ 7897:
6171/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6172
6173"use strict";
6174
6175
6176function checkDCE() {
6177  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
6178  if (
6179    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||
6180    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
6181  ) {
6182    return;
6183  }
6184  if (false) {}
6185  try {
6186    // Verify that the code above has been dead code eliminated (DCE'd).
6187    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
6188  } catch (err) {
6189    // DevTools shouldn't crash React, no matter what.
6190    // We should still report in case we break this code.
6191    console.error(err);
6192  }
6193}
6194
6195if (true) {

6196  // DCE check should happen before ReactDOM bundle executes so that
6197  // DevTools can report bad minification during injection.
6198  checkDCE();
6199  module.exports = __webpack_require__(7174);
6200} else {}
6201
6202
6203/***/ }),
6204
6205/***/ 2453:
6206/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6207
6208"use strict";
6209/*
6210 React
6211 react-server-dom-webpack-client.browser.production.min.js
6212
6213 Copyright (c) Meta Platforms, Inc. and affiliates.
6214
6215 This source code is licensed under the MIT license found in the
6216 LICENSE file in the root directory of this source tree.
6217*/
6218var r=__webpack_require__(7897),t=__webpack_require__(9988),u={stream:!0};function v(a,b){if(a){var c=a[b[0]];if(a=c[b[2]])c=a.name;else{a=c["*"];if(!a)throw Error('Could not find the module "'+b[0]+'" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.');c=b[2]}return 4===b.length?[a.id,a.chunks,c,1]:[a.id,a.chunks,c]}return b}var w=new Map;
6219function x(a){var b=__webpack_require__(a);if("function"!==typeof b.then||"fulfilled"===b.status)return null;b.then(function(c){b.status="fulfilled";b.value=c},function(c){b.status="rejected";b.reason=c});return b}function y(){}
6220function z(a){for(var b=a[1],c=[],e=0;e<b.length;){var l=b[e++],k=b[e++],n=w.get(l);void 0===n?(A.set(l,k),k=__webpack_require__.e(l),c.push(k),n=w.set.bind(w,l,null),k.then(n,y),w.set(l,k)):null!==n&&c.push(n)}return 4===a.length?0===c.length?x(a[0]):Promise.all(c).then(function(){return x(a[0])}):0<c.length?Promise.all(c):null}var A=new Map,B=__webpack_require__.u;__webpack_require__.u=function(a){var b=A.get(a);return void 0!==b?b:B(a)};
6221var aa=r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Dispatcher,C=Symbol.for("react.element"),ba=Symbol.for("react.provider"),ca=Symbol.for("react.server_context"),da=Symbol.for("react.lazy"),E=Symbol.for("react.default_value"),F=Symbol.iterator;function ea(a){if(null===a||"object"!==typeof a)return null;a=F&&a[F]||a["@@iterator"];return"function"===typeof a?a:null}var fa=Array.isArray,G=Object.getPrototypeOf,ha=Object.prototype,I=new WeakMap;
6222function ia(a){return Number.isFinite(a)?0===a&&-Infinity===1/a?"$-0":a:Infinity===a?"$Infinity":-Infinity===a?"$-Infinity":"$NaN"}
6223function ja(a,b,c,e){function l(m,d){if(null===d)return null;if("object"===typeof d){if("function"===typeof d.then){null===g&&(g=new FormData);n++;var h=k++;d.then(function(p){p=JSON.stringify(p,l);var q=g;q.append(b+h,p);n--;0===n&&c(q)},function(p){e(p)});return"$@"+h.toString(16)}if(fa(d))return d;if(d instanceof FormData){null===g&&(g=new FormData);var f=g;m=k++;var D=b+m+"_";d.forEach(function(p,q){f.append(D+q,p)});return"$K"+m.toString(16)}if(d instanceof Map)return d=JSON.stringify(Array.from(d),
6224l),null===g&&(g=new FormData),m=k++,g.append(b+m,d),"$Q"+m.toString(16);if(d instanceof Set)return d=JSON.stringify(Array.from(d),l),null===g&&(g=new FormData),m=k++,g.append(b+m,d),"$W"+m.toString(16);if(ea(d))return Array.from(d);m=G(d);if(m!==ha&&(null===m||null!==G(m)))throw Error("Only plain objects, and a few built-ins, can be passed to Server Actions. Classes or null prototypes are not supported.");return d}if("string"===typeof d){if("Z"===d[d.length-1]&&this[m]instanceof Date)return"$D"+d;
6225d="$"===d[0]?"$"+d:d;return d}if("boolean"===typeof d)return d;if("number"===typeof d)return ia(d);if("undefined"===typeof d)return"$undefined";if("function"===typeof d){d=I.get(d);if(void 0!==d)return d=JSON.stringify(d,l),null===g&&(g=new FormData),m=k++,g.set(b+m,d),"$F"+m.toString(16);throw Error("Client Functions cannot be passed directly to Server Functions. Only Functions passed from the Server can be passed back again.");}if("symbol"===typeof d){m=d.description;if(Symbol.for(m)!==d)throw Error("Only global symbols received from Symbol.for(...) can be passed to Server Functions. The symbol Symbol.for("+
6226(d.description+") cannot be found among global symbols."));return"$S"+m}if("bigint"===typeof d)return"$n"+d.toString(10);throw Error("Type "+typeof d+" is not supported as an argument to a Server Function.");}var k=1,n=0,g=null;a=JSON.stringify(a,l);null===g?c(a):(g.set(b+"0",a),0===n&&c(g))}function J(a,b){I.set(a,b)}

6226var K=t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ContextRegistry;function L(a,b,c,e){this.status=a;this.value=b;this.reason=c;this._response=e}L.prototype=Object.create(Promise.prototype);
6227L.prototype.then=function(a,b){switch(this.status){case "resolved_model":M(this);break;case "resolved_module":N(this)}switch(this.status){case "fulfilled":a(this.value);break;case "pending":case "blocked":case "cyclic":a&&(null===this.value&&(this.value=[]),this.value.push(a));b&&(null===this.reason&&(this.reason=[]),this.reason.push(b));break;default:b(this.reason)}};
6228function ka(a){switch(a.status){case "resolved_model":M(a);break;case "resolved_module":N(a)}switch(a.status){case "fulfilled":return a.value;case "pending":case "blocked":case "cyclic":throw a;default:throw a.reason;}}function O(a,b){for(var c=0;c<a.length;c++)(0,a[c])(b)}function P(a,b,c){switch(a.status){case "fulfilled":O(b,a.value);break;case "pending":case "blocked":case "cyclic":a.value=b;a.reason=c;break;case "rejected":c&&O(c,a.reason)}}
6229function Q(a,b){if("pending"===a.status||"blocked"===a.status){var c=a.reason;a.status="rejected";a.reason=b;null!==c&&O(c,b)}}function R(a,b){if("pending"===a.status||"blocked"===a.status){var c=a.value,e=a.reason;a.status="resolved_module";a.value=b;null!==c&&(N(a),P(a,c,e))}}var T=null,U=null;
6230function M(a){var b=T,c=U;T=a;U=null;var e=a.value;a.status="cyclic";a.value=null;a.reason=null;try{var l=JSON.parse(e,a._response._fromJSON);if(null!==U&&0<U.deps)U.value=l,a.status="blocked",a.value=null,a.reason=null;else{var k=a.value;a.status="fulfilled";a.value=l;null!==k&&O(k,l)}}catch(n){a.status="rejected",a.reason=n}finally{T=b,U=c}}
6231function N(a){try{var b=a.value,c=__webpack_require__(b[0]);if(4===b.length&&"function"===typeof c.then)if("fulfilled"===c.status)c=c.value;else throw c.reason;var e="*"===b[2]?c:""===b[2]?c.__esModule?c.default:c:c[b[2]];a.status="fulfilled";a.value=e}catch(l){a.status="rejected",a.reason=l}}function V(a,b){a._chunks.forEach(function(c){"pending"===c.status&&Q(c,b)})}function W(a,b){var c=a._chunks,e=c.get(b);e||(e=new L("pending",null,null,a),c.set(b,e));return e}
6232function la(a,b,c,e){if(U){var l=U;e||l.deps++}else l=U={deps:e?0:1,value:null};return function(k){b[c]=k;l.deps--;0===l.deps&&"blocked"===a.status&&(k=a.value,a.status="fulfilled",a.value=l.value,null!==k&&O(k,l.value))}}function ma(a){return function(b){return Q(a,b)}}
6233function na(a,b){function c(){var l=Array.prototype.slice.call(arguments),k=b.bound;return k?"fulfilled"===k.status?e(b.id,k.value.concat(l)):Promise.resolve(k).then(function(n){return e(b.id,n.concat(l))}):e(b.id,l)}var e=a._callServer;J(c,b);return c}function X(a,b){a=W(a,b);switch(a.status){case "resolved_model":M(a)}switch(a.status){case "fulfilled":return a.value;default:throw a.reason;}}
6234function oa(a,b,c,e){if("$"===e[0]){if("$"===e)return C;switch(e[1]){case "$":return e.slice(1);case "L":return b=parseInt(e.slice(2),16),a=W(a,b),{$$typeof:da,_payload:a,_init:ka};case "@":return b=parseInt(e.slice(2),16),W(a,b);case "S":return Symbol.for(e.slice(2));case "P":return a=e.slice(2),K[a]||(b={$$typeof:ca,_currentValue:E,_currentValue2:E,_defaultValue:E,_threadCount:0,Provider:null,Consumer:null,_globalName:a},b.Provider={$$typeof:ba,_context:b},K[a]=b),K[a].Provider;case "F":return b=
6235parseInt(e.slice(2),16),b=X(a,b),na(a,b);case "Q":return b=parseInt(e.slice(2),16),a=X(a,b),new Map(a);case "W":return b=parseInt(e.slice(2),16),a=X(a,b),new Set(a);case "I":return Infinity;case "-":return"$-0"===e?-0:-Infinity;case "N":return NaN;case "u":return;case "D":return new Date(Date.parse(e.slice(2)));case "n":return BigInt(e.slice(2));default:e=parseInt(e.slice(1),16);a=W(a,e);switch(a.status){case "resolved_model":M(a);break;case "resolved_module":N(a)}switch(a.status){case "fulfilled":return a.value;
6236case "pending":case "blocked":case "cyclic":return e=T,a.then(la(e,b,c,"cyclic"===a.status),ma(e)),null;default:throw a.reason;}}}return e}function pa(){throw Error('Trying to call a function from "use server" but the callServer option was not implemented in your router runtime.');}
6237function Y(a,b,c,e){var l=new Map;a={_bundlerConfig:a,_moduleLoading:b,_callServer:void 0!==c?c:pa,_nonce:e,_chunks:l,_stringDecoder:new TextDecoder,_fromJSON:null,_rowState:0,_rowID:0,_rowTag:0,_rowLength:0,_buffer:[]};a._fromJSON=qa(a);return a}
6238function ra(a,b,c){var e=a._chunks,l=e.get(b);c=JSON.parse(c,a._fromJSON);var k=v(a._bundlerConfig,c);if(c=z(k)){if(l){var n=l;n.status="blocked"}else n=new L("blocked",null,null,a),e.set(b,n);c.then(function(){return R(n,k)},function(g){return Q(n,g)})}else l?R(l,k):e.set(b,new L("resolved_module",k,null,a))}
6239function qa(a){return function(b,c){return"string"===typeof c?oa(a,this,b,c):"object"===typeof c&&null!==c?(b=c[0]===C?{$$typeof:C,type:c[1],key:c[2],ref:null,props:c[3],_owner:null}:c,b):c}}
6240function Z(a,b){function c(k){var n=k.value;if(k.done)V(a,Error("Connection closed."));else{var g=0,m=a._rowState,d=a._rowID,h=a._rowTag,f=a._rowLength;k=a._buffer;for(var D=n.length;g<D;){var p=-1;switch(m){case 0:p=n[g++];58===p?m=1:d=d<<4|(96<p?p-87:p-48);continue;case 1:m=n[g];84===m?(h=m,m=2,g++):64<m&&91>m?(h=m,m=3,g++):(h=0,m=3);continue;case 2:p=n[g++];44===p?m=4:f=f<<4|(96<p?p-87:p-48);continue;case 3:p=n.indexOf(10,g);break;case 4:p=g+f,p>n.length&&(p=-1)}var q=n.byteOffset+g;if(-1<p){g=
6241new Uint8Array(n.buffer,q,p-g);f=a;q=h;var S=f._stringDecoder;h="";for(var H=0;H<k.length;H++)h+=S.decode(k[H],u);h+=S.decode(g);switch(q){case 73:ra(f,d,h);break;case 72:d=h[0];h=h.slice(1);f=JSON.parse(h,f._fromJSON);if(h=aa.current)switch(d){case "D":h.prefetchDNS(f);break;case "C":"string"===typeof f?h.preconnect(f):h.preconnect(f[0],f[1]);break;case "L":d=f[0];g=f[1];3===f.length?h.preload(d,g,f[2]):h.preload(d,g);break;case "m":"string"===typeof f?h.preloadModule(f):h.preloadModule(f[0],f[1]);
6242break;case "S":"string"===typeof f?h.preinitStyle(f):h.preinitStyle(f[0],0===f[1]?void 0:f[1],3===f.length?f[2]:void 0);break;case "X":"string"===typeof f?h.preinitScript(f):h.preinitScript(f[0],f[1]);break;case "M":"string"===typeof f?h.preinitModuleScript(f):h.preinitModuleScript(f[0],f[1])}break;case 69:h=JSON.parse(h);g=h.digest;h=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
6243h.stack="Error: "+h.message;h.digest=g;g=f._chunks;(q=g.get(d))?Q(q,h):g.set(d,new L("rejected",null,h,f));break;case 84:f._chunks.set(d,new L("fulfilled",h,null,f));break;default:g=f._chunks,(q=g.get(d))?(f=q,d=h,"pending"===f.status&&(h=f.value,g=f.reason,f.status="resolved_model",f.value=d,null!==h&&(M(f),P(f,h,g)))):g.set(d,new L("resolved_model",h,null,f))}g=p;3===m&&g++;f=d=h=m=0;k.length=0}else{n=new Uint8Array(n.buffer,q,n.byteLength-g);k.push(n);f-=n.byteLength;break}}a._rowState=m;a._rowID=
6244d;a._rowTag=h;a._rowLength=f;return l.read().then(c).catch(e)}}function e(k){V(a,k)}var l=b.getReader();l.read().then(c).catch(e)}exports.createFromFetch=function(a,b){var c=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);a.then(function(e){Z(c,e.body)},function(e){V(c,e)});return W(c,0)};exports.createFromReadableStream=function(a,b){b=Y(null,null,b&&b.callServer?b.callServer:void 0,void 0);Z(b,a);return W(b,0)};
6245exports.createServerReference=function(a,b){function c(){var e=Array.prototype.slice.call(arguments);return b(a,e)}J(c,{id:a,bound:null});return c};exports.encodeReply=function(a){return new Promise(function(b,c){ja(a,"",b,c)})};
6246
6247//# sourceMappingURL=react-server-dom-webpack-client.browser.production.min.js.map
6248
6249
6250/***/ }),
6251
6252/***/ 3413:
6253/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6254
6255"use strict";
6256
6257
6258if (true) {
6259  module.exports = __webpack_require__(2453);
6260} else {}
6261
6262
6263/***/ }),
6264
6265/***/ 5552:
6266/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6267
6268"use strict";
6269
6270
6271module.exports = __webpack_require__(3413);
6272
6273
6274/***/ }),
6275
6276/***/ 5627:
6277/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6278
6279"use strict";
6280/*
6281 React
6282 react-jsx-runtime.production.min.js
6283
6284 Copyright (c) Meta Platforms, Inc. and affiliates.
6285
6286 This source code is licensed under the MIT license found in the
6287 LICENSE file in the root directory of this source tree.
6288*/
6289var f=__webpack_require__(9988),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INT

vendor: 4,822 bytes, lines 6289-6320

6289ERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
6290function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
6291
6292//# sourceMappingURL=react-jsx-runtime.production.min.js.map
6293
6294
6295/***/ }),
6296
6297/***/ 6271:
6298/***/ (function(__unused_webpack_module, exports) {
6299
6300"use strict";
6301/*
6302 React
6303 react.production.min.js
6304
6305 Copyright (c) Meta Platforms, Inc. and affiliates.
6306
6307 This source code is licensed under the MIT license found in the
6308 LICENSE file in the root directory of this source tree.
6309*/
6310var l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),w=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),z=Symbol.iterator;function A(a){if(null===a||"object"!==typeof a)return null;a=z&&a[z]||a["@@iterator"];return"function"===typeof a?a:null}
6311var B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,c){this.props=a;this.context=b;this.refs=D;this.updater=c||B}E.prototype.isReactComponent={};
6312E.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};function F(){}F.prototype=E.prototype;function G(a,b,c){this.props=a;this.context=b;this.refs=D;this.updater=c||B}var H=G.prototype=new F;
6313H.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};
6314function M(a,b,c){var f,d={},e=null,g=null;if(null!=b)for(f in void 0!==b.ref&&(g=b.ref),void 0!==b.key&&(e=""+b.key),b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=b[f]);var h=arguments.length-2;if(1===h)d.children=c;else if(1<h){for(var k=Array(h),m=0;m<h;m++)k[m]=arguments[m+2];d.children=k}if(a&&a.defaultProps)for(f in h=a.defaultProps,h)void 0===d[f]&&(d[f]=h[f]);return{$$typeof:l,type:a,key:e,ref:g,props:d,_owner:K.current}}
6315function N(a,b){return{$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return"object"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={"=":"=0",":":"=2"};return"$"+a.replace(/[=:]/g,function(c){return b[c]})}var P=/\/+/g;function Q(a,b){return"object"===typeof a&&null!==a&&null!=a.key?escape(""+a.key):b.toString(36)}
6316function R(a,b,c,f,d){var e=typeof a;if("undefined"===e||"boolean"===e)a=null;var g=!1;if(null===a)g=!0;else switch(e){case "string":case "number":g=!0;break;case "object":switch(a.$$typeof){case l:case n:g=!0}}if(g)return g=a,d=d(g),a=""===f?"."+Q(g,0):f,I(d)?(c="",null!=a&&(c=a.replace(P,"$&/")+"/"),R(d,b,c,"",function(m){return m})):null!=d&&(O(d)&&(d=N(d,c+(!d.key||g&&g.key===d.key?"":(""+d.key).replace(P,"$&/")+"/")+a)),b.push(d)),1;g=0;f=""===f?".":f+":";if(I(a))for(var h=0;h<a.length;h++){e=
6317a[h];var k=f+Q(e,h);g+=R(e,b,c,k,d)}else if(k=A(a),"function"===typeof k)for(a=k.call(a),h=0;!(e=a.next()).done;)e=e.value,k=f+Q(e,h++),g+=R(e,b,c,k,d);else if("object"===e)throw b=String(a),Error("Objects are not valid as a React child (found: "+("[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b)+"). If you meant to render a collection of children, use an array instead.");return g}
6318function S(a,b,c){if(null==a)return a;var f=[],d=0;R(a,f,"","",function(e){return b.call(c,e,d++)});return f}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(c){if(0===a._status||-1===a._status)a._status=1,a._result=c},function(c){if(0===a._status||-1===a._status)a._status=2,a._result=c});-1===a._status&&(a._status=0,a._result=b)}if(1===a._status)return a._result.default;throw a._result;}var U={current:null};function V(){return new WeakMap}
6319function W(){return{s:0,v:void 0,o:null,p:null}}var X={current:null},Y={transition:null},Z={ReactCurrentDispatcher:X,ReactCurrentCache:U,ReactCurrentBatchConfig:Y,ReactCurrentOwner:K};
6320exports.Children={map:S,forEach:function(a,b,c){S(a,function(){b.apply(this,arguments)},c)},count:function(a){var b=0;S(a,function(){b++});return b},toArray:function(a){return S(a,function(b){return b})||[]}

6320,only:function(a){if(!O(a))throw Error("React.Children.only expected to receive a single React element child.");return a}};exports.Component=E;exports.Fragment=p;exports.Profiler=r;exports.PureComponent=G;exports.StrictMode=q;exports.Suspense=w;
6321exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=Z;
6322exports.cache=function(a){return function(){var b=U.current;if(!b)return a.apply(null,arguments);var c=b.getCacheForType(V);b=c.get(a);void 0===b&&(b=W(),c.set(a,b));c=0;for(var f=arguments.length;c<f;c++){var d=arguments[c];if("function"===typeof d||"object"===typeof d&&null!==d){var e=b.o;null===e&&(b.o=e=new WeakMap);b=e.get(d);void 0===b&&(b=W(),e.set(d,b))}else e=b.p,null===e&&(b.p=e=new Map),b=e.get(d),void 0===b&&(b=W(),e.set(d,b))}if(1===b.s)return b.v;if(2===b.s)throw b.v;try{var g=a.apply(null,
6323arguments);c=b;c.s=1;return c.v=g}catch(h){throw g=b,g.s=2,g.v=h,h;}}};
6324exports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+a+".");var f=C({},a.props),d=a.key,e=a.ref,g=a._owner;if(null!=b){void 0!==b.ref&&(e=b.ref,g=K.current);void 0!==b.key&&(d=""+b.key);if(a.type&&a.type.defaultProps)var h=a.type.defaultProps;for(k in b)J.call(b,k)&&!L.hasOwnProperty(k)&&(f[k]=void 0===b[k]&&void 0!==h?h[k]:b[k])}var k=arguments.length-2;if(1===k)f.children=c;else if(1<k){h=Array(k);
6325for(var m=0;m<k;m++)h[m]=arguments[m+2];f.children=h}return{$$typeof:l,type:a.type,key:d,ref:e,props:f,_owner:g}};

6325exports.createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};
6326exports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=Y.transition;Y.transition={};try{a()}finally{Y.transition=b}};exports.unstable_act=function(){throw Error("act(...) is not supported in production builds of React.");};exports.unstable_useCacheRefresh=function(){return X.current.useCacheRefresh()};
6327exports.use=function(a){return X.current.use(a)};exports.useCallback=function(a,b){return X.current.useCallback(a,b)};exports.useContext=function(a){return X.current.useContext(a)};exports.useDebugValue=function(){};exports.useDeferredValue=function(a,b){return X.current.useDeferredValue(a,b)};exports.useEffect=function(a,b){return X.current.useEffect(a,b)};exports.useId=function(){return X.current.useId()};exports.useImperativeHandle=function(a,b,c){return X.current.useImperativeHandle(a,b,c)};
6328exports.useInsertionEffect=function(a,b){return X.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return X.current.useLayoutEffect(a,b)};exports.useMemo=function(a,b){return X.current.useMemo(a,b)};exports.useOptimistic=function(a,b){return X.current.useOptimistic(a,b)};exports.useReducer=function(a,b,c){return X.current.useReducer(a,b,c)};exports.useRef=function(a){return X.current.useRef(a)};exports.useState=function(a){return X.current.useState(a)};
6329exports.useSyncExternalStore=function(a,b,c){return X.current.useSyncExternalStore(a,b,c)};exports.useTransition=function(){return X.current.useTransition()};exports.version="18.3.0-canary-0cdfef19b-20231211";
6330
6331//# sourceMappingURL=react.production.min.js.map
6332
6333
6334/***/ }),
6335
6336/***/ 9988:
6337/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6338
6339"use strict";
6340
6341
6342if (true) {
6343  module.exports = __webpack_require__(6271);
6344} else {}
6345
6346
6347/***/ }),
6348
6349/***/ 1411:
6350/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6351
6352"use strict";
6353
6354
6355if (true) {
6356  module.exports = __webpack_require__(5627);
6357} else {}
6358
6359
6360/***/ }),
6361
6362/***/ 5560:
6363/***/ (function(__unused_webpack_module, exports) {
6364
6365"use strict";
6366/*
6367 React
6368 scheduler.production.min.js
6369
6370 Copyright (c) Meta Platforms, Inc. and affiliates.
6371
6372 This source code is licensed under the MIT license found in the
6373 LICENSE file in the root directory of this source tree.
6374*/
6375function f(a,c){var b=a.length;a.push(c);a:for(;0<b;){var d=b-1>>>1,e=a[d];if(0<g(e,c))a[d]=c,a[b]=e,b=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var c=a[0],b=a.pop();if(b!==c){a[0]=b;a:for(var d=0,e=a.length,v=e>>>1;d<v;){var w=2*(d+1)-1,C=a[w],m=w+1,x=a[m];if(0>g(C,b))m<e&&0>g(x,C)?(a[d]=x,a[m]=b,d=m):(a[d]=C,a[w]=b,d=w);else if(m<e&&0>g(x,b))a[d]=x,a[m]=b,d=m;else break a}}return c}
6376function g(a,c){var b=a.sortIndex-c.sortIndex;return 0!==b?b:a.id-c.id}exports.unstable_now=void 0;if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var n=Date,p=n.now();exports.unstable_now=function(){return n.now()-p}}
6377var q=[],r=[],t=1,u=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending?navigator.scheduling.isInputPending.bind(navigator.scheduling):null;
6378function G(a){for(var c=h(r);null!==c;){if(null===c.callback)k(r);else if(c.startTime<=a)k(r),c.sortIndex=c.expirationTime,f(q,c);else break;c=h(r)}}function H(a){B=!1;G(a);if(!A)if(null!==h(q))A=!0,I();else{var c=h(r);null!==c&&J(H,c.startTime-a)}}var K=!1,L=-1,M=5,N=-1;function O(){return exports.unstable_now()-N<M?!1:!0}
6379function P(){if(K){var a=exports.unstable_now();N=a;var c=!0;try{a:{A=!1;B&&(B=!1,E(L),L=-1);z=!0;var b=y;try{b:{G(a);for(u=h(q);null!==u&&!(u.expirationTime>a&&O());){var d=u.callback;if("function"===typeof d){u.callback=null;y=u.priorityLevel;var e=d(u.expirationTime<=a);a=exports.unstable_now();if("function"===typeof e){u.callback=e;G(a);c=!0;break b}u===h(q)&&k(q);G(a)}else k(q);u=h(q)}if(null!==u)c=!0;else{var v=h(r);null!==v&&J(H,v.startTime-a);c=!1}}break a}finally{u=null,y=b,z=!1}c=void 0}}finally{c?
6380Q():K=!1}}}var Q;if("function"===typeof F)Q=function(){F(P)};else if("undefined"!==typeof MessageChannel){var R=new MessageChannel,S=R.port2;R.port1.onmessage=P;Q=function(){S.postMessage(null)}}else Q=function(){D(P,0)};function I(){K||(K=!0,Q())}function J(a,c){L=D(function(){a(exports.unstable_now())},c)}exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;
6381exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I())};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):M=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(q)};
6382exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var c=3;break;default:c=y}var b=y;y=c;try{return a()}finally{y=b}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,c){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var b=y;y=a;try{return c()}finally{y=b}};
6383exports.unstable_scheduleCallback=function(a,c,b){var d=exports.unstable_now();"object"===typeof b&&null!==b?(b=b.delay,b="number"===typeof b&&0<b?d+b:d):b=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=b+e;a={id:t++,callback:c,priorityLevel:a,startTime:b,expirationTime:e,sortIndex:-1};b>d?(a.sortIndex=b,f(r,a),null===h(q)&&a===h(r)&&(B?(E(L),L=-1):B=!0,J(H,b-d))):(a.sortIndex=e,f(q,a),A||z||(A=!0,I()));return a};
6384exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var c=y;return function(){var b=y;y=c;try{return a.apply(this,arguments)}finally{y=b}}};
6385
6386//# sourceMappingURL=scheduler.production.min.js.map
6387
6388
6389/***/ }),
6390
6391/***/ 1519:
6392/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6393
6394"use strict";
6395
6396
6397if (true) {
6398  module.exports = __webpack_require__(5560);
6399} else {}
6400
6401
6402/***/ }),
6403
6404/***/ 4758:
6405/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6406
6407"use strict";
6408
6409Object.defineProperty(exports, "__esModule", ({
6410    value: true
6411}));
6412Object.defineProperty(exports, "getSegmentParam", ({
6413    enumerable: true,
6414    get: function() {
6415        return getSegmentParam;
6416    }
6417}));
6418const _interceptionroutes = __webpack_require__(5859);
6419function getSegmentParam(segment) {
6420    const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker)=>segment.startsWith(marker));
6421    // if an interception marker is part of the path segment, we need to jump ahead
6422    // to the relevant portion for param parsing
6423    if (interceptionMarker) {
6424        segment = segment.slice(interceptionMarker.length);
6425    }
6426    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
6427        return {
6428            type: "optional-catchall",
6429            param: segment.slice(5, -2)
6430        };
6431    }
6432    if (segment.startsWith("[...") && segment.endsWith("]")) {
6433        return {
6434            type: "catchall",
6435            param: segment.slice(4, -1)
6436        };
6437    }
6438    if (segment.startsWith("[") && segment.endsWith("]")) {
6439        return {
6440            type: "dynamic",
6441            param: segment.slice(1, -1)
6442        };
6443    }
6444    return null;
6445}
6446
6447//# sourceMappingURL=get-segment-param.js.map
6448
6449/***/ }),
6450
6451/***/ 5859:
6452/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
6453
6454"use strict";
6455
6456Object.defineProperty(exports, "__esModule", ({
6457    value: true
6458}));
64590 && (0);
6460function _export(target, all) {
6461    for(var name in all)Object.defineProperty(target, name, {
6462        enumerable: true,
6463        get: all[name]
6464    });
6465}
6466_export(exports, {
6467    INTERCEPTION_ROUTE_MARKERS: function() {
6468        return INTERCEPTION_ROUTE_MARKERS;
6469    },
6470    isInterceptionRouteAppPath: function() {
6471        return isInterceptionRouteAppPath;
6472    },
6473    extractInterceptionRouteInformation: function() {
6474        return extractInterceptionRouteInformation;
6475    }
6476});
6477const _apppaths = __webpack_require__(8640);
6478const INTERCEPTION_ROUTE_MARKERS = [
6479    "(..)(..)",
6480    "(.)",
6481    "(..)",
6482    "(...)"
6483];
6484function isInterceptionRouteAppPath(path) {
6485    // TODO-APP: add more serious validation
6486    return path.split("/").find((segment)=>INTERCEPTION_ROUTE_MARKERS.find((m)=>

6486segment.startsWith(m))) !== undefined;
6487}
6488function extractInterceptionRouteInformation(path) {
6489    let interceptingRoute, marker, interceptedRoute;
6490    for (const segment of path.split("/")){
6491        marker = INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
6492        if (marker) {
6493            [interceptingRoute, interceptedRoute] = path.split(marker, 2);
6494            break;
6495        }
6496    }
6497    if (!interceptingRoute || !marker || !interceptedRoute) {
6498        throw new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`);
6499    }
6500    interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute) // normalize the path, e.g. /(blog)/feed -> /feed
6501    ;
6502    switch(marker){
6503        case "(.)":
6504            // (.) indicates that we should match with sibling routes, so we just need to append the intercepted route to the intercepting route
6505            if (interceptingRoute === "/") {
6506                interceptedRoute = `/${interceptedRoute}`;
6507            } else {
6508                interceptedRoute = interceptingRoute + "/" + interceptedRoute;
6509            }
6510            break;
6511        case "(..)":
6512            // (..) indicates that we should match at one level up, so we need to remove the last segment of the intercepting route
6513            if (interceptingRoute === "/") {
6514                throw new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`);
6515            }
6516            interceptedRoute = interceptingRoute.split("/").slice(0, -1).concat(interceptedRoute).join("/");
6517            break;
6518        case "(...)":
6519            // (...) will match the route segment in the root directory, so we need to use the root directory to prepend the intercepted route
6520            interceptedRoute = "/" + interceptedRoute;
6521            break;
6522        case "(..)(..)":
6523            // (..)(..) indicates that we should match at two levels up, so we need to remove the last two segments of the intercepting route
6524            const splitInterceptingRoute = interceptingRoute.split("/");
6525            if (splitInterceptingRoute.length <= 2) {
6526                throw new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`);
6527            }
6528            interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
6529            break;
6530        default:
6531            throw new Error("Invariant: unexpected marker");
6532    }
6533    return {
6534        interceptingRoute,
6535        interceptedRoute
6536    };
6537}
6538
6539//# sourceMappingURL=interception-routes.js.map
6540
6541/***/ }),
6542
6543/***/ 9382:
6544/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
6545
6546"use strict";
6547__webpack_require__.r(__webpack_exports__);
6548/* harmony export */ __webpack_require__.d(__webpack_exports__, {
6549/* harmony export */   _: function() { return /* binding */ _class_private_field_loose_base; },
6550/* harmony export */   _class_private_field_loose_base: function() { return /* binding */ _class_private_field_loose_base; }
6551/* harmony export */ });
6552function _class_private_field_loose_base(receiver, privateKey) {
6553    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
6554        throw new TypeError("attempted to use private field on non-instance");
6555    }
6556
6557    return receiver;
6558}
6559
6560
6561
6562/***/ }),
6563
6564/***/ 7666:
6565/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
6566
6567"use strict";
6568__webpack_require__.r(__webpack_exports__);
6569/* harmony export */ __webpack_require__.d(__webpack_exports__, {
6570/* harmony export */   _: function() { return /* binding */ _class_private_field_loose_key; },
6571/* harmony export */   _class_private_field_loose_key: function() { return /* binding */ _class_private_field_loose_key; }
6572/* harmony export */ });
6573var id = 0;
6574
6575function _class_private_field_loose_key(name) {
6576    return "__private_" + id++ + "_" + name;
6577}
6578
6579
6580
6581/***/ }),
6582
6583/***/ 7295:
6584/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
6585
6586"use strict";
6587__webpack_require__.r(__webpack_exports__);
6588/* harmony export */ __webpack_require__.d(__webpack_exports__, {
6589/* harmony export */   _: function() { return /* binding */ _interop_require_default; },
6590/* harmony export */   _interop_require_default: function() { return /* binding */ _interop_require_default; }
6591/* harmony export */ });
6592function _interop_require_default(obj) {
6593    return obj && obj.__esModule ? obj : { default: obj };
6594}
6595
6596
6597
6598/***/ }),
6599
6600/***/ 3589:
6601/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
6602
6603"use strict";
6604__webpack_require__.r(__webpack_exports__);
6605/* harmony export */ __webpack_require__.d(__webpack_exports__, {
6606/* harmony export */   _: function() { return /* binding */ _interop_require_wildcard; },
6607/* harmony export */   _interop_require_wildcard: function() { return /* binding */ _interop_require_wildcard; }
6608/* harmony export */ });
6609function _getRequireWildcardCache(nodeInterop) {
6610    if (typeof WeakMap !== "function") return null;
6611
6612    var cacheBabelInterop = new WeakMap();
6613    var cacheNodeInterop = new WeakMap();
6614
6615    return (_getRequireWildcardCache = function(nodeInterop) {
6616        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
6617    })(nodeInterop);
6618}
6619function _interop_require_wildcard(obj, nodeInterop) {
6620    if (!nodeInterop && obj && obj.__esModule) return obj;
6621    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
6622
6623    var cache = _getRequireWildcardCache(nodeInterop);
6624
6625    if (cache && cache.has(obj)) return cache.get(obj);
6626
6627    var newObj = {};
6628    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
6629
6630    for (var key in obj) {
6631        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
6632            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
6633            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
6634            else newObj[key] = obj[key];
6635        }
6636    }
6637
6638    newObj.default = obj;
6639
6640    if (cache) cache.set(obj, newObj);
6641
6642    return newObj;
6643}
6644
6645
6646
6647/***/ })
6648
6649}]);

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.