https://scunthorpe-united.co.uk/_next/static/chunks/2ryz5-ycxv0cy.js

1(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
254394, ((__turbopack_context__, module, exports) => {
3"use strict";
4
5Object.defineProperty(exports, "__esModule", {
6    value: true
7});
80 && (module.exports = {
9    HTTPAccessErrorStatus: null,
10    HTTP_ERROR_FALLBACK_ERROR_CODE: null,
11    getAccessFallbackErrorTypeByStatus: null,
12    getAccessFallbackHTTPStatus: null,
13    isHTTPAccessFallbackError: null
14});
15function _export(target, all) {
16    for(var name in all)Object.defineProperty(target, name, {
17        enumerable: true,
18        get: all[name]
19    });
20}
21_export(exports, {
22    HTTPAccessErrorStatus: function() {
23        return HTTPAccessErrorStatus;
24    },
25    HTTP_ERROR_FALLBACK_ERROR_CODE: function() {
26        return HTTP_ERROR_FALLBACK_ERROR_CODE;
27    },
28    getAccessFallbackErrorTypeByStatus: function() {
29        return getAccessFallbackErrorTypeByStatus;
30    },
31    getAccessFallbackHTTPStatus: function() {
32        return getAccessFallbackHTTPStatus;
33    },
34    isHTTPAccessFallbackError: function() {
35        return isHTTPAccessFallbackError;
36    }
37});
38const HTTPAccessErrorStatus = {
39    NOT_FOUND: 404,
40    FORBIDDEN: 403,
41    UNAUTHORIZED: 401
42};
43const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
44const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK';
45function isHTTPAccessFallbackError(error) {
46    if (typeof error !== 'object' || error === null || !('digest' in error) || typeof error.digest !== 'string') {
47        return false;
48    }
49    const [prefix, httpStatus] = error.digest.split(';');
50    return prefix === HTTP_ERROR_FALLBACK_ERROR_CODE && ALLOWED_CODES.has(Number(httpStatus));
51}
52function getAccessFallbackHTTPStatus(error) {
53    const httpStatus = error.digest.split(';')[1];
54    return Number(httpStatus);
55}
56function getAccessFallbackErrorTypeByStatus(status) {
57    switch(status){
58        case 401:
59            return 'unauthorized';
60        case 403:
61            return 'forbidden';
62        case 404:
63            return 'not-found';
64        default:
65            return;
66    }
67}
68if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
69    Object.defineProperty(exports.default, '__esModule', {
70        value: true
71    });
72    Object.assign(exports.default, exports);
73    module.exports = exports.default;
74}
75}),
7665713, ((__turbopack_context__, module, exports) => {
77"use strict";
78
79Object.defineProperty(exports, "__esModule", {
80    value: true
81});
82Object.defineProperty(exports, "isNextRouterError", {
83    enumerable: true,
84    get: function() {
85        return isNextRouterError;
86    }
87});
88const _httpaccessfallback = __turbopack_context__.r(54394);
89const _redirecterror = __turbopack_context__.r(68391);
90function isNextRouterError(error) {
91    return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error);
92}
93if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
94    Object.defineProperty(exports.default, '__esModule', {
95        value: true
96    });
97    Object.assign(exports.default, exports);
98    module.exports = exports.default;
99}
100}),
1013680, ((__turbopack_context__, module, exports) => {
102"use strict";
103
104/**
105 * ReadonlyURLSearchParams implementation shared between client and server.
106 * This file is intentionally not marked as 'use client' or 'use server'
107 * so it can be imported by both environments.
108 */ /** @internal */ Object.defineProperty(exports, "__esModule", {
109    value: true
110});
111Object.defineProperty(exports, "ReadonlyURLSearchParams", {
112    enumerable: true,
113    get: function() {
114        return ReadonlyURLSearchParams;
115    }
116});
117class ReadonlyURLSearchParamsError extends Error {
118    constructor(){
119        super('Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams');
120    }
121}
122class ReadonlyURLSearchParams extends URLSearchParams {
123    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ append() {
124        throw new ReadonlyURLSearchParamsError();
125    }
126    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ delete() {
127        throw new ReadonlyURLSearchParamsError();
128    }
129    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ set() {
130        throw new ReadonlyURLSearchParamsError();
131    }
132    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ sort() {
133        throw new ReadonlyURLSearchParamsError();
134    }
135}
136if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
137    Object.defineProperty(exports.default, '__esModule', {
138        value: true
139    });

140    Object.assign(exports.default, exports);
141    module.exports = exports.default;
142}
143}),
14461994, ((__turbopack_context__, module, exports) => {
145"use strict";
146
147var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
148'use client';
149"use strict";
150Object.defineProperty(exports, "__esModule", {
151    value: true
152});
1530 && (module.exports = {
154    NavigationPromisesContext: null,
155    PathParamsContext: null,
156    PathnameContext: null,
157    ReadonlyURLSearchParams: null,
158    SearchParamsContext: null,
159    createDevToolsInstrumentedPromise: null
160});
161function _export(target, all) {
162    for(var name in all)Object.defineProperty(target, name, {
163        enumerable: true,
164        get: all[name]
165    });
166}
167_export(exports, {
168    NavigationPromisesContext: function() {
169        return NavigationPromisesContext;
170    },
171    PathParamsContext: function() {
172        return PathParamsContext;
173    },
174    PathnameContext: function() {
175        return PathnameContext;
176    },
177    ReadonlyURLSearchParams: function() {
178        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
179    },
180    SearchParamsContext: function() {
181        return SearchParamsContext;
182    },
183    createDevToolsInstrumentedPromise: function() {
184        return createDevToolsInstrumentedPromise;
185    }
186});
187const _react = __turbopack_context__.r(71645);
188const _readonlyurlsearchparams = __turbopack_context__.r(3680);
189const SearchParamsContext = (0, _react.createContext)(null);
190const PathnameContext = (0, _react.createContext)(null);
191const PathParamsContext = (0, _react.createContext)(null);
192const NavigationPromisesContext = (0, _react.createContext)(null);
193function createDevToolsInstrumentedPromise(displayName, value) {
194    const promise = Promise.resolve(value);
195    promise.status = 'fulfilled';
196    promise.value = value;
197    promise.displayName = `${displayName} (SSR)`;
198    return promise;
199}
200if ("TURBOPACK compile-time truthy", 1) {
201    SearchParamsContext.displayName = 'SearchParamsContext';
202    PathnameContext.displayName = 'PathnameContext';
203    PathParamsContext.displayName = 'PathParamsContext';
204    NavigationPromisesContext.displayName = 'NavigationPromisesContext';
205}
206}),
20745955, ((__turbopack_context__, module, exports) => {
208"use strict";
209
210Object.defineProperty(exports, "__esModule", {
211    value: true
212});
213Object.defineProperty(exports, "workUnitAsyncStorageInstance", {
214    enumerable: true,
215    get: function() {
216        return workUnitAsyncStorageInstance;
217    }
218});
219const _asynclocalstorage = __turbopack_context__.r(90317);
220const workUnitAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
221}),
22242852, ((__turbopack_context__, module, exports) => {
223"use strict";
224
225Object.defineProperty(exports, "__esModule", {
226    value: true
227});
2280 && (module.exports = {
229    RenderStage: null,
230    StagedRenderingController: null
231});
232function _export(target, all) {
233    for(var name in all)Object.defineProperty(target, name, {
234        enumerable: true,
235        get: all[name]
236    });
237}
238_export(exports, {
239    RenderStage: function() {
240        return RenderStage;
241    },
242    StagedRenderingController: function() {
243        return StagedRenderingController;
244    }
245});
246const _invarianterror = __turbopack_context__.r(12718);
247const _promisewithresolvers = __turbopack_context__.r(39470);
248var RenderStage = /*#__PURE__*/ function(RenderStage) {
249    RenderStage[RenderStage["Before"] = 1] = "Before";
250    RenderStage[RenderStage["EarlyStatic"] = 2] = "EarlyStatic";
251    RenderStage[RenderStage["Static"] = 3] = "Static";
252    RenderStage[RenderStage["EarlyRuntime"] = 4] = "EarlyRuntime";
253    RenderStage[RenderStage["Runtime"] = 5] = "Runtime";
254    RenderStage[RenderStage["Dynamic"] = 6] = "Dynamic";
255    RenderStage[RenderStage["Abandoned"] = 7] = "Abandoned";
256    return RenderStage;
257}({});
258class StagedRenderingController {
259    constructor(abortSignal, abandonController, shouldTrackSyncIO){
260        this.abortSignal = abortSignal;
261        this.abandonController = abandonController;
262        this.shouldTrackSyncIO = shouldTrackSyncIO;
263        this.currentStage = 1;
264        this.syncInterruptReason = null;
265        this.staticStageEndTime = Infinity;
266        this.runtimeStageEndTime = Infinity;
267        this.staticStageListeners = [];
268        this.earlyRuntimeStageListeners = [];
269        this.runtimeStageListeners = [];
270        this.dynamicStageListeners = [];
271        this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
272        this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
273        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
274        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
275        if (abortSignal) {
276            abortSignal.addEventListener('abort', ()=>{
277                // Reject all stage promises that haven't already been resolved.
278                // If a promise was already resolved via advanceStage, the reject
279                // is a no-op. The ignoreReject handler suppresses unhandled
280                // rejection warnings for promises that no one is awaiting.
281                const { reason } = abortSignal;
282                this.staticStagePromise.promise.catch(ignoreReject);
283                this.staticStagePromise.reject(reason);
284                this.earlyRuntimeStagePromise.promise.catch(ignoreReject);
285                this.earlyRuntimeStagePromise.reject(reason);
286                this.runtimeStagePromise.promise.catch(ignoreReject);
287                this.runtimeStagePromise.reject(reason);
288                this.dynamicStagePromise.promise.catch(ignoreReject);
289                this.dynamicStagePromise.reject(reason);
290            }, {
291                once: true
292            });
293        }
294        if (abandonController) {
295            abandonController.signal.addEventListener('abort', ()=>{
296                this.abandonRender();
297            }, {
298                once: true
299            });
300        }
301    }
302    onStage(stage, callback) {
303        if (this.currentStage >= stage) {
304            callback();
305        } else if (stage === 3) {
306            this.staticStageListeners.push(callback);
307        } else if (stage === 4) {
308            this.earlyRuntimeStageListeners.push(callback);
309        } else if (stage === 5) {
310            this.runtimeStageListeners.push(callback);
311        } else if (stage === 6) {
312            this.dynamicStageListeners.push(callback);
313        } else {
314            // This should never happen
315            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
316                value: "E881",
317                enumerable: false,
318                configurable: true
319            });
320        }
321    }
322    shouldTrackSyncInterrupt() {
323        if (!this.shouldTrackSyncIO) {
324            return false;

325        }
326        switch(this.currentStage){
327            case 1:
328                // If we haven't started the render yet, it can't be interrupted.
329                return false;
330            case 2:
331            case 3:
332                return true;
333            case 4:
334                // EarlyRuntime is for runtime-prefetchable segments. Sync IO
335                // should error because it would abort a runtime prefetch.
336                return true;
337            case 5:
338                // Runtime is for non-prefetchable segments. Sync IO is fine there
339                // because in practice this segment will never be runtime prefetched
340                return false;
341            case 6:
342            case 7:
343                return false;
344            default:
345                return false;
346        }
347    }
348    syncInterruptCurrentStageWithReason(reason) {
349        if (this.currentStage === 1) {
350            return;
351        }
352        // If the render has already been abandoned, there's nothing to interrupt.
353        if (this.currentStage === 7) {
354            return;
355        }
356        // If Sync IO occurs during an abandonable render, we trigger the abandon.
357        // The abandon listener will call abandonRender which advances through
358        // stages to let caches fill before marking as Abandoned.
359        if (this.abandonController) {
360            this.abandonController.abort();
361            return;
362        }
363        if (this.abortSignal) {
364            // If this is an abortable render, we capture the interruption reason and stop advancing.
365            // We don't release any more promises.
366            // The caller is expected to abort the signal.
367            this.syncInterruptReason = reason;
368            this.currentStage = 7;
369            return;
370        }
371        // If we're in a non-abandonable & non-abortable render,
372        // we need to advance to the Dynamic stage and capture the interruption reason.
373        // (in dev, this will be the restarted render)
374        switch(this.currentStage){
375            case 2:
376            case 3:
377            case 4:
378                {
379                    // EarlyRuntime is for runtime-prefetchable segments. Sync IO here
380                    // means the prefetch would be aborted too early.
381                    this.syncInterruptReason = reason;
382                    this.advanceStage(6);
383                    return;
384                }
385            case 5:
386                {
387                    // canSyncInterrupt returns false for Runtime, so we should
388                    // never get here. Defensive no-op.
389                    return;
390                }
391            case 6:
392            default:
393        }
394    }
395    getSyncInterruptReason() {
396        return this.syncInterruptReason;
397    }
398    getStaticStageEndTime() {
399        return this.staticStageEndTime;
400    }
401    getRuntimeStageEndTime() {
402        return this.runtimeStageEndTime;
403    }
404    abandonRender() {
405        // In staged rendering, only the initial render is abandonable.
406        // We can abandon the initial render if
407        //   1. We notice a cache miss, and need to wait for caches to fill
408        //   2. A sync IO error occurs, and the render should be interrupted
409        //      (this might be a lazy intitialization of a module,
410        //       so we still want to restart in this case and see if it still occurs)
411        // In either case, we'll be doing another render after this one,
412        // so we only want to unblock the next stage, not Dynamic, because
413        // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
414        const { currentStage } = this;
415        switch(currentStage){
416            case 2:
417                {
418                    this.resolveStaticStage();
419                }
420            // intentional fallthrough
421            case 3:
422                {
423                    this.resolveEarlyRuntimeStage();
424                }
425            // intentional fallthrough
426            case 4:
427                {
428                    this.resolveRuntimeStage();
429                }
430            // intentional fallthrough
431            case 5:
432                {
433                    this.currentStage = 7;
434                    return;
435                }
436            case 6:
437            case 1:
438            case 7:
439                break;
440            default:
441                {
442                    currentStage;
443                }
444        }
445    }
446    advanceStage(stage) {
447        // If we're already at the target stage or beyond, do nothing.
448        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
449        if (stage <= this.currentStage) {
450            return;
451        }
452        let currentStage = this.currentStage;
453        this.currentStage = stage;
454        if (currentStage < 3 && stage >= 3) {
455            this.resolveStaticStage();
456        }
457        if (currentStage < 4 && stage >= 4) {
458            this.resolveEarlyRuntimeStage();
459        }
460        if (currentStage < 5 && stage >= 5) {
461            this.staticStageEndTime = performance.now() + performance.timeOrigin;
462            this.resolveRuntimeStage();
463        }
464        if (currentStage < 6 && stage >= 6) {
465            this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
466            this.resolveDynamicStage();
467            return;
468        }
469    }
470    /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */ resolveStaticStage() {
471        const staticListeners = this.staticStageListeners;
472        for(let i = 0; i < staticListeners.length; i++){
473            staticListeners[i]();
474        }
475        staticListeners.length = 0;
476        this.staticStagePromise.resolve();
477    }
478    /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */ resolveEarlyRuntimeStage() {
479        const earlyRuntimeListeners = this.earlyRuntimeStageListeners;
480        for(let i = 0; i < earlyRuntimeListeners.length; i++){
481            earlyRuntimeListeners[i]();
482        }
483        earlyRuntimeListeners.length = 0;
484        this.earlyRuntimeStagePromise.resolve();
485    }
486    /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
487        const runtimeListeners = this.runtimeStageListeners;
488        for(let i = 0; i < runtimeListeners.length; i++){
489            runtimeListeners[i]();
490        }
491        runtimeListeners.length = 0;
492        this.runtimeStagePromise.resolve();
493    }
494    /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
495        const dynamicListeners = this.dynamicStageListeners;
496        for(let i = 0; i < dynamicListeners.length; i++){
497            dynamicListeners[i]();
498        }
499        dynamicListeners.length = 0;
500        this.dynamicStagePromise.resolve();
501    }
502    getStagePromise(stage) {
503        switch(stage){
504            case 3:
505                {
506                    return this.staticStagePromise.promise;
507                }
508            case 4:
509                {
510                    return this.earlyRuntimeStagePromise.promise;
511                }
512            case 5:
513                {
514                    return this.runtimeStagePromise.promise;
515                }
516            case 6:
517                {
518                    return this.dynamicStagePromise.promise;
519                }
520            default:
521                {
522                    stage;
523                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
524                        value: "E881",
525                        enumerable: false,
526                        configurable: true
527                    });
528                }
529        }
530    }
531    waitForStage(stage) {

532        return this.getStagePromise(stage);
533    }
534    delayUntilStage(stage, displayName, resolvedValue) {
535        const ioTriggerPromise = this.getStagePromise(stage);
536        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
537        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
538        // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
539        // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
540        if (this.abortSignal) {
541            promise.catch(ignoreReject);
542        }
543        return promise;
544    }
545}
546function ignoreReject() {}
547// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
548// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
549// is confusing, we should clean it up.
550function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
551    // If we create a `new Promise` and give it a displayName
552    // (with no userspace code above us in the stack)
553    // React Devtools will use it as the IO cause when determining "suspended by".
554    // In particular, it should shadow any inner IO that resolved/rejected the promise
555    // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
556    const promise = new Promise((resolve, reject)=>{
557        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
558    });
559    if (displayName !== undefined) {
560        // @ts-expect-error
561        promise.displayName = displayName;
562    }
563    return promise;
564}
565}),
56662141, ((__turbopack_context__, module, exports) => {
567"use strict";
568
569var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
570"use strict";
571Object.defineProperty(exports, "__esModule", {
572    value: true
573});
5740 && (module.exports = {
575    getCacheSignal: null,
576    getDraftModeProviderForCacheScope: null,
577    getHmrRefreshHash: null,
578    getPrerenderResumeDataCache: null,
579    getRenderResumeDataCache: null,
580    getServerComponentsHmrCache: null,
581    getStagedRenderingController: null,
582    isHmrRefresh: null,
583    isInEarlyRenderStage: null,
584    throwForMissingRequestStore: null,
585    throwInvariantForMissingStore: null,
586    workUnitAsyncStorage: null
587});
588function _export(target, all) {
589    for(var name in all)Object.defineProperty(target, name, {
590        enumerable: true,
591        get: all[name]
592    });
593}
594_export(exports, {
595    getCacheSignal: function() {
596        return getCacheSignal;
597    },
598    getDraftModeProviderForCacheScope: function() {
599        return getDraftModeProviderForCacheScope;
600    },
601    getHmrRefreshHash: function() {
602        return getHmrRefreshHash;
603    },
604    getPrerenderResumeDataCache: function() {
605        return getPrerenderResumeDataCache;
606    },
607    getRenderResumeDataCache: function() {
608        return getRenderResumeDataCache;
609    },
610    getServerComponentsHmrCache: function() {
611        return getServerComponentsHmrCache;
612    },
613    getStagedRenderingController: function() {
614        return getStagedRenderingController;
615    },
616    isHmrRefresh: function() {
617        return isHmrRefresh;
618    },
619    isInEarlyRenderStage: function() {
620        return isInEarlyRenderStage;
621    },
622    throwForMissingRequestStore: function() {
623        return throwForMissingRequestStore;
624    },
625    throwInvariantForMissingStore: function() {
626        return throwInvariantForMissingStore;
627    },
628    workUnitAsyncStorage: function() {
629        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
630    }
631});
632const _workunitasyncstorageinstance = __turbopack_context__.r(45955);
633const _approuterheaders = __turbopack_context__.r(21768);
634const _invarianterror = __turbopack_context__.r(12718);
635const _stagedrendering = __turbopack_context__.r(42852);
636function isInEarlyRenderStage(requestStore) {
637    const stagedRendering = requestStore.stagedRendering;
638    if (stagedRendering) {
639        return stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime;
640    }
641    return false;

642}
643function throwForMissingRequestStore(callingExpression) {
644    throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
645        value: "E251",
646        enumerable: false,
647        configurable: true
648    });
649}
650function throwInvariantForMissingStore() {
651    throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
652        value: "E696",
653        enumerable: false,
654        configurable: true
655    });
656}
657function getPrerenderResumeDataCache(workUnitStore) {
658    switch(workUnitStore.type){
659        case 'prerender':
660        case 'prerender-runtime':
661        case 'prerender-ppr':
662            return workUnitStore.prerenderResumeDataCache;
663        case 'prerender-client':
664        case 'validation-client':
665            // TODO eliminate fetch caching in client scope and stop exposing this data
666            // cache during SSR.
667            return workUnitStore.prerenderResumeDataCache;
668        case 'request':
669            {
670                // In dev, we might fill caches even during a dynamic request.
671                if (workUnitStore.prerenderResumeDataCache) {
672                    return workUnitStore.prerenderResumeDataCache;
673                }
674            // fallthrough
675            }
676        case 'prerender-legacy':
677        case 'cache':
678        case 'private-cache':
679        case 'unstable-cache':
680        case 'generate-static-params':
681            return null;
682        default:
683            return workUnitStore;
684    }
685}
686function getRenderResumeDataCache(workUnitStore) {
687    switch(workUnitStore.type){
688        case 'request':
689        case 'prerender':
690        case 'prerender-runtime':
691        case 'prerender-client':
692        case 'validation-client':
693            if (workUnitStore.renderResumeDataCache) {
694                // If we are in a prerender, we might have a render resume data cache
695                // that is used to read from prefilled caches.
696                return workUnitStore.renderResumeDataCache;
697            }
698        // fallthrough
699        case 'prerender-ppr':
700            // Otherwise we return the mutable resume data cache here as an immutable
701            // version of the cache as it can also be used for reading.
702            return workUnitStore.prerenderResumeDataCache ?? null;
703        case 'cache':
704        case 'private-cache':
705        case 'unstable-cache':
706        case 'prerender-legacy':
707        case 'generate-static-params':
708            return null;
709        default:
710            return workUnitStore;
711    }
712}
713function getHmrRefreshHash(workUnitStore) {
714    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
715    {
716        var _workUnitStore_cookies_get;
717    /*TURBOPACK member replacement*/ }
718    return undefined;
719}
720function isHmrRefresh(workUnitStore) {
721    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
722    ;
723    return false;
724}
725function getServerComponentsHmrCache(workUnitStore) {
726    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
727    ;
728    return undefined;
729}
730function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
731    if (workStore.isDraftMode) {
732        switch(workUnitStore.type){
733            case 'cache':
734            case 'private-cache':
735            case 'unstable-cache':
736            case 'prerender-runtime':
737            case 'request':
738                return workUnitStore.draftMode;
739            case 'prerender':
740            case 'prerender-client':
741            case 'validation-client':
742            case 'prerender-ppr':
743            case 'prerender-legacy':
744            case 'generate-static-params':
745                break;
746            default:
747                workUnitStore;
748        }
749    }
750    return undefined;
751}
752function getStagedRenderingController(workUnitStore) {
753    switch(workUnitStore.type){
754        case 'request':
755        case 'prerender-runtime':
756            return workUnitStore.stagedRendering ?? null;
757        case 'prerender':
758        case 'prerender-client':
759        case 'validation-client':
760        case 'prerender-ppr':
761        case 'prerender-legacy':
762        case 'cache':
763        case 'private-cache':
764        case 'unstable-cache':
765        case 'generate-static-params':
766            return null;
767        default:
768            return workUnitStore;
769    }
770}
771function getCacheSignal(workUnitStore) {
772    switch(workUnitStore.type){
773        case 'prerender':
774        case 'prerender-client':
775        case 'validation-client':
776        case 'prerender-runtime':
777            return workUnitStore.cacheSignal;
778        case 'request':
779            {
780                // In dev, we might fill caches even during a dynamic request.
781                if (workUnitStore.cacheSignal) {
782                    return workUnitStore.cacheSignal;
783                }
784            // fallthrough
785            }
786        case 'prerender-ppr':
787        case 'prerender-legacy':
788        case 'cache':
789        case 'private-cache':
790        case 'unstable-cache':
791        case 'generate-static-params':
792            return null;
793        default:
794            return workUnitStore;
795    }
796}
797}),

79822783, ((__turbopack_context__, module, exports) => {
799"use strict";
800
801Object.defineProperty(exports, "__esModule", {
802    value: true
803});
804Object.defineProperty(exports, "notFound", {
805    enumerable: true,
806    get: function() {
807        return notFound;
808    }
809});
810const _httpaccessfallback = __turbopack_context__.r(54394);
811/**
812 * This function allows you to render the [not-found.js file](https://nextjs.org/docs/app/api-reference/file-conventions/not-found)
813 * within a route segment as well as inject a tag.
814 *
815 * `notFound()` can be used in
816 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
817 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
818 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
819 *
820 * - In a Server Component, this will insert a `<meta name="robots" content="noindex" />` meta tag and set the status code to 404.
821 * - In a Route Handler or Server Action, it will serve a 404 to the caller.
822 *
823 * Read more: [Next.js Docs: `notFound`](https://nextjs.org/docs/app/api-reference/functions/not-found)
824 */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
825function notFound() {
826    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
827        value: "E1041",
828        enumerable: false,
829        configurable: true
830    });
831    error.digest = DIGEST;
832    throw error;
833}
834if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
835    Object.defineProperty(exports.default, '__esModule', {
836        value: true
837    });
838    Object.assign(exports.default, exports);
839    module.exports = exports.default;
840}
841}),
84213957, ((__turbopack_context__, module, exports) => {
843"use strict";
844
845Object.defineProperty(exports, "__esModule", {
846    value: true
847});
8480 && (module.exports = {
849    ServerInsertedHTMLContext: null,
850    useServerInsertedHTML: null
851});
852function _export(target, all) {
853    for(var name in all)Object.defineProperty(target, name, {
854        enumerable: true,
855        get: all[name]
856    });
857}
858_export(exports, {
859    ServerInsertedHTMLContext: function() {
860        return ServerInsertedHTMLContext;
861    },
862    useServerInsertedHTML: function() {
863        return useServerInsertedHTML;
864    }
865});
866const _interop_require_wildcard = __turbopack_context__.r(90809);
867const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(71645));
868const ServerInsertedHTMLContext = /*#__PURE__*/ _react.default.createContext(null);
869function useServerInsertedHTML(callback) {
870    const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
871    // Should have no effects on client where there's no flush effects provider
872    if (addInsertedServerHTMLCallback) {
873        addInsertedServerHTMLCallback(callback);
874    }
875}
876}),
87779854, ((__turbopack_context__, module, exports) => {
878"use strict";
879
880var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
881"use strict";
882Object.defineProperty(exports, "__esModule", {
883    value: true
884});
885Object.defineProperty(exports, "forbidden", {
886    enumerable: true,
887    get: function() {
888        return forbidden;
889    }
890});
891const _httpaccessfallback = __turbopack_context__.r(54394);
892// TODO: Add `forbidden` docs
893/**
894 * @experimental
895 * This function allows you to render the [forbidden.js file](https://nextjs.org/docs/app/api-reference/file-conventions/forbidden)
896 * within a route segment as well as inject a tag.
897 *
898 * `forbidden()` can be used in
899 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
900 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
901 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
902 *
903 * Read more: [Next.js Docs: `forbidden`](https://nextjs.org/docs/app/api-reference/functions/forbidden)

904 */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};403`;
905function forbidden() {
906    if ("TURBOPACK compile-time truthy", 1) {
907        throw Object.defineProperty(new Error(`\`forbidden()\` is experimental and only allowed to be enabled when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
908            value: "E488",
909            enumerable: false,
910            configurable: true
911        });
912    }
913    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
914        value: "E1019",
915        enumerable: false,
916        configurable: true
917    });
918    error.digest = DIGEST;
919    throw error;
920}
921if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
922    Object.defineProperty(exports.default, '__esModule', {
923        value: true
924    });
925    Object.assign(exports.default, exports);
926    module.exports = exports.default;
927}
928}),
92922683, ((__turbopack_context__, module, exports) => {
930"use strict";
931
932var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
933"use strict";
934Object.defineProperty(exports, "__esModule", {
935    value: true
936});
937Object.defineProperty(exports, "unauthorized", {
938    enumerable: true,
939    get: function() {
940        return unauthorized;
941    }
942});
943const _httpaccessfallback = __turbopack_context__.r(54394);
944// TODO: Add `unauthorized` docs
945/**
946 * @experimental
947 * This function allows you to render the [unauthorized.js file](https://nextjs.org/docs/app/api-reference/file-conventions/unauthorized)
948 * within a route segment as well as inject a tag.
949 *
950 * `unauthorized()` can be used in
951 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
952 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
953 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
954 *
955 *
956 * Read more: [Next.js Docs: `unauthorized`](https://nextjs.org/docs/app/api-reference/functions/unauthorized)
957 */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};401`;
958function unauthorized() {
959    if ("TURBOPACK compile-time truthy", 1) {
960        throw Object.defineProperty(new Error(`\`unauthorized()\` is experimental and only allowed to be used when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
961            value: "E411",
962            enumerable: false,
963            configurable: true
964        });
965    }
966    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
967        value: "E1002",
968        enumerable: false,
969        configurable: true
970    });
971    error.digest = DIGEST;
972    throw error;
973}
974if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
975    Object.defineProperty(exports.default, '__esModule', {
976        value: true
977    });
978    Object.assign(exports.default, exports);
979    module.exports = exports.default;
980}
981}),
98215507, ((__turbopack_context__, module, exports) => {
983"use strict";
984
985Object.defineProperty(exports, "__esModule", {
986    value: true
987});
988Object.defineProperty(exports, "unstable_rethrow", {
989    enumerable: true,
990    get: function() {
991        return unstable_rethrow;
992    }
993});
994const _bailouttocsr = __turbopack_context__.r(32061);
995const _isnextroutererror = __turbopack_context__.r(65713);
996function unstable_rethrow(error) {
997    if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error)) {
998        throw error;
999    }
1000    if (error instanceof Error && 'cause' in error) {
1001        unstable_rethrow(error.cause);
1002    }
1003}
1004if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1005    Object.defineProperty(exports.default, '__esModule', {
1006        value: true
1007    });

1008    Object.assign(exports.default, exports);
1009    module.exports = exports.default;
1010}
1011}),
101263138, ((__turbopack_context__, module, exports) => {
1013"use strict";
1014
1015Object.defineProperty(exports, "__esModule", {
1016    value: true
1017});
10180 && (module.exports = {
1019    delayUntilRuntimeStage: null,
1020    getRuntimeStage: null,
1021    isHangingPromiseRejectionError: null,
1022    makeDevtoolsIOAwarePromise: null,
1023    makeHangingPromise: null
1024});
1025function _export(target, all) {
1026    for(var name in all)Object.defineProperty(target, name, {
1027        enumerable: true,
1028        get: all[name]
1029    });
1030}
1031_export(exports, {
1032    delayUntilRuntimeStage: function() {
1033        return delayUntilRuntimeStage;
1034    },
1035    getRuntimeStage: function() {
1036        return getRuntimeStage;
1037    },
1038    isHangingPromiseRejectionError: function() {
1039        return isHangingPromiseRejectionError;
1040    },
1041    makeDevtoolsIOAwarePromise: function() {
1042        return makeDevtoolsIOAwarePromise;
1043    },
1044    makeHangingPromise: function() {
1045        return makeHangingPromise;
1046    }
1047});
1048const _stagedrendering = __turbopack_context__.r(42852);
1049function isHangingPromiseRejectionError(err) {
1050    if (typeof err !== 'object' || err === null || !('digest' in err)) {
1051        return false;
1052    }
1053    return err.digest === HANGING_PROMISE_REJECTION;
1054}
1055const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION';
1056class HangingPromiseRejectionError extends Error {
1057    constructor(route, expression){
1058        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
1059    }
1060}
1061const abortListenersBySignal = new WeakMap();
1062function makeHangingPromise(signal, route, expression) {
1063    if (signal.aborted) {
1064        return Promise.reject(new HangingPromiseRejectionError(route, expression));
1065    } else {
1066        const hangingPromise = new Promise((_, reject)=>{
1067            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
1068            let currentListeners = abortListenersBySignal.get(signal);
1069            if (currentListeners) {
1070                currentListeners.push(boundRejection);
1071            } else {
1072                const listeners = [
1073                    boundRejection
1074                ];
1075                abortListenersBySignal.set(signal, listeners);
1076                signal.addEventListener('abort', ()=>{
1077                    for(let i = 0; i < listeners.length; i++){
1078                        listeners[i]();
1079                    }
1080                }, {
1081                    once: true
1082                });
1083            }
1084        });
1085        // We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
1086        // we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
1087        // your own promise out of it you'll need to ensure you handle the error when it rejects.
1088        hangingPromise.catch(ignoreReject);
1089        return hangingPromise;
1090    }
1091}
1092function ignoreReject() {}
1093function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
1094    if (requestStore.stagedRendering) {
1095        // We resolve each stage in a timeout, so React DevTools will pick this up as IO.
1096        return requestStore.stagedRendering.delayUntilStage(stage, undefined, underlying);
1097    }
1098    // in React DevTools if we resolve in a setTimeout we will observe
1099    // the promise resolution as something that can suspend a boundary or root.
1100    return new Promise((resolve)=>{
1101        // Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
1102        setTimeout(()=>{
1103            resolve(underlying);
1104        }, 0);
1105    });
1106}
1107function getRuntimeStage(stagedRendering) {
1108    if (stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime) {
1109        return _stagedrendering.RenderStage.EarlyRuntime;
1110    }
1111    return _stagedrendering.RenderStage.Runtime;
1112}
1113function delayUntilRuntimeStage(prerenderStore, result) {
1114    const { stagedRendering } = prerenderStore;
1115    if (!stagedRendering) {
1116        return result;
1117    }
1118    return stagedRendering.waitForStage(getRuntimeStage(stagedRendering)).then(()=>result);
1119}
1120}),

112167287, ((__turbopack_context__, module, exports) => {
1122"use strict";
1123
1124Object.defineProperty(exports, "__esModule", {
1125    value: true
1126});
1127Object.defineProperty(exports, "isPostpone", {
1128    enumerable: true,
1129    get: function() {
1130        return isPostpone;
1131    }
1132});
1133const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
1134function isPostpone(error) {
1135    return typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE;
1136}
1137}),
113876353, ((__turbopack_context__, module, exports) => {
1139"use strict";
1140
1141Object.defineProperty(exports, "__esModule", {
1142    value: true
1143});
11440 && (module.exports = {
1145    DynamicServerError: null,
1146    isDynamicServerError: null
1147});
1148function _export(target, all) {
1149    for(var name in all)Object.defineProperty(target, name, {
1150        enumerable: true,
1151        get: all[name]
1152    });
1153}
1154_export(exports, {
1155    DynamicServerError: function() {
1156        return DynamicServerError;
1157    },
1158    isDynamicServerError: function() {
1159        return isDynamicServerError;
1160    }
1161});
1162const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
1163class DynamicServerError extends Error {
1164    constructor(description){
1165        super(`Dynamic server usage: ${description}`), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
1166    }
1167}
1168function isDynamicServerError(err) {
1169    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
1170        return false;
1171    }
1172    return err.digest === DYNAMIC_ERROR_CODE;
1173}
1174if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1175    Object.defineProperty(exports.default, '__esModule', {
1176        value: true
1177    });
1178    Object.assign(exports.default, exports);
1179    module.exports = exports.default;
1180}
1181}),
118243248, ((__turbopack_context__, module, exports) => {
1183"use strict";
1184
1185Object.defineProperty(exports, "__esModule", {
1186    value: true
1187});
11880 && (module.exports = {
1189    StaticGenBailoutError: null,
1190    isStaticGenBailoutError: null
1191});
1192function _export(target, all) {
1193    for(var name in all)Object.defineProperty(target, name, {
1194        enumerable: true,
1195        get: all[name]
1196    });
1197}
1198_export(exports, {
1199    StaticGenBailoutError: function() {
1200        return StaticGenBailoutError;
1201    },
1202    isStaticGenBailoutError: function() {
1203        return isStaticGenBailoutError;
1204    }
1205});
1206const NEXT_STATIC_GEN_BAILOUT = 'NEXT_STATIC_GEN_BAILOUT';
1207class StaticGenBailoutError extends Error {
1208    constructor(...args){
1209        super(...args), this.code = NEXT_STATIC_GEN_BAILOUT;
1210    }
1211}
1212function isStaticGenBailoutError(error) {
1213    if (typeof error !== 'object' || error === null || !('code' in error)) {
1214        return false;
1215    }
1216    return error.code === NEXT_STATIC_GEN_BAILOUT;
1217}
1218if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1219    Object.defineProperty(exports.default, '__esModule', {
1220        value: true
1221    });
1222    Object.assign(exports.default, exports);
1223    module.exports = exports.default;
1224}
1225}),
122654839, ((__turbopack_context__, module, exports) => {
1227"use strict";
1228
1229Object.defineProperty(exports, "__esModule", {
1230    value: true
1231});
12320 && (module.exports = {
1233    METADATA_BOUNDARY_NAME: null,
1234    OUTLET_BOUNDARY_NAME: null,
1235    ROOT_LAYOUT_BOUNDARY_NAME: null,
1236    VIEWPORT_BOUNDARY_NAME: null
1237});
1238function _export(target, all) {
1239    for(var name in all)Object.defineProperty(target, name, {
1240        enumerable: true,
1241        get: all[name]
1242    });
1243}
1244_export(exports, {
1245    METADATA_BOUNDARY_NAME: function() {
1246        return METADATA_BOUNDARY_NAME;
1247    },
1248    OUTLET_BOUNDARY_NAME: function() {
1249        return OUTLET_BOUNDARY_NAME;
1250    },
1251    ROOT_LAYOUT_BOUNDARY_NAME: function() {
1252        return ROOT_LAYOUT_BOUNDARY_NAME;
1253    },
1254    VIEWPORT_BOUNDARY_NAME: function() {
1255        return VIEWPORT_BOUNDARY_NAME;
1256    }
1257});
1258const METADATA_BOUNDARY_NAME = '__next_metadata_boundary__';
1259const VIEWPORT_BOUNDARY_NAME = '__next_viewport_boundary__';
1260const OUTLET_BOUNDARY_NAME = '__next_outlet_boundary__';
1261const ROOT_LAYOUT_BOUNDARY_NAME = '__next_root_layout_boundary__';
1262}),

126329419, ((__turbopack_context__, module, exports) => {
1264"use strict";
1265
1266var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
1267"use strict";
1268Object.defineProperty(exports, "__esModule", {
1269    value: true
1270});
12710 && (module.exports = {
1272    atLeastOneTask: null,
1273    scheduleImmediate: null,
1274    scheduleOnNextTick: null,
1275    waitAtLeastOneReactRenderTask: null
1276});
1277function _export(target, all) {
1278    for(var name in all)Object.defineProperty(target, name, {
1279        enumerable: true,
1280        get: all[name]
1281    });
1282}
1283_export(exports, {
1284    atLeastOneTask: function() {
1285        return atLeastOneTask;
1286    },
1287    scheduleImmediate: function() {
1288        return scheduleImmediate;
1289    },
1290    scheduleOnNextTick: function() {
1291        return scheduleOnNextTick;
1292    },
1293    waitAtLeastOneReactRenderTask: function() {
1294        return waitAtLeastOneReactRenderTask;
1295    }
1296});
1297const scheduleOnNextTick = (cb)=>{
1298    // We use Promise.resolve().then() here so that the operation is scheduled at
1299    // the end of the promise job queue, we then add it to the next process tick
1300    // to ensure it's evaluated afterwards.
1301    //
1302    // This was inspired by the implementation of the DataLoader interface: https://github.com/graphql/dataloader/blob/d336bd15282664e0be4b4a657cb796f09bafbc6b/src/index.js#L213-L255
1303    //
1304    Promise.resolve().then(()=>{
1305        if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1306        ;
1307        else {
1308            __TURBOPACK__imported__module__47167__["default"].nextTick(cb);
1309        }
1310    });
1311};
1312const scheduleImmediate = (cb)=>{
1313    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1314    ;
1315    else {
1316        setImmediate(cb);
1317    }
1318};
1319function atLeastOneTask() {
1320    return new Promise((resolve)=>scheduleImmediate(resolve));
1321}
1322function waitAtLeastOneReactRenderTask() {
1323    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1324    ;
1325    else {
1326        return new Promise((r)=>setImmediate(r));
1327    }
1328}
1329}),
13302897, ((__turbopack_context__, module, exports) => {
1331"use strict";
1332
1333Object.defineProperty(exports, "__esModule", {
1334    value: true
1335});
1336Object.defineProperty(exports, "INSTANT_VALIDATION_BOUNDARY_NAME", {
1337    enumerable: true,
1338    get: function() {
1339        return INSTANT_VALIDATION_BOUNDARY_NAME;
1340    }
1341});
1342const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
1343}),
134467673, ((__turbopack_context__, module, exports) => {
1345"use strict";
1346
1347var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
1348/**
1349 * The functions provided by this module are used to communicate certain properties
1350 * about the currently running code so that Next.js can make decisions on how to handle
1351 * the current execution in different rendering modes such as pre-rendering, resuming, and SSR.
1352 *
1353 * Today Next.js treats all code as potentially static. Certain APIs may only make sense when dynamically rendering.
1354 * Traditionally this meant deopting the entire render to dynamic however with PPR we can now deopt parts
1355 * of a React tree as dynamic while still keeping other parts static. There are really two different kinds of
1356 * Dynamic indications.
1357 *
1358 * The first is simply an intention to be dynamic. unstable_noStore is an example of this where
1359 * the currently executing code simply declares that the current scope is dynamic but if you use it
1360 * inside unstable_cache it can still be cached. This type of indication can be removed if we ever
1361 * make the default dynamic to begin with because the only way you would ever be static is inside
1362 * a cache scope which this indication does not affect.
1363 *
1364 * The second is an indication that a dynamic data source was read. This is a stronger form of dynamic
1365 * because it means that it is inappropriate to cache this at all. using a dynamic data source inside
1366 * unstable_cache should error. If you want to use some dynamic data inside unstable_cache you should
1367 * read that data outside the cache and pass it in as an argument to the cached function.
1368 */ "use strict";
1369Object.defineProperty(exports, "__esModule", {
1370    value: true
1371});
13720 && (module.exports = {
1373    DynamicHoleKind: null,
1374    Postpone: null,
1375    PreludeState: null,
1376    abortAndThrowOnSynchronousRequestDataAccess: null,

1377    abortOnSynchronousPlatformIOAccess: null,
1378    accessedDynamicData: null,
1379    annotateDynamicAccess: null,
1380    consumeDynamicAccess: null,
1381    createDynamicTrackingState: null,
1382    createDynamicValidationState: null,
1383    createHangingInputAbortSignal: null,
1384    createInstantValidationState: null,
1385    createRenderInBrowserAbortSignal: null,
1386    formatDynamicAPIAccesses: null,
1387    getFirstDynamicReason: null,
1388    getNavigationDisallowedDynamicReasons: null,
1389    getStaticShellDisallowedDynamicReasons: null,
1390    isDynamicPostpone: null,
1391    isPrerenderInterruptedError: null,
1392    logDisallowedDynamicError: null,
1393    markCurrentScopeAsDynamic: null,
1394    postponeWithTracking: null,
1395    throwIfDisallowedDynamic: null,
1396    throwToInterruptStaticGeneration: null,
1397    trackAllowedDynamicAccess: null,
1398    trackDynamicDataInDynamicRender: null,
1399    trackDynamicHoleInNavigation: null,
1400    trackDynamicHoleInRuntimeShell: null,
1401    trackDynamicHoleInStaticShell: null,
1402    trackThrownErrorInNavigation: null,
1403    useDynamicRouteParam

1403s: null,
1404    useDynamicSearchParams: null
1405});
1406function _export(target, all) {
1407    for(var name in all)Object.defineProperty(target, name, {
1408        enumerable: true,
1409        get: all[name]
1410    });
1411}
1412_export(exports, {
1413    DynamicHoleKind: function() {
1414        return DynamicHoleKind;
1415    },
1416    Postpone: function() {
1417        return Postpone;
1418    },
1419    PreludeState: function() {
1420        return PreludeState;
1421    },
1422    abortAndThrowOnSynchronousRequestDataAccess: function() {
1423        return abortAndThrowOnSynchronousRequestDataAccess;
1424    },
1425    abortOnSynchronousPlatformIOAccess: function() {
1426        return abortOnSynchronousPlatformIOAccess;
1427    },
1428    accessedDynamicData: function() {
1429        return accessedDynamicData;
1430    },
1431    annotateDynamicAccess: function() {
1432        return annotateDynamicAccess;
1433    },
1434    consumeDynamicAccess: function() {
1435        return consumeDynamicAccess;
1436    },
1437    createDynamicTrackingState: function() {
1438        return createDynamicTrackingState;
1439    },
1440    createDynamicValidationState: function() {
1441        return createDynamicValidationState;
1442    },
1443    createHangingInputAbortSignal: function() {
1444        return createHangingInputAbortSignal;
1445    },
1446    createInstantValidationState: function() {
1447        return createInstantValidationState;
1448    },
1449    createRenderInBrowserAbortSignal: function() {
1450        return createRenderInBrowserAbortSignal;
1451    },
1452    formatDynamicAPIAccesses: function() {
1453        return formatDynamicAPIAccesses;
1454    },
1455    getFirstDynamicReason: function() {
1456        return getFirstDynamicReason;
1457    },
1458    getNavigationDisallowedDynamicReasons: function() {
1459        return getNavigationDisallowedDynamicReasons;
1460    },
1461    getStaticShellDisallowedDynamicReasons: function() {
1462        return getStaticShellDisallowedDynamicReasons;
1463    },
1464    isDynamicPostpone: function() {
1465        return isDynamicPostpone;
1466    },
1467    isPrerenderInterruptedError: function() {
1468        return isPrerenderInterruptedError;
1469    },
1470    logDisallowedDynamicError: function() {
1471        return logDisallowedDynamicError;
1472    },
1473    markCurrentScopeAsDynamic: function() {
1474        return markCurrentScopeAsDynamic;
1475    },
1476    postponeWithTracking: function() {
1477        return postponeWithTracking;
1478    },
1479    throwIfDisallowedDynamic: function() {
1480        return throwIfDisallowedDynamic;
1481    },
1482    throwToInterruptStaticGeneration: function() {
1483        return throwToInterruptStaticGeneration;
1484    },
1485    trackAllowedDynamicAccess: function() {
1486        return trackAllowedDynamicAccess;
1487    },
1488    trackDynamicDataInDynamicRender: function() {
1489        return trackDynamicDataInDynamicRender;
1490    },
1491    trackDynamicHoleInNavigation: function() {
1492        return trackDynamicHoleInNavigation;
1493    },
1494    trackDynamicHoleInRuntimeShell: function() {
1495        return trackDynamicHoleInRuntimeShell;
1496    },
1497    trackDynamicHoleInStaticShell: function() {
1498        return trackDynamicHoleInStaticShell;
1499    },
1500    trackThrownErrorInNavigation: function() {
1501        return trackThrownErrorInNavigation;
1502    },
1503    useDynamicRouteParams: function() {
1504        return useDynamicRouteParams;
1505    },
1506    useDynamicSearchParams: function() {
1507        return useDynamicSearchParams;
1508    }
1509});
1510const _react = /*#__PURE__*/ _interop_require_default(__turbopack_context__.r(71645));
1511const _hooksservercontext = __turbopack_context__.r(76353);
1512const _staticgenerationbailout = __turbopack_context__.r(43248);
1513const _workunitasyncstorageexternal = __turbopack_context__.r(62141);
1514const _workasyncstorageexternal = __turbopack_context__.r(63599);
1515const _dynamicrenderingutils = __turbopack_context__.r(63138);
1516const _boundaryconstants = __turbopack_context__.r(54839);
1517const _scheduler = __turbopack_context__.r(29419);
1518const _bailouttocsr = __turbopack_context__.r(32061);
1519const _invarianterror = __turbopack_context__.r(12718);
1520const _boundaryconstants1 = __turbopack_context__.r(2897);
1521function _interop_require_default(obj) {
1522    return obj && obj.__esModule ? obj : {
1523        default: obj
1524    };
1525}
1526const hasPostpone = typeof _react.default.unstable_postpone === 'function';
1527function createDynamicTrackingState(isDebugDynamicAccesses) {
1528    return {
1529        isDebugDynamicAccesses,
1530        dynamicAccesses: [],
1531        syncDynamicErrorWithStack: null
1532    };
1533}
1534function createDynamicValidationState() {
1535    return {
1536        hasSuspenseAboveBody: false,
1537        hasDynamicMetadata: false,
1538        dynamicMetadata: null,
1539        hasDynamicViewport: false,

1540        hasAllowedDynamic: false,
1541        dynamicErrors: []
1542    };
1543}
1544function getFirstDynamicReason(trackingState) {
1545    var _trackingState_dynamicAccesses_;
1546    return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
1547}
1548function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
1549    if (workUnitStore) {
1550        switch(workUnitStore.type){
1551            case 'cache':
1552            case 'unstable-cache':
1553                // Inside cache scopes, marking a scope as dynamic has no effect,
1554                // because the outer cache scope creates a cache boundary. This is
1555                // subtly different from reading a dynamic data source, which is
1556                // forbidden inside a cache scope.
1557                return;
1558            case 'private-cache':
1559                // A private cache scope is already dynamic by definition.
1560                return;
1561            case 'prerender-legacy':
1562            case 'prerender-ppr':
1563            case 'request':
1564            case 'generate-static-params':
1565                break;
1566            default:
1567                workUnitStore;
1568        }
1569    }
1570    // If we're forcing dynamic rendering or we're forcing static rendering, we
1571    // don't need to do anything here because the entire page is already dynamic
1572    // or it's static and it should not throw or postpone here.
1573    if (store.forceDynamic || store.forceStatic) return;
1574    if (store.dynamicShouldError) {
1575        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
1576            value: "E553",
1577            enumerable: false,
1578            configurable: true
1579        });
1580    }
1581    if (workUnitStore) {
1582        switch(workUnitStore.type){
1583            case 'prerender-ppr':
1584                return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
1585            case 'prerender-legacy':
1586                workUnitStore.revalidate = 0;
1587                // We aren't prerendering, but we are generating a static page. We need
1588                // to bail out of static generation.
1589                const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
1590                    value: "E550",
1591                    enumerable: false,
1592                    configurable: true
1593                });
1594                store.dynamicUsageDescription = expression;
1595                store.dynamicUsageStack = err.stack;
1596                throw err;
1597            case 'request':
1598                if ("TURBOPACK compile-time truthy", 1) {
1599                    workUnitStore.usedDynamic = true;
1600                }
1601                break;
1602            case 'generate-static-params':
1603                break;
1604            default:
1605                workUnitStore;
1606        }
1607    }
1608}
1609function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
1610    // We aren't prerendering but we are generating a static page. We need to bail out of static generation
1611    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
1612        value: "E558",
1613        enumerable: false,
1614        configurable: true
1615    });
1616    prerenderStore.revalidate = 0;
1617    store.dynamicUsageDescription = expression;
1618    store.dynamicUsageStack = err.stack;
1619    throw err;
1620}
1621function trackDynamicDataInDynamicRender(workUnitStore) {
1622    switch(workUnitStore.type){
1623        case 'cache':
1624        case 'unstable-cache':
1625            // Inside cache scopes, marking a scope as dynamic has no effect,
1626            // because the outer cache scope creates a cache boundary. This is
1627            // subtly different from reading a dynamic data source, which is
1628            // forbidden inside a cache scope.
1629            return;
1630        case 'private-cache':
1631            // A private cache scope is already dynamic by definition.
1632            return;
1633        case 'prerender':
1634        case 'prerender-runtime':
1635        case 'prerender-legacy':
1636        case 'prerender-ppr':
1637        case 'prerender-client':
1638        case 'validation-client':
1639        case 'generate-static-params':
1640            break;
1641        case 'request':
1642            if ("TURBOPACK compile-time truthy", 1) {
1643                workUnitStore.usedDynamic = true;
1644            }
1645            break;
1646        default:
1647            workUnitStore;
1648    }
1649}
1650function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
1651    const reason = `Route ${route}

1651 needs to bail out of prerendering at this point because it used ${expression}.`;
1652    const error = createPrerenderInterruptedError(reason);
1653    prerenderStore.controller.abort(error);
1654    const dynamicTracking = prerenderStore.dynamicTracking;
1655    if (dynamicTracking) {
1656        dynamicTracking.dynamicAccesses.push({
1657            // When we aren't debugging, we don't need to create another error for the
1658            // stack trace.
1659            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
1660            expression
1661        });
1662    }
1663}
1664function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
1665    const dynamicTracking = prerenderStore.dynamicTracking;
1666    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
1667    // It is important that we set this tracking value after aborting. Aborts are executed
1668    // synchronously except for the case where you abort during render itself. By setting this
1669    // value late we can use it to determine if any of the aborted tasks are the task that
1670    // called the sync IO expression in the first place.
1671    if (dynamicTracking) {
1672        if (dynamicTracking.syncDynamicErrorWithStack === null) {
1673            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
1674        }
1675    }
1676}
1677function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
1678    const prerenderSignal = prerenderStore.controller.signal;
1679    if (prerenderSignal.aborted === false) {
1680        // TODO it would be better to move this aborted check into the callsite so we can avoid making
1681        // the error object when it isn't relevant to the aborting of the prerender however
1682        // since we need the throw semantics regardless of whether we abort it is easier to land
1683        // this way. See how this was handled with `abortOnSynchronousPlatformIOAccess` for a closer
1684        // to ideal implementation
1685        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
1686        // It is important that we set this tracking value after aborting. Aborts are executed
1687        // synchronously except for the case where you abort during render itself. By setting this
1688        // value late we can use it to determine if any of the aborted tasks are the task that
1689        // called the sync IO expression in the first place.
1690        const dynamicTracking = prerenderStore.dynamicTracking;
1691        if (dynamicTracking) {
1692            if (dynamicTracking.syncDynamicErrorWithStack === null) {
1693                dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
1694            }
1695        }
1696    }
1697    throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
1698}
1699function Postpone({ reason, route }) {
1700    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1701    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
1702    postponeWithTracking(route, reason, dynamicTracking);
1703}
1704function postponeWithTracking(route, expression, dynamicTracking) {
1705    assertPostpone();
1706    if (dynamicTracking) {
1707        dynamicTracking.dynamicAccesses.push({
1708            // When we aren't debugging, we don't need to create another error for the
1709            // stack trace.
1710            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
1711            expression
1712        });
1713    }
1714    _react.default.unstable_postpone(createPostponeReason(route, expression));
1715}
1716function createPostponeReason(route, expression) {
1717    return `Route ${route} needs to bail out of prerendering at this point because it used ${expression}. ` + `React throws this special object to indicate where. It should not be caught by ` + `your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`;
1718}
1719function isDynamicPostpone(err) {
1720    if (typeof err === 'object' && err !== null && typeof err.message === 'string') {
1721        return isDynamicPostponeReason(err.message);
1722    }
1723    return false;

1724}
1725function isDynamicPostponeReason(reason) {
1726    return reason.includes('needs to bail out of prerendering at this point because it used') && reason.includes('Learn more: https://nextjs.org/docs/messages/ppr-caught-error');
1727}
1728if (isDynamicPostponeReason(createPostponeReason('%%%', '^^^')) === false) {
1729    throw Object.defineProperty(new Error('Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
1730        value: "E296",
1731        enumerable: false,
1732        configurable: true
1733    });
1734}
1735const NEXT_PRERENDER_INTERRUPTED = 'NEXT_PRERENDER_INTERRUPTED';
1736function createPrerenderInterruptedError(message) {
1737    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1738        value: "E394",
1739        enumerable: false,
1740        configurable: true
1741    });
1742    error.digest = NEXT_PRERENDER_INTERRUPTED;
1743    return error;
1744}
1745function isPrerenderInterruptedError(error) {
1746    return typeof error === 'object' && error !== null && error.digest === NEXT_PRERENDER_INTERRUPTED && 'name' in error && 'message' in error && error instanceof Error;
1747}
1748function accessedDynamicData(dynamicAccesses) {
1749    return dynamicAccesses.length > 0;
1750}
1751function consumeDynamicAccess(serverDynamic, clientDynamic) {
1752    // We mutate because we only call this once we are no longer writing
1753    // to the dynamicTrackingState and it's more efficient than creating a new
1754    // array.
1755    serverDynamic.dynamicAccesses.push(...clientDynamic.dynamicAccesses);
1756    return serverDynamic.dynamicAccesses;
1757}
1758function formatDynamicAPIAccesses(dynamicAccesses) {
1759    return dynamicAccesses.filter((access)=>typeof access.stack === 'string' && access.stack.length > 0).map(({ expression, stack })=>{
1760        stack = stack.split('\n') // Remove the "Error: " prefix from the first line of the stack trace as
1761        // well as the first 4 lines of the stack trace which is the distance
1762        // from the user code and the `new Error().stack` call.
1763        .slice(4).filter((line)=>{
1764            // Exclude Next.js internals from the stack trace.
1765            if (line.includes('node_modules/next/')) {
1766                return false;
1767            }
1768            // Exclude anonymous functions from the stack trace.
1769            if (line.includes(' (<anonymous>)')) {
1770                return false;
1771            }
1772            // Exclude Node.js internals from the stack trace.
1773            if (line.includes(' (node:')) {
1774                return false;
1775            }
1776            return true;
1777        }).join('\n');
1778        return `Dynamic API Usage Debug - ${expression}:\n${stack}`;
1779    });
1780}
1781function assertPostpone() {
1782    if (!hasPostpone) {
1783        throw Object.defineProperty(new Error(`Invariant: React.unstable_postpone is not defined. This suggests the wrong version of React was loaded. This is a bug in Next.js`), "__NEXT_ERROR_CODE", {
1784            value: "E224",
1785            enumerable: false,
1786            configurable: true
1787        });
1788    }
1789}
1790function createRenderInBrowserAbortSignal() {
1791    const controller = new AbortController();
1792    controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError('Render in Browser'), "__NEXT_ERROR_CODE", {
1793        value: "E721",
1794        enumerable: false,
1795        configurable: true
1796    }));
1797    return controller.signal;
1798}
1799function createHangingInputAbortSignal(workUnitStore) {
1800    switch(workUnitStore.type){
1801        case 'prerender':
1802        case 'prerender-runtime':
1803            const controller = new AbortController();
1804            if (workUnitStore.cacheSignal) {
1805                // If we have a cacheSignal it means we're in a prospective render. If
1806                // the input we're waiting on is coming from another cache, we do want
1807                // to wait for it so that we can resolve this cache entry too.
1808                workUnitStore.cacheSignal.inputReady().then(()=>{
1809                    controller.abort();
1810                });
1811            } else {
1812                // Otherwise we're in the final render and we should already have all
1813                // our caches filled.
1814                // If the prerender uses stages, we have wait until the runtime stage,
1815                // at which point all runtime inputs will be resolved.
1816                // (otherwise, a runtime prerender might consider `cookies()` hanging
1817                //  even though they'd resolve in the next task.)
1818                //
1819                // We might still be waiting on some microtasks so we
1820                // wait one tick before giving up. When we give up, we still want to
1821                // render the content of this cache as deeply as we can so that we can
1822                // suspend as deeply as possible in the tree or not at all if we don't
1823                // end up waiting for the input.
1824                if (workUnitStore.type === 'prerender-runtime' && workUnitStore.stagedRendering) {
1825                    const { stagedRendering } = workUnitStore;
1826                    stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering)).then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
1827                } else {
1828                    (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
1829                }
1830            }
1831            return controller.signal;
1832        case 'prerender-client':
1833        case 'validation-client':
1834        case 'prerender-ppr':
1835        case 'prerender-legacy':
1836        case 'request':
1837        case 'cache':
1838        case 'private-cache':
1839        case 'unstable-cache':
1840        case 'generate-static-params':
1841            return undefined;
1842        default:
1843            workUnitStore;
1844    }
1845}
1846function annotateDynamicAccess(expression, prerenderStore) {
1847    const dynamicTracking = prerenderStore.dynamicTracking;
1848    if (dynamicTracking) {
1849        dynamicTracking.dynamicAccesses.push({
1850            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
1851            expression
1852        });
1853    }
1854}

1855function useDynamicRouteParams(expression) {
1856    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
1857    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1858    if (workStore && workUnitStore) {
1859        switch(workUnitStore.type){
1860            case 'prerender-client':
1861            case 'prerender':
1862                {
1863                    const fallbackParams = workUnitStore.fallbackRouteParams;
1864                    if (fallbackParams && fallbackParams.size > 0) {
1865                        // We are in a prerender with cacheComponents semantics. We are going to
1866                        // hang here and never resolve. This will cause the currently
1867                        // rendering component to effectively be a dynamic hole.
1868                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
1869                    }
1870                    break;
1871                }
1872            case 'prerender-ppr':
1873                {
1874                    const fallbackParams = workUnitStore.fallbackRouteParams;
1875                    if (fallbackParams && fallbackParams.size > 0) {
1876                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
1877                    }
1878                    break;
1879                }
1880            case 'validation-client':
1881                {
1882                    break;
1883                }
1884            case 'prerender-runtime':
1885                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1886                    value: "E771",
1887                    enumerable: false,
1888                    configurable: true
1889                });
1890            case 'cache':
1891            case 'private-cache':
1892                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1893                    value: "E745",
1894                    enumerable: false,
1895                    configurable: true
1896                });
1897            case 'generate-static-params':
1898                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1899                    value: "E1130",
1900                    enumerable: false,
1901                    configurable: true
1902                });
1903            case 'prerender-legacy':
1904            case 'request':
1905            case 'unstable-cache':
1906                break;
1907            default:
1908                workUnitStore;
1909        }
1910    }
1911}
1912function useDynamicSearchParams(expression) {
1913    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
1914    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1915    if (!workStore) {
1916        // We assume pages router context and just return
1917        return;
1918    }
1919    if (!workUnitStore) {
1920        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
1921    }
1922    switch(workUnitStore.type){
1923        case 'validation-client':
1924            // During instant validation we try to behave as close to client as possible,
1925            // so this shouldn't hang during SSR.
1926            return;
1927        case 'prerender-client':
1928            {
1929                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
1930                break;
1931            }
1932        case 'prerender-legacy':
1933        case 'prerender-ppr':
1934            {
1935                if (workStore.forceStatic) {
1936                    return;
1937                }
1938                throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(expression), "__NEXT_ERROR_CODE", {
1939                    value: "E394",
1940                    enumerable: false,
1941                    configurable: true
1942                });
1943            }
1944        case 'prerender':
1945        case 'prerender-runtime':
1946            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called from a Server Component. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1947                value: "E795",
1948                enumerable: false,
1949                configurable: true
1950            });
1951        case 'cache':
1952        case 'unstable-cache':
1953        case 'private-cache':
1954            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}

1954\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1955                value: "E745",
1956                enumerable: false,
1957                configurable: true
1958            });
1959        case 'generate-static-params':
1960            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
1961                value: "E1130",
1962                enumerable: false,
1963                configurable: true
1964            });
1965        case 'request':
1966            return;
1967        default:
1968            workUnitStore;
1969    }
1970}
1971const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
1972// Common implicit body tags that React will treat as body when placed directly in html
1973const bodyAndImplicitTags = 'body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6';
1974// Detects when RootLayoutBoundary (our framework marker component) appears
1975// after Suspense in the component stack, indicating the root layout is wrapped
1976// within a Suspense boundary. Ensures no body/html/implicit-body components are in between.
1977//
1978// Example matches:
1979//   at Suspense (<anonymous>)
1980//   at __next_root_layout_boundary__ (<anonymous>)
1981//
1982// Or with other components in between (but not body/html/implicit-body):
1983//   at Suspense (<anonymous>)
1984//   at SomeComponent (<anonymous>)
1985//   at __next_root_layout_boundary__ (<anonymous>)
1986const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
1987const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
1988const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
1989const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
1990const hasInstantValidationBoundaryRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_VALIDATION_BOUNDARY_NAME}[\\n\\s]`);
1991function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
1992    if (hasOutletRegex.test(componentStack)) {
1993        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
1994        return;
1995    } else if (hasMetadataRegex.test(componentStack)) {
1996        dynamicValidation.hasDynamicMetadata = true;
1997        return;
1998    } else if (hasViewportRegex.test(componentStack)) {
1999        dynamicValidation.hasDynamicViewport = true;
2000        return;
2001    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
2002        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
2003        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
2004        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
2005        dynamicValidation.hasAllowedDynamic = true;
2006        dynamicValidation.hasSuspenseAboveBody = true;
2007        return;
2008    } else if (hasSuspenseRegex.test(componentStack)) {
2009        // this error had a Suspense boundary above it so we don't need to report it as a source
2010        // of disallowed
2011        dynamicValidation.hasAllowedDynamic = true;
2012        return;
2013    } else if (clientDynamic.syncDynamicErrorWithStack) {
2014        // This task was the task that called the sync error.
2015        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
2016        return;
2017    } else {
2018        const message = `Route "${workStore.route}": Uncached data was accessed outside of ` + '<Suspense>. This delays the entire page from rendering, resulting in a ' + 'slow user experience. Learn more: ' + 'https://nextjs.org/docs/messages/blocking-route';
2019        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2020            value: "E1079",
2021            enumerable: false,
2022            configurable: true
2023        }), componentStack, null);
2024        dynamicValidation.dynamicErrors.push(error);
2025        return;
2026    }
2027}
2028var DynamicHoleKind = /*#__PURE__*/ function(DynamicHoleKind) {
2029    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 1] = "Runtime";
2030    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 2] = "Dynamic";
2031    return DynamicHoleKind;
2032}({});
2033function createInstantValidationState(createInstantStack) {
2034    return {
2035        hasDynamicMetadata: false,
2036        hasAllowedClientDynamicAboveBoundary: false,
2037        dynamicMetadata: null,
2038        hasDynamicViewport: false,

2039        hasAllowedDynamic: false,
2040        dynamicErrors: [],
2041        validationPreventingErrors: [],
2042        thrownErrorsOutsideBoundary: [],
2043        createInstantStack
2044    };
2045}
2046function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
2047    if (hasOutletRegex.test(componentStack)) {
2048        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
2049        return;
2050    }
2051    if (hasMetadataRegex.test(componentStack)) {
2052        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments.` : `Uncached data or \`connection()\` was accessed inside \`generateMetadata\`.`;
2053        const message = `Route "${workStore.route}": ${usageDescription} Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
2054        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2055            value: "E1076",
2056            enumerable: false,
2057            configurable: true
2058        }), componentStack, dynamicValidation.createInstantStack);
2059        dynamicValidation.dynamicMetadata = error;
2060        return;
2061    }
2062    if (hasViewportRegex.test(componentStack)) {
2063        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`.` : `Uncached data or \`connection()\` was accessed inside \`generateViewport\`.`;
2064        const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
2065        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2066            value: "E1086",
2067            enumerable: false,
2068            configurable: true
2069        }), componentStack, dynamicValidation.createInstantStack);
2070        dynamicValidation.dynamicErrors.push(error);
2071        return;
2072    }
2073    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
2074    if (!boundaryLocation) {
2075        // We don't see the validation boundary in the component stack,
2076        // so this hole must be coming from a shared parent.
2077        // Shared parents are fully resolved and don't have RSC holes,
2078        // but they can still suspend in a client component during SSR.
2079        // If we managed to render all the validation boundaries, that means
2080        // that the client holes aren't blocking validation and we can disregard them.
2081        // Note that we don't even care whether they have suspense or not.
2082        if (boundaryState.expectedIds.size === boundaryState.renderedIds.size) {
2083            dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
2084            dynamicValidation.hasAllowedDynamic = true // Holes outside the boundary contribute to allowing dynamic metadata
2085            ;
2086            return;
2087        } else {
2088            // TODO(instant-validation) TODO(NAR-787)
2089            // If shared parents blocked us from validating, we should only log
2090            // the errors from the innermost (segments), i.e. omit layouts whose
2091            // slots managed to render (because clearly they didn't block validation)
2092            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because a Client Component in a parent segment prevented the page from rendering.`;
2093            const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2094                value: "E1082",
2095                enumerable: false,
2096                configurable: true
2097            }), componentStack, dynamicValidation.createInstantStack);
2098            dynamicValidation.validationPreventingErrors.push(error);
2099            return;
2100        }
2101    } else {
2102        // The hole originates inside the validation boundary.
2103        //
2104        // Check if we have a Suspense above the hole, but below the validation boundary.

2105        // If we do, then this dynamic usage wouldn't block a navigation to this subtree.
2106        // Conversely, if the nearest suspense is above the validation boundary, then this subtree would block.
2107        //
2108        // Note that in the component stack, children come before parents.
2109        //
2110        // Valid:
2111        //   ...
2112        //   at Suspense
2113        //   ...
2114        //   at __next_prefetch_validation_boundary__
2115        //
2116        // Invalid:
2117        //   ...
2118        //   at __next_prefetch_validation_boundary__
2119        //   ...
2120        //   at Suspense
2121        //
2122        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
2123        if (suspenseLocation) {
2124            if (suspenseLocation.index < boundaryLocation.index) {
2125                dynamicValidation.hasAllowedDynamic = true;
2126                return;
2127            } else {
2128            // invalid - fallthrough
2129            }
2130        }
2131    }
2132    if (clientDynamic.syncDynamicErrorWithStack) {
2133        // This task was the task that called the sync error.
2134        const syncError = clientDynamic.syncDynamicErrorWithStack;
2135        if (dynamicValidation.createInstantStack !== null && syncError.cause === undefined) {
2136            syncError.cause = dynamicValidation.createInstantStack();
2137        }
2138        dynamicValidation.dynamicErrors.push(syncError);
2139        return;
2140    }
2141    const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`.` : `Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`.`;
2142    const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
2143    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2144        value: "E1078",
2145        enumerable: false,
2146        configurable: true
2147    }), componentStack, dynamicValidation.createInstantStack);
2148    dynamicValidation.dynamicErrors.push(error);
2149    return;
2150}
2151function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack) {
2152    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
2153    if (!boundaryLocation) {
2154        // There's no validation boundary on the component stack.
2155        // This error may have blocked a boundary from rendering.
2156        // Wrap the error to provide component context.
2157        // This helps for errors from node_modules which would otherwise
2158        // have no useful stack information due to ignore-listing,
2159        // e.g. next/dynamic with `ssr: false`.
2160        const error = addErrorContext(Object.defineProperty(new Error('An error occurred while attempting to validate instant UI. This error may be preventing the validation from completing.', {
2161            cause: thrownValue
2162        }), "__NEXT_ERROR_CODE", {
2163            value: "E1118",
2164            enumerable: false,
2165            configurable: true
2166        }), componentStack, null);
2167        dynamicValidation.thrownErrorsOutsideBoundary.push(error);
2168    } else {
2169        // There's validation boundary on the component stack,
2170        // so we know this error didn't block a validation boundary from rendering.
2171        // However, this error might be hiding be hiding dynamic content that would
2172        // cause validation to fail.
2173        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
2174        if (suspenseLocation) {
2175            if (suspenseLocation.index < boundaryLocation.index) {
2176                // There's a Suspense below the validation boundary but above this error's location.
2177                // This subtree can't fail instant validation because any potential
2178                // dynamic holes would be guarded by the Suspense anyway,
2179                // so we can allow this.
2180                return;
2181            } else {
2182            // invalid - fallthrough
2183            }
2184        }
2185        const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because an error prevented the target segment from rendering.`;
2186        const error = addErrorContext(Object.defineProperty(new Error(message, {
2187            cause: thrownValue
2188        }), "__NEXT_ERROR_CODE", {
2189            value: "E1112",
2190            enumerable: false,
2191            configurable: true
2192        }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
2193        );
2194        dynamicValidation.validationPreventingErrors.push(error);
2195    }
2196}
2197function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
2198    if (hasOutletRegex.test(componentStack)) {
2199        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
2200        return;
2201    } else if (hasMetadataRegex.test(componentStack)) {
2202        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
2203        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2204            value: "E1080",
2205            enumerable: false,
2206            configurable: true
2207        }), componentStack, null);
2208        dynamicValidation.dynamicMetadata = error;
2209        return;
2210    } else if (hasViewportRegex.test(componentStack)) {
2211        // TODO(instant-validation): If the page only has holes caused by runtime data,
2212        // we won't find out if there's a suspense-above-body and error for dynamic viewport
2213        // even if there is in fact a suspense-above-body
2214        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
2215        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2216            value: "E1077",
2217            enumerable: false,
2218            configurable: true
2219        }), componentStack, null);
2220        dynamicValidation.dynamicErrors.push(error);
2221        return;
2222    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
2223        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
2224        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
2225        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
2226        dynamicValidation.hasAllowedDynamic = true;
2227        dynamicValidation.hasSuspenseAboveBody = true;
2228        return;
2229    } else if (hasSuspenseRegex.test(componentStack)) {
2230        // this error had a Suspense boundary above it so we don't need to report it as a source
2231        // of disallowed
2232        dynamicValidation.hasAllowedDynamic = true;
2233        return;
2234    } else if (clientDynamic.syncDynamicErrorWithStack) {
2235        // This task was the task that called the sync error.
2236        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
2237        return;
2238    }
2239    const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed outside of \`<Su

2239spense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
2240    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2241        value: "E1084",
2242        enumerable: false,
2243        configurable: true
2244    }), componentStack, null);
2245    dynamicValidation.dynamicErrors.push(error);
2246    return;
2247}
2248function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
2249    if (hasOutletRegex.test(componentStack)) {
2250        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
2251        return;
2252    } else if (hasMetadataRegex.test(componentStack)) {
2253        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
2254        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2255            value: "E1085",
2256            enumerable: false,
2257            configurable: true
2258        }), componentStack, null);
2259        dynamicValidation.dynamicMetadata = error;
2260        return;
2261    } else if (hasViewportRegex.test(componentStack)) {
2262        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
2263        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2264            value: "E1081",
2265            enumerable: false,
2266            configurable: true
2267        }), componentStack, null);
2268        dynamicValidation.dynamicErrors.push(error);
2269        return;
2270    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
2271        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
2272        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
2273        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
2274        dynamicValidation.hasAllowedDynamic = true;
2275        dynamicValidation.hasSuspenseAboveBody = true;
2276        return;
2277    } else if (hasSuspenseRegex.test(componentStack)) {
2278        // this error had a Suspense boundary above it so we don't need to report it as a source
2279        // of disallowed
2280        dynamicValidation.hasAllowedDynamic = true;
2281        return;
2282    } else if (clientDynamic.syncDynamicErrorWithStack) {
2283        // This task was the task that called the sync error.
2284        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
2285        return;
2286    } else {
2287        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
2288        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2289            value: "E1083",
2290            enumerable: false,
2291            configurable: true
2292        }), componentStack, null);
2293        dynamicValidation.dynamicErrors.push(error);
2294        return;
2295    }
2296}
2297/**
2298 * In dev mode, we prefer using the owner stack, otherwise the provided
2299 * component stack is used.
2300 *
2301 * Accepts an already-created Error so the SWC error-code plugin can see the
2302 * `new Error(...)` call at each call site and auto-assign error codes.
2303 */ function addErrorContext(error, componentStack, createInstantStack) {
2304    const ownerStack = ("TURBOPACK compile-time value", "development") !== 'production' && _react.default.captureOwnerStack ? _react.default.captureOwnerStack() : null;
2305    if (createInstantStack !== null) {
2306        error.cause = createInstantStack();
2307    }
2308    // TODO go back to owner stack here if available. This is temporarily using componentStack to get the right
2309    //
2310    error.stack = error.name + ': ' + error.message + (ownerStack || componentStack);
2311    return error;
2312}
2313var PreludeState = /*#__PURE__*/ function(PreludeState) {
2314    PreludeState[PreludeState["Full"] = 0] = "Full";
2315    PreludeState[PreludeState["Empty"] = 1] = "Empty";
2316    PreludeState[PreludeState["Errored"] = 2] = "Errored";
2317    return PreludeState;
2318}({});
2319function logDisallowedDynamicError(workStore, error) {
2320    console.error(error);
2321    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2322    ;
2323    else if ("TURBOPACK compile-time truthy", 1) {
2324        console.error(`To debug the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
2325    }
2326}
2327function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
2328    if (serverDynamic.syncDynamicErrorWithStack) {
2329        logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
2330        throw new _staticgenerationbailout.StaticGenBailoutError();
2331    }
2332    if (prelude !== 0) {
2333        if (dynamicValidation.hasSuspenseAboveBody) {

2334            // This route has opted into allowing fully dynamic rendering
2335            // by including a Suspense boundary above the body. In this case
2336            // a lack of a shell is not considered disallowed so we simply return
2337            return;
2338        }
2339        // We didn't have any sync bailouts but there may be user code which
2340        // blocked the root. We would have captured these during the prerender
2341        // and can log them here and then terminate the build/validating render
2342        const dynamicErrors = dynamicValidation.dynamicErrors;
2343        if (dynamicErrors.length > 0) {
2344            for(let i = 0; i < dynamicErrors.length; i++){
2345                logDisallowedDynamicError(workStore, dynamicErrors[i]);
2346            }
2347            throw new _staticgenerationbailout.StaticGenBailoutError();
2348        }
2349        // If we got this far then the only other thing that could be blocking
2350        // the root is dynamic Viewport. If this is dynamic then
2351        // you need to opt into that by adding a Suspense boundary above the body
2352        // to indicate your are ok with fully dynamic rendering.
2353        if (dynamicValidation.hasDynamicViewport) {
2354            console.error(`Route "${workStore.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`);
2355            throw new _staticgenerationbailout.StaticGenBailoutError();
2356        }
2357        if (prelude === 1) {
2358            // If we ever get this far then we messed up the tracking of invalid dynamic.
2359            // We still adhere to the constraint that you must produce a shell but invite the
2360            // user to report this as a bug in Next.js.
2361            console.error(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`);
2362            throw new _staticgenerationbailout.StaticGenBailoutError();
2363        }
2364    } else {
2365        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
2366            console.error(`Route "${workStore.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`);
2367            throw new _staticgenerationbailout.StaticGenBailoutError();
2368        }
2369    }
2370}
2371function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, configAllowsBlocking) {
2372    if (configAllowsBlocking || dynamicValidation.hasSuspenseAboveBody) {
2373        // This route has opted into allowing fully dynamic rendering
2374        // by including a Suspense boundary above the body. In this case
2375        // a lack of a shell is not considered disallowed so we simply return
2376        return [];
2377    }
2378    if (prelude !== 0) {
2379        // We didn't have any sync bailouts but there may be user code which
2380        // blocked the root. We would have captured these during the prerender
2381        // and can log them here and then terminate the build/validating render
2382        const dynamicErrors = dynamicValidation.dynamicErrors;
2383        if (dynamicErrors.length > 0) {
2384            return dynamicErrors;
2385        }
2386        if (prelude === 1) {
2387            // If we ever get this far then we messed up the tracking of invalid dynamic.
2388            // We still adhere to the constraint that you must produce a shell but invite the
2389            // user to report this as a bug in Next.js.
2390            return [
2391                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
2392                    value: "E936",
2393                    enumerable: false,
2394                    configurable: true
2395                })
2396            ];
2397        }
2398    } else {
2399        // We have a prelude but we might still have dynamic metadata without any other dynamic access
2400        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
2401            return [
2402                dynamicValidation.dynamicMetadata
2403            ];
2404        }
2405    }
2406    // We had a non-empty prelude and there are no dynamic holes
2407    return [];
2408}
2409function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
2410    // If we have errors related to missing samples, those should take precedence over everything else.
2411    if (validationSampleTracking) {
2412        const { missingSampleErrors } = validationSampleTracking;
2413        if (missingSampleErrors.length > 0) {
2414            return missingSampleErrors;
2415        }
2416    }
2417    const { validationPreventingErrors } = dynamicValidation;
2418    if (validationPreventingErrors.length > 0) {
2419        return validationPreventingErrors;
2420    }
2421    if (boundaryState.renderedIds.size < boundaryState.expectedIds.size) {
2422        const { thrownErrorsOutsideBoundary, createInstantStack } = dynamicValidation;
2423        if (thrownErrorsOutsideBoundary.length === 0) {
2424            const message = `Route "${workStore.route}

2424": Could not validate \`unstable_instant\` because the target segment was prevented from rendering for an unknown reason.`;
2425            const error = createInstantStack !== null ? createInstantStack() : new Error();
2426            error.name = 'Error';
2427            error.message = message;
2428            return [
2429                error
2430            ];
2431        } else if (thrownErrorsOutsideBoundary.length === 1) {
2432            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to the following error.`;
2433            const error = createInstantStack !== null ? createInstantStack() : new Error();
2434            error.name = 'Error';
2435            error.message = message;
2436            return [
2437                error,
2438                thrownErrorsOutsideBoundary[0]
2439            ];
2440        } else {
2441            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to one of the following errors.`;
2442            const error = createInstantStack !== null ? createInstantStack() : new Error();
2443            error.name = 'Error';
2444            error.message = message;
2445            return [
2446                error,
2447                ...thrownErrorsOutsideBoundary
2448            ];
2449        }
2450    }
2451    // NOTE: We don't care about Suspense above body here,
2452    // we're only concerned with the validation boundary
2453    if (prelude !== 0) {
2454        const dynamicErrors = dynamicValidation.dynamicErrors;
2455        if (dynamicErrors.length > 0) {
2456            return dynamicErrors;
2457        }
2458        if (prelude === 1) {
2459            // If a client component suspended prevented us from rendering a shell
2460            // but didn't block validation, we don't require a prelude.
2461            if (dynamicValidation.hasAllowedClientDynamicAboveBoundary) {
2462                return [];
2463            }
2464            // If we ever get this far then we messed up the tracking of invalid dynamic.
2465            return [
2466                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" failed to render during instant validation and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
2467                    value: "E1055",
2468                    enumerable: false,
2469                    configurable: true
2470                })
2471            ];
2472        }
2473    } else {
2474        const dynamicErrors = dynamicValidation.dynamicErrors;
2475        if (dynamicErrors.length > 0) {
2476            return dynamicErrors;
2477        }
2478        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicMetadata) {
2479            return [
2480                dynamicValidation.dynamicMetadata
2481            ];
2482        }
2483    }
2484    // We had a non-empty prelude and there are no dynamic holes
2485    return [];
2486}
2487}),
248891414, ((__turbopack_context__, module, exports) => {
2489"use strict";
2490
2491Object.defineProperty(exports, "__esModule", {
2492    value: true
2493});
2494Object.defineProperty(exports, "unstable_rethrow", {
2495    enumerable: true,
2496    get: function() {
2497        return unstable_rethrow;
2498    }
2499});
2500const _dynamicrenderingutils = __turbopack_context__.r(63138);
2501const _ispostpone = __turbopack_context__.r(67287);
2502const _bailouttocsr = __turbopack_context__.r(32061);
2503const _isnextroutererror = __turbopack_context__.r(65713);
2504const _dynamicrendering = __turbopack_context__.r(67673);
2505const _hooksservercontext = __turbopack_context__.r(76353);
2506function unstable_rethrow(error) {
2507    if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error) || (0, _hooksservercontext.isDynamicServerError)(error) || (0, _dynamicrendering.isDynamicPostpone)(error) || (0, _ispostpone.isPostpone)(error) || (0, _dynamicrenderingutils.isHangingPromiseRejectionError)(error) || (0, _dynamicrendering.isPrerenderInterruptedError)(error)) {
2508        throw error;
2509    }
2510    if (error instanceof Error && 'cause' in error) {
2511        unstable_rethrow(error.cause);
2512    }
2513}
2514if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
2515    Object.defineProperty(exports.default, '__esModule', {
2516        value: true
2517    });

2518    Object.assign(exports.default, exports);
2519    module.exports = exports.default;
2520}
2521}),
252290508, ((__turbopack_context__, module, exports) => {
2523"use strict";
2524
2525/**
2526 * This function should be used to rethrow internal Next.js errors so that they can be handled by the framework.
2527 * When wrapping an API that uses errors to interrupt control flow, you should use this function before you do any error handling.
2528 * This function will rethrow the error if it is a Next.js error so it can be handled, otherwise it will do nothing.
2529 *
2530 * Read more: [Next.js Docs: `unstable_rethrow`](https://nextjs.org/docs/app/api-reference/functions/unstable_rethrow)
2531 */ Object.defineProperty(exports, "__esModule", {
2532    value: true
2533});
2534Object.defineProperty(exports, "unstable_rethrow", {
2535    enumerable: true,
2536    get: function() {
2537        return unstable_rethrow;
2538    }
2539});
2540const unstable_rethrow = typeof window === 'undefined' ? __turbopack_context__.r(91414).unstable_rethrow : __turbopack_context__.r(15507).unstable_rethrow;
2541if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
2542    Object.defineProperty(exports.default, '__esModule', {
2543        value: true
2544    });
2545    Object.assign(exports.default, exports);
2546    module.exports = exports.default;
2547}
2548}),
254992805, ((__turbopack_context__, module, exports) => {
2550"use strict";
2551
2552Object.defineProperty(exports, "__esModule", {
2553    value: true
2554});
25550 && (module.exports = {
2556    ReadonlyURLSearchParams: null,
2557    RedirectType: null,
2558    forbidden: null,
2559    notFound: null,
2560    permanentRedirect: null,
2561    redirect: null,
2562    unauthorized: null,
2563    unstable_isUnrecognizedActionError: null,
2564    unstable_rethrow: null
2565});
2566function _export(target, all) {
2567    for(var name in all)Object.defineProperty(target, name, {
2568        enumerable: true,
2569        get: all[name]
2570    });
2571}
2572_export(exports, {
2573    ReadonlyURLSearchParams: function() {
2574        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
2575    },
2576    RedirectType: function() {
2577        return RedirectType;
2578    },
2579    forbidden: function() {
2580        return _forbidden.forbidden;
2581    },
2582    notFound: function() {
2583        return _notfound.notFound;
2584    },
2585    permanentRedirect: function() {
2586        return _redirect.permanentRedirect;
2587    },
2588    redirect: function() {
2589        return _redirect.redirect;
2590    },
2591    unauthorized: function() {
2592        return _unauthorized.unauthorized;
2593    },
2594    unstable_isUnrecognizedActionError: function() {
2595        return unstable_isUnrecognizedActionError;
2596    },
2597    unstable_rethrow: function() {
2598        return _unstablerethrow.unstable_rethrow;
2599    }
2600});
2601const _readonlyurlsearchparams = __turbopack_context__.r(3680);
2602const _redirect = __turbopack_context__.r(24063);
2603const _notfound = __turbopack_context__.r(22783);
2604const _forbidden = __turbopack_context__.r(79854);
2605const _unauthorized = __turbopack_context__.r(22683);
2606const _unstablerethrow = __turbopack_context__.r(90508);
2607function unstable_isUnrecognizedActionError() {
2608    throw Object.defineProperty(new Error('`unstable_isUnrecognizedActionError` can only be used on the client.'), "__NEXT_ERROR_CODE", {
2609        value: "E776",
2610        enumerable: false,
2611        configurable: true
2612    });
2613}
2614const RedirectType = {
2615    push: 'push',
2616    replace: 'replace'
2617};
2618if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
2619    Object.defineProperty(exports.default, '__esModule', {
2620        value: true
2621    });
2622    Object.assign(exports.default, exports);
2623    module.exports = exports.default;
2624}
2625}),
262676562, ((__turbopack_context__, module, exports) => {
2627"use strict";
2628
2629var __TURBOPACK__imported__module__47167__ = /*#__PURE__*/ __turbopack_context__.i(47167);
2630"use strict";
2631Object.defineProperty(exports, "__esModule", {
2632    value: true
2633});
26340 && (module.exports = {
2635    ReadonlyURLSearchParams: null,
2636    RedirectType: null,
2637    ServerInsertedHTMLContext: null,
2638    forbidden: null,
2639    notFound: null,
2640    permanentRedirect: null,
2641    redirect: null,
2642    unauthorized: null,
2643    unstable_isUnrecognizedActionError: null,
2644    unstable_rethrow: null,
2645    useParams: null,
2646    usePathname: null,
2647    useRouter: null,
2648    useSearchParams: null,
2649    useSelectedLayoutSegment: null,
2650    useSelectedLayoutSegments: null,
2651    useServerInsertedHTML: null
2652});
2653function _export(target, all) {
2654    for(var name in all)Object.defineProperty(target, name, {
2655        enumerable: true,
2656        get: all[name]
2657    });
2658}
2659_export(exports, {
2660    // We need the same class that was used to instantiate the context value
2661    // Otherwise instanceof checks will fail in usercode
2662    ReadonlyURLSearchParams: function() {
2663        return _hooksclientcontextsharedruntime.ReadonlyURLSearchParams;
2664    },
2665    RedirectType: function() {
2666        return _navigationreactserver.RedirectType;
2667    },
2668    ServerInsertedHTMLContext: function() {
2669        return _serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext;
2670    },
2671    forbidden: function() {
2672        return _navigationreactserver.forbidden;
2673    },
2674    notFound: function() {
2675        return _navigationreactserver.notFound;
2676    },
2677    permanentRedirect: function() {
2678        return _navigationreactserver.permanentRedirect;
2679    },
2680    redirect: function() {
2681        return _navigationreactserver.redirect;
2682    },
2683    unauthorized: function() {
2684        return _navigationreactserver.unauthorized;
2685    },
2686    unstable_isUnrecognizedActionError: function() {
2687        return _unrecognizedactionerror.unstable_isUnrecognizedActionError;
2688    },
2689    unstable_rethrow: function() {
2690        return _navigationreactserver.unstable_rethrow;
2691    },
2692    useParams: function() {
2693        return useParams;
2694    },
2695    usePathname: function() {
2696        return usePathname;
2697    },
2698    useRouter: function() {
2699        return useRouter;
2700    },
2701    useSearchParams: function() {
2702        return useSearchParams;
2703    },
2704    useSelectedLayoutSegment: function() {
2705        return useSelectedLayoutSegment;
2706    },
2707    useSelectedLayoutSegments: function() {
2708        return useSelectedLayoutSegments;
2709    },
2710    useServerInsertedHTML: function() {
2711        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
2712    }
2713});
2714const _interop_require_wildcard = __turbopack_context__.r(90809);
2715const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(71645));
2716const _approutercontextsharedruntime = __turbopack_context__.r(8372);
2717const _hooksclientcontextsharedruntime = __turbopack_context__.r(61994);
2718const _segment = __turbopack_context__.r(13258);
2719const _serverinsertedhtmlsharedruntime = __turbopack_context__.r(13957);
2720const _unrecognizedactionerror = __turbopack_context__.r(92838);
2721const _navigationreactserver = __turbopack_context__.r(92805);

2722const useDynamicRouteParams = typeof window === 'undefined' ? __turbopack_context__.r(67673).useDynamicRouteParams : undefined;
2723const useDynamicSearchParams = typeof window === 'undefined' ? __turbopack_context__.r(67673).useDynamicSearchParams : undefined;
2724const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : {};
2725function useSearchParams() {
2726    useDynamicSearchParams?.('useSearchParams()');
2727    const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
2728    // In the case where this is `null`, the compat types added in
2729    // `next-env.d.ts` will add a new overload that changes the return type to
2730    // include `null`.
2731    const readonlySearchParams = (0, _react.useMemo)(()=>{
2732        if (!searchParams) {
2733            // When the router is not ready in pages, we won't have the search params
2734            // available.
2735            return null;
2736        }
2737        return new _hooksclientcontextsharedruntime.ReadonlyURLSearchParams(searchParams);
2738    }, [
2739        searchParams
2740    ]);
2741    // During build-time instant validation, wrap with an proxy
2742    // so that accessing undeclared search params throws an error.
2743    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2744    ;
2745    // Instrument with Suspense DevTools (dev-only)
2746    if (("TURBOPACK compile-time value", "development") !== 'production' && 'use' in _react.default) {
2747        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2748        if (navigationPromises) {
2749            return (0, _react.use)(navigationPromises.searchParams);
2750        }
2751    }
2752    return readonlySearchParams;
2753}
2754function usePathname() {
2755    useDynamicRouteParams?.('usePathname()');
2756    // In the case where this is `null`, the compat types added in `next-env.d.ts`
2757    // will add a new overload that changes the return type to include `null`.
2758    const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
2759    // During build-time instant validation, error if fallback params exist
2760    // because usePathname() can't return a sensible value without all params.
2761    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2762    ;
2763    // Instrument with Suspense DevTools (dev-only)
2764    if (("TURBOPACK compile-time value", "development") !== 'production' && 'use' in _react.default) {
2765        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2766        if (navigationPromises) {
2767            return (0, _react.use)(navigationPromises.pathname);
2768        }
2769    }
2770    return pathname;
2771}
2772function useRouter() {
2773    const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
2774    if (router === null) {
2775        throw Object.defineProperty(new Error('invariant expected app router to be mounted'), "__NEXT_ERROR_CODE", {
2776            value: "E238",
2777            enumerable: false,
2778            configurable: true
2779        });
2780    }
2781    return router;
2782}
2783function useParams() {
2784    useDynamicRouteParams?.('useParams()');
2785    const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
2786    // During build-time instant validation, wrap with a proxy
2787    // so that accessing undeclared params throws an error.
2788    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2789    ;
2790    // Instrument with Suspense DevTools (dev-only)
2791    if (("TURBOPACK compile-time value", "development") !== 'production' && 'use' in _react.default) {
2792        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2793        if (navigationPromises) {
2794            return (0, _react.use)(navigationPromises.params);
2795        }
2796    }
2797    return params;
2798}
2799function useSelectedLayoutSegments(parallelRouteKey = 'children') {
2800    useDynamicRouteParams?.('useSelectedLayoutSegments()');
2801    const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
2802    // @ts-expect-error This only happens in `pages`. Type is overwritten in navigation.d.ts
2803    if (!context) return null;
2804    // During build-time instant validation, error if fallback params exist
2805    // because useSelectedLayoutSegments() can't return a sensible value without all params.
2806    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2807    ;
2808    // Instrument with Suspense DevTools (dev-only)
2809    if (("TURBOPACK compile-time value", "development") !== 'production' && 'use' in _react.default) {
2810        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2811        if (navigationPromises) {
2812            const promise = navigationPromises.selectedLayoutSegmentsPromises?.get(parallelRouteKey);
2813            if (promise) {
2814                // We should always have a promise here, but if we don't, it's not worth erroring over.
2815                // We just won't be able to instrument it, but can still provide the value.
2816                return (0, _react.use)(promise);
2817            }
2818        }
2819    }
2820    return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
2821}
2822function useSelectedLayoutSegment(parallelRouteKey = 'children') {

2823    useDynamicRouteParams?.('useSelectedLayoutSegment()');
2824    const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2825    const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
2826    // During build-time instant validation, error if fallback params exist
2827    // because useSelectedLayoutSegment() can't return a sensible value without all params.
2828    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2829    ;
2830    // Instrument with Suspense DevTools (dev-only)
2831    if (("TURBOPACK compile-time value", "development") !== 'production' && navigationPromises && 'use' in _react.default) {
2832        const promise = navigationPromises.selectedLayoutSegmentPromises?.get(parallelRouteKey);
2833        if (promise) {
2834            // We should always have a promise here, but if we don't, it's not worth erroring over.
2835            // We just won't be able to instrument it, but can still provide the value.
2836            return (0, _react.use)(promise);
2837        }
2838    }
2839    return (0, _segment.computeSelectedLayoutSegment)(selectedLayoutSegments, parallelRouteKey);
2840}
2841if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
2842    Object.defineProperty(exports.default, '__esModule', {
2843        value: true
2844    });
2845    Object.assign(exports.default, exports);
2846    module.exports = exports.default;
2847}
2848}),
2849]);