https://diks.net/_next/static/chunks/27m1314j3xp61.js

1;!function(){try { var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof global?global:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&((e._debugIds|| (e._debugIds={}))[n]="4d467732-7a3a-0fc2-eb60-78e42c901741")}catch(e){}}();
2(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
3132061, ((__turbopack_context__, module, exports) => {
4"use strict";
5
6// This has to be a shared module which is shared between client component error boundary and dynamic component
7Object.defineProperty(exports, "__esModule", {
8    value: true
9});
100 && (module.exports = {
11    BailoutToCSRError: null,
12    isBailoutToCSRError: null
13});
14function _export(target, all) {
15    for(var name in all)Object.defineProperty(target, name, {
16        enumerable: true,
17        get: all[name]
18    });
19}
20_export(exports, {
21    BailoutToCSRError: function() {
22        return BailoutToCSRError;
23    },
24    isBailoutToCSRError: function() {
25        return isBailoutToCSRError;
26    }
27});
28const BAILOUT_TO_CSR = 'BAILOUT_TO_CLIENT_SIDE_RENDERING';
29class BailoutToCSRError extends Error {
30    constructor(reason){
31        super("Bail out to client-side rendering: ".concat(reason)), this.reason = reason, this.digest = BAILOUT_TO_CSR;
32    }
33}
34function isBailoutToCSRError(err) {
35    if (typeof err !== 'object' || err === null || !('digest' in err)) {
36        return false;
37    }
38    return err.digest === BAILOUT_TO_CSR;
39}
40}),
4113957, ((__turbopack_context__, module, exports) => {
42"use strict";
43
44Object.defineProperty(exports, "__esModule", {
45    value: true
46});
470 && (module.exports = {
48    ServerInsertedHTMLContext: null,
49    useServerInsertedHTML: null
50});
51function _export(target, all) {
52    for(var name in all)Object.defineProperty(target, name, {
53        enumerable: true,
54        get: all[name]
55    });
56}
57_export(exports, {
58    ServerInsertedHTMLContext: function() {
59        return ServerInsertedHTMLContext;
60    },
61    useServerInsertedHTML: function() {
62        return useServerInsertedHTML;
63    }
64});
65const _interop_require_wildcard = __turbopack_context__.r(151836);
66const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(271645));
67const ServerInsertedHTMLContext = /*#__PURE__*/ _react.default.createContext(null);
68function useServerInsertedHTML(callback) {
69    const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
70    // Should have no effects on client where there's no flush effects provider
71    if (addInsertedServerHTMLCallback) {
72        addInsertedServerHTMLCallback(callback);
73    }
74}
75}),
76222783, ((__turbopack_context__, module, exports) => {
77"use strict";
78
79Object.defineProperty(exports, "__esModule", {
80    value: true
81});
82Object.defineProperty(exports, "notFound", {
83    enumerable: true,
84    get: function() {
85        return notFound;
86    }
87});
88const _httpaccessfallback = __turbopack_context__.r(754394);
89/**
90 * This function allows you to render the [not-found.js file](https://nextjs.org/docs/app/api-reference/file-conventions/not-found)
91 * within a route segment as well as inject a tag.
92 *
93 * `notFound()` can be used in
94 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
95 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
96 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
97 *
98 * - In a Server Component, this will insert a `<meta name="robots" content="noindex" />` meta tag and set the status code to 404.
99 * - In a Route Handler or Server Action, it will serve a 404 to the caller.
100 *
101 * Read more: [Next.js Docs: `notFound`](https://nextjs.org/docs/app/api-reference/functions/not-found)
102 */ const DIGEST = "".concat(_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE, ";404");
103function notFound() {
104    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
105        value: "E1041",
106        enumerable: false,
107        configurable: true
108    });
109    error.digest = DIGEST;
110    throw error;
111}
112if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
113    Object.defineProperty(exports.default, '__esModule', {
114        value: true
115    });

116    Object.assign(exports.default, exports);
117    module.exports = exports.default;
118}
119}),
120879854, ((__turbopack_context__, module, exports) => {
121"use strict";
122
123var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167);
124"use strict";
125Object.defineProperty(exports, "__esModule", {
126    value: true
127});
128Object.defineProperty(exports, "forbidden", {
129    enumerable: true,
130    get: function() {
131        return forbidden;
132    }
133});
134const _httpaccessfallback = __turbopack_context__.r(754394);
135// TODO: Add `forbidden` docs
136/**
137 * @experimental
138 * This function allows you to render the [forbidden.js file](https://nextjs.org/docs/app/api-reference/file-conventions/forbidden)
139 * within a route segment as well as inject a tag.
140 *
141 * `forbidden()` can be used in
142 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
143 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
144 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
145 *
146 * Read more: [Next.js Docs: `forbidden`](https://nextjs.org/docs/app/api-reference/functions/forbidden)
147 */ const DIGEST = "".concat(_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE, ";403");
148function forbidden() {
149    if ("TURBOPACK compile-time truthy", 1) {
150        throw Object.defineProperty(new Error("`forbidden()` is experimental and only allowed to be enabled when `experimental.authInterrupts` is enabled."), "__NEXT_ERROR_CODE", {
151            value: "E488",
152            enumerable: false,
153            configurable: true
154        });
155    }
156    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
157        value: "E1019",
158        enumerable: false,
159        configurable: true
160    });
161    error.digest = DIGEST;
162    throw error;
163}
164if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
165    Object.defineProperty(exports.default, '__esModule', {
166        value: true
167    });
168    Object.assign(exports.default, exports);
169    module.exports = exports.default;
170}
171}),
172122683, ((__turbopack_context__, module, exports) => {
173"use strict";
174
175var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167);
176"use strict";
177Object.defineProperty(exports, "__esModule", {
178    value: true
179});
180Object.defineProperty(exports, "unauthorized", {
181    enumerable: true,
182    get: function() {
183        return unauthorized;
184    }
185});
186const _httpaccessfallback = __turbopack_context__.r(754394);
187// TODO: Add `unauthorized` docs
188/**
189 * @experimental
190 * This function allows you to render the [unauthorized.js file](https://nextjs.org/docs/app/api-reference/file-conventions/unauthorized)
191 * within a route segment as well as inject a tag.
192 *
193 * `unauthorized()` can be used in
194 * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
195 * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
196 * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
197 *
198 *
199 * Read more: [Next.js Docs: `unauthorized`](https://nextjs.org/docs/app/api-reference/functions/unauthorized)
200 */ const DIGEST = "".concat(_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE, ";401");
201function unauthorized() {
202    if ("TURBOPACK compile-time truthy", 1) {
203        throw Object.defineProperty(new Error("`unauthorized()` is experimental and only allowed to be used when `experimental.authInterrupts` is enabled."), "__NEXT_ERROR_CODE", {
204            value: "E411",
205            enumerable: false,
206            configurable: true
207        });
208    }
209    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
210        value: "E1002",
211        enumerable: false,
212        configurable: true
213    });
214    error.digest = DIGEST;
215    throw error;
216}
217if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
218    Object.defineProperty(exports.default, '__esModule', {
219        value: true
220    });

221    Object.assign(exports.default, exports);
222    module.exports = exports.default;
223}
224}),
225115507, ((__turbopack_context__, module, exports) => {
226"use strict";
227
228Object.defineProperty(exports, "__esModule", {
229    value: true
230});
231Object.defineProperty(exports, "unstable_rethrow", {
232    enumerable: true,
233    get: function() {
234        return unstable_rethrow;
235    }
236});
237const _bailouttocsr = __turbopack_context__.r(132061);
238const _isnextroutererror = __turbopack_context__.r(265713);
239function unstable_rethrow(error) {
240    if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error)) {
241        throw error;
242    }
243    if (error instanceof Error && 'cause' in error) {
244        unstable_rethrow(error.cause);
245    }
246}
247if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
248    Object.defineProperty(exports.default, '__esModule', {
249        value: true
250    });
251    Object.assign(exports.default, exports);
252    module.exports = exports.default;
253}
254}),
255963138, ((__turbopack_context__, module, exports) => {
256"use strict";
257
258Object.defineProperty(exports, "__esModule", {
259    value: true
260});
2610 && (module.exports = {
262    delayUntilRuntimeStage: null,
263    getRuntimeStage: null,
264    isHangingPromiseRejectionError: null,
265    makeDevtoolsIOAwarePromise: null,
266    makeHangingPromise: null
267});
268function _export(target, all) {
269    for(var name in all)Object.defineProperty(target, name, {
270        enumerable: true,
271        get: all[name]
272    });
273}
274_export(exports, {
275    delayUntilRuntimeStage: function() {
276        return delayUntilRuntimeStage;
277    },
278    getRuntimeStage: function() {
279        return getRuntimeStage;
280    },
281    isHangingPromiseRejectionError: function() {
282        return isHangingPromiseRejectionError;
283    },
284    makeDevtoolsIOAwarePromise: function() {
285        return makeDevtoolsIOAwarePromise;
286    },
287    makeHangingPromise: function() {
288        return makeHangingPromise;
289    }
290});
291const _stagedrendering = __turbopack_context__.r(142852);
292function isHangingPromiseRejectionError(err) {
293    if (typeof err !== 'object' || err === null || !('digest' in err)) {
294        return false;
295    }
296    return err.digest === HANGING_PROMISE_REJECTION;
297}
298const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION';
299class HangingPromiseRejectionError extends Error {
300    constructor(route, expression){
301        super("During prerendering, ".concat(expression, " rejects when the prerender is complete. Typically these errors are handled by React but if you move ").concat(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 "').concat(route, '".')), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
302    }
303}
304const abortListenersBySignal = new WeakMap();
305function makeHangingPromise(signal, route, expression) {
306    if (signal.aborted) {
307        return Promise.reject(new HangingPromiseRejectionError(route, expression));
308    } else {
309        const hangingPromise = new Promise((_, reject)=>{
310            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
311            let currentListeners = abortListenersBySignal.get(signal);
312            if (currentListeners) {
313                currentListeners.push(boundRejection);
314            } else {
315                const listeners = [
316                    boundRejection
317                ];
318                abortListenersBySignal.set(signal, listeners);
319                signal.addEventListener('abort', ()=>{
320                    for(let i = 0; i < listeners.length; i++){
321                        listeners[i]();
322                    }
323                }, {
324                    once: true
325                });
326            }
327        });
328        // We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
329        // we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
330        // your own promise out of it you'll need to ensure you handle the error when it rejects.
331        hangingPromise.catch(ignoreReject);
332        return hangingPromise;
333    }
334}
335function ignoreReject() {}
336function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
337    if (requestStore.stagedRendering) {
338        // We resolve each stage in a timeout, so React DevTools will pick this up as IO.

339        return requestStore.stagedRendering.delayUntilStage(stage, undefined, underlying);
340    }
341    // in React DevTools if we resolve in a setTimeout we will observe
342    // the promise resolution as something that can suspend a boundary or root.
343    return new Promise((resolve)=>{
344        // Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
345        setTimeout(()=>{
346            resolve(underlying);
347        }, 0);
348    });
349}
350function getRuntimeStage(stagedRendering) {
351    if (stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime) {
352        return _stagedrendering.RenderStage.EarlyRuntime;
353    }
354    return _stagedrendering.RenderStage.Runtime;
355}
356function delayUntilRuntimeStage(prerenderStore, result) {
357    const { stagedRendering } = prerenderStore;
358    if (!stagedRendering) {
359        return result;
360    }
361    return stagedRendering.waitForStage(getRuntimeStage(stagedRendering)).then(()=>result);
362}
363}),
364367287, ((__turbopack_context__, module, exports) => {
365"use strict";
366
367Object.defineProperty(exports, "__esModule", {
368    value: true
369});
370Object.defineProperty(exports, "isPostpone", {
371    enumerable: true,
372    get: function() {
373        return isPostpone;
374    }
375});
376const REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
377function isPostpone(error) {
378    return typeof error === 'object' && error !== null && error.$$typeof === REACT_POSTPONE_TYPE;
379}
380}),
381476353, ((__turbopack_context__, module, exports) => {
382"use strict";
383
384Object.defineProperty(exports, "__esModule", {
385    value: true
386});
3870 && (module.exports = {
388    DynamicServerError: null,
389    isDynamicServerError: null
390});
391function _export(target, all) {
392    for(var name in all)Object.defineProperty(target, name, {
393        enumerable: true,
394        get: all[name]
395    });
396}
397_export(exports, {
398    DynamicServerError: function() {
399        return DynamicServerError;
400    },
401    isDynamicServerError: function() {
402        return isDynamicServerError;
403    }
404});
405const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
406class DynamicServerError extends Error {
407    constructor(description){
408        super("Dynamic server usage: ".concat(description)), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
409    }
410}
411function isDynamicServerError(err) {
412    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
413        return false;
414    }
415    return err.digest === DYNAMIC_ERROR_CODE;
416}
417if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
418    Object.defineProperty(exports.default, '__esModule', {
419        value: true
420    });
421    Object.assign(exports.default, exports);
422    module.exports = exports.default;
423}
424}),
425643248, ((__turbopack_context__, module, exports) => {
426"use strict";
427
428Object.defineProperty(exports, "__esModule", {
429    value: true
430});
4310 && (module.exports = {
432    StaticGenBailoutError: null,
433    isStaticGenBailoutError: null
434});
435function _export(target, all) {
436    for(var name in all)Object.defineProperty(target, name, {
437        enumerable: true,
438        get: all[name]
439    });
440}
441_export(exports, {
442    StaticGenBailoutError: function() {
443        return StaticGenBailoutError;
444    },
445    isStaticGenBailoutError: function() {
446        return isStaticGenBailoutError;
447    }
448});
449const NEXT_STATIC_GEN_BAILOUT = 'NEXT_STATIC_GEN_BAILOUT';
450class StaticGenBailoutError extends Error {
451    constructor(...args){
452        super(...args), this.code = NEXT_STATIC_GEN_BAILOUT;
453    }
454}
455function isStaticGenBailoutError(error) {
456    if (typeof error !== 'object' || error === null || !('code' in error)) {
457        return false;
458    }
459    return error.code === NEXT_STATIC_GEN_BAILOUT;
460}
461if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
462    Object.defineProperty(exports.default, '__esModule', {
463        value: true
464    });

465    Object.assign(exports.default, exports);
466    module.exports = exports.default;
467}
468}),
469954839, ((__turbopack_context__, module, exports) => {
470"use strict";
471
472Object.defineProperty(exports, "__esModule", {
473    value: true
474});
4750 && (module.exports = {
476    METADATA_BOUNDARY_NAME: null,
477    OUTLET_BOUNDARY_NAME: null,
478    ROOT_LAYOUT_BOUNDARY_NAME: null,
479    VIEWPORT_BOUNDARY_NAME: null
480});
481function _export(target, all) {
482    for(var name in all)Object.defineProperty(target, name, {
483        enumerable: true,
484        get: all[name]
485    });
486}
487_export(exports, {
488    METADATA_BOUNDARY_NAME: function() {
489        return METADATA_BOUNDARY_NAME;
490    },
491    OUTLET_BOUNDARY_NAME: function() {
492        return OUTLET_BOUNDARY_NAME;
493    },
494    ROOT_LAYOUT_BOUNDARY_NAME: function() {
495        return ROOT_LAYOUT_BOUNDARY_NAME;
496    },
497    VIEWPORT_BOUNDARY_NAME: function() {
498        return VIEWPORT_BOUNDARY_NAME;
499    }
500});
501const METADATA_BOUNDARY_NAME = '__next_metadata_boundary__';
502const VIEWPORT_BOUNDARY_NAME = '__next_viewport_boundary__';
503const OUTLET_BOUNDARY_NAME = '__next_outlet_boundary__';
504const ROOT_LAYOUT_BOUNDARY_NAME = '__next_root_layout_boundary__';
505}),
506729419, ((__turbopack_context__, module, exports) => {
507"use strict";
508
509var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167);
510"use strict";
511Object.defineProperty(exports, "__esModule", {
512    value: true
513});
5140 && (module.exports = {
515    atLeastOneTask: null,
516    scheduleImmediate: null,
517    scheduleOnNextTick: null,
518    waitAtLeastOneReactRenderTask: null
519});
520function _export(target, all) {
521    for(var name in all)Object.defineProperty(target, name, {
522        enumerable: true,
523        get: all[name]
524    });
525}
526_export(exports, {
527    atLeastOneTask: function() {
528        return atLeastOneTask;
529    },
530    scheduleImmediate: function() {
531        return scheduleImmediate;
532    },
533    scheduleOnNextTick: function() {
534        return scheduleOnNextTick;
535    },
536    waitAtLeastOneReactRenderTask: function() {
537        return waitAtLeastOneReactRenderTask;
538    }
539});
540const scheduleOnNextTick = (cb)=>{
541    // We use Promise.resolve().then() here so that the operation is scheduled at
542    // the end of the promise job queue, we then add it to the next process tick
543    // to ensure it's evaluated afterwards.
544    //
545    // This was inspired by the implementation of the DataLoader interface: https://github.com/graphql/dataloader/blob/d336bd15282664e0be4b4a657cb796f09bafbc6b/src/index.js#L213-L255
546    //
547    Promise.resolve().then(()=>{
548        if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
549        ;
550        else {
551            __TURBOPACK__imported__module__247167__["default"].nextTick(cb);
552        }
553    });
554};
555const scheduleImmediate = (cb)=>{
556    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
557    ;
558    else {
559        setImmediate(cb);
560    }
561};
562function atLeastOneTask() {
563    return new Promise((resolve)=>scheduleImmediate(resolve));
564}
565function waitAtLeastOneReactRenderTask() {
566    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
567    ;
568    else {
569        return new Promise((r)=>setImmediate(r));
570    }
571}
572}),
573102897, ((__turbopack_context__, module, exports) => {
574"use strict";
575
576Object.defineProperty(exports, "__esModule", {
577    value: true
578});
579Object.defineProperty(exports, "INSTANT_VALIDATION_BOUNDARY_NAME", {
580    enumerable: true,
581    get: function() {
582        return INSTANT_VALIDATION_BOUNDARY_NAME;
583    }
584});
585const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
586}),
58767673, ((__turbopack_context__, module, exports) => {
588"use strict";
589
590var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167);
591/**
592 * The functions provided by this module are used to communicate certain properties
593 * about the currently running code so that Next.js can make decisions on how to handle
594 * the current execution in different rendering modes such as pre-rendering, resuming, and SSR.
595 *
596 * Today Next.js treats all code as potentially static. Certain APIs may only make sense when dynamically rendering.
597 * Traditionally this meant deopting the entire render to dynamic however with PPR we can now deopt parts
598 * of a React tree as dynamic while still keeping other parts static. There are really two different kinds of
599 * Dynamic indications.
600 *
601 * The first is simply an intention to be dynamic. unstable_noStore is an example of this where
602 * the currently executing code simply declares that the current scope is dynamic but if you use it
603 * inside unstable_cache it can still be cached. This type of indication can be removed if we ever
604 * make the default dynamic to begin with because the only way you would ever be static is inside
605 * a cache scope which this indication does not affect.
606 *
607 * The second is an indication that a dynamic data source was read. This is a stronger form of dynamic
608 * because it means that it is inappropriate to cache this at all. using a dynamic data source inside
609 * unstable_cache should error. If you want to use some dynamic data inside unstable_cache you should
610 * read that data outside the cache and pass it in as an argument to the cached function.
611 */ "use strict";
612Object.defineProperty(exports, "__esModule", {
613    value: true
614});
6150 && (module.exports = {
616    DynamicHoleKind: null,
617    Postpone: null,
618    PreludeState: null,
619    abortAndThrowOnSynchronousRequestDataAccess: null,

620    abortOnSynchronousPlatformIOAccess: null,
621    accessedDynamicData: null,
622    annotateDynamicAccess: null,
623    consumeDynamicAccess: null,
624    createDynamicTrackingState: null,
625    createDynamicValidationState: null,
626    createHangingInputAbortSignal: null,
627    createInstantValidationState: null,
628    createRenderInBrowserAbortSignal: null,
629    formatDynamicAPIAccesses: null,
630    getFirstDynamicReason: null,
631    getNavigationDisallowedDynamicReasons: null,
632    getStaticShellDisallowedDynamicReasons: null,
633    isDynamicPostpone: null,
634    isPrerenderInterruptedError: null,
635    logDisallowedDynamicError: null,
636    markCurrentScopeAsDynamic: null,
637    postponeWithTracking: null,
638    throwIfDisallowedDynamic: null,
639    throwToInterruptStaticGeneration: null,
640    trackAllowedDynamicAccess: null,
641    trackDynamicDataInDynamicRender: null,
642    trackDynamicHoleInNavigation: null,
643    trackDynamicHoleInRuntimeShell: null,
644    trackDynamicHoleInStaticShell: null,
645    trackThrownErrorInNavigation: null,
646    useDynamicRouteParam

646s: null,
647    useDynamicSearchParams: null
648});
649function _export(target, all) {
650    for(var name in all)Object.defineProperty(target, name, {
651        enumerable: true,
652        get: all[name]
653    });
654}
655_export(exports, {
656    DynamicHoleKind: function() {
657        return DynamicHoleKind;
658    },
659    Postpone: function() {
660        return Postpone;
661    },
662    PreludeState: function() {
663        return PreludeState;
664    },
665    abortAndThrowOnSynchronousRequestDataAccess: function() {
666        return abortAndThrowOnSynchronousRequestDataAccess;
667    },
668    abortOnSynchronousPlatformIOAccess: function() {
669        return abortOnSynchronousPlatformIOAccess;
670    },
671    accessedDynamicData: function() {
672        return accessedDynamicData;
673    },
674    annotateDynamicAccess: function() {
675        return annotateDynamicAccess;
676    },
677    consumeDynamicAccess: function() {
678        return consumeDynamicAccess;
679    },
680    createDynamicTrackingState: function() {
681        return createDynamicTrackingState;
682    },
683    createDynamicValidationState: function() {
684        return createDynamicValidationState;
685    },
686    createHangingInputAbortSignal: function() {
687        return createHangingInputAbortSignal;
688    },
689    createInstantValidationState: function() {
690        return createInstantValidationState;
691    },
692    createRenderInBrowserAbortSignal: function() {
693        return createRenderInBrowserAbortSignal;
694    },
695    formatDynamicAPIAccesses: function() {
696        return formatDynamicAPIAccesses;
697    },
698    getFirstDynamicReason: function() {
699        return getFirstDynamicReason;
700    },
701    getNavigationDisallowedDynamicReasons: function() {
702        return getNavigationDisallowedDynamicReasons;
703    },
704    getStaticShellDisallowedDynamicReasons: function() {
705        return getStaticShellDisallowedDynamicReasons;
706    },
707    isDynamicPostpone: function() {
708        return isDynamicPostpone;
709    },
710    isPrerenderInterruptedError: function() {
711        return isPrerenderInterruptedError;
712    },
713    logDisallowedDynamicError: function() {
714        return logDisallowedDynamicError;
715    },
716    markCurrentScopeAsDynamic: function() {
717        return markCurrentScopeAsDynamic;
718    },
719    postponeWithTracking: function() {
720        return postponeWithTracking;
721    },
722    throwIfDisallowedDynamic: function() {
723        return throwIfDisallowedDynamic;
724    },
725    throwToInterruptStaticGeneration: function() {
726        return throwToInterruptStaticGeneration;
727    },
728    trackAllowedDynamicAccess: function() {
729        return trackAllowedDynamicAccess;
730    },
731    trackDynamicDataInDynamicRender: function() {
732        return trackDynamicDataInDynamicRender;
733    },
734    trackDynamicHoleInNavigation: function() {
735        return trackDynamicHoleInNavigation;
736    },
737    trackDynamicHoleInRuntimeShell: function() {
738        return trackDynamicHoleInRuntimeShell;
739    },
740    trackDynamicHoleInStaticShell: function() {
741        return trackDynamicHoleInStaticShell;
742    },
743    trackThrownErrorInNavigation: function() {
744        return trackThrownErrorInNavigation;
745    },
746    useDynamicRouteParams: function() {
747        return useDynamicRouteParams;
748    },
749    useDynamicSearchParams: function() {
750        return useDynamicSearchParams;
751    }
752});
753const _react = /*#__PURE__*/ _interop_require_default(__turbopack_context__.r(271645));
754const _hooksservercontext = __turbopack_context__.r(476353);
755const _staticgenerationbailout = __turbopack_context__.r(643248);
756const _workunitasyncstorageexternal = __turbopack_context__.r(662141);
757const _workasyncstorageexternal = __turbopack_context__.r(563599);
758const _dynamicrenderingutils = __turbopack_context__.r(963138);
759const _boundaryconstants = __turbopack_context__.r(954839);
760const _scheduler = __turbopack_context__.r(729419);
761const _bailouttocsr = __turbopack_context__.r(132061);
762const _invarianterror = __turbopack_context__.r(312718);
763const _boundaryconstants1 = __turbopack_context__.r(102897);
764function _interop_require_default(obj) {
765    return obj && obj.__esModule ? obj : {
766        default: obj
767    };
768}
769const hasPostpone = typeof _react.default.unstable_postpone === 'function';
770function createDynamicTrackingState(isDebugDynamicAccesses) {
771    return {
772        isDebugDynamicAccesses,
773        dynamicAccesses: [],
774        syncDynamicErrorWithStack: null
775    };
776}
777function createDynamicValidationState() {
778    return {
779        hasSuspenseAboveBody: false,
780        hasDynamicMetadata: false,
781        dynamicMetadata: null,
782        hasDynamicViewport: false,

783        hasAllowedDynamic: false,
784        dynamicErrors: []
785    };
786}
787function getFirstDynamicReason(trackingState) {
788    var _trackingState_dynamicAccesses_;
789    return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
790}
791function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
792    if (workUnitStore) {
793        switch(workUnitStore.type){
794            case 'cache':
795            case 'unstable-cache':
796                // Inside cache scopes, marking a scope as dynamic has no effect,
797                // because the outer cache scope creates a cache boundary. This is
798                // subtly different from reading a dynamic data source, which is
799                // forbidden inside a cache scope.
800                return;
801            case 'private-cache':
802                // A private cache scope is already dynamic by definition.
803                return;
804            case 'prerender-legacy':
805            case 'prerender-ppr':
806            case 'request':
807            case 'generate-static-params':
808                break;
809            default:
810                workUnitStore;
811        }
812    }
813    // If we're forcing dynamic rendering or we're forcing static rendering, we
814    // don't need to do anything here because the entire page is already dynamic
815    // or it's static and it should not throw or postpone here.
816    if (store.forceDynamic || store.forceStatic) return;
817    if (store.dynamicShouldError) {
818        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError("Route ".concat(store.route, ' with `dynamic = "error"` couldn\'t be rendered statically because it used `').concat(expression, "`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering")), "__NEXT_ERROR_CODE", {
819            value: "E553",
820            enumerable: false,
821            configurable: true
822        });
823    }
824    if (workUnitStore) {
825        switch(workUnitStore.type){
826            case 'prerender-ppr':
827                return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
828            case 'prerender-legacy':
829                workUnitStore.revalidate = 0;
830                // We aren't prerendering, but we are generating a static page. We need
831                // to bail out of static generation.
832                const err = Object.defineProperty(new _hooksservercontext.DynamicServerError("Route ".concat(store.route, " couldn't be rendered statically because it used ").concat(expression, ". See more info here: https://nextjs.org/docs/messages/dynamic-server-error")), "__NEXT_ERROR_CODE", {
833                    value: "E550",
834                    enumerable: false,
835                    configurable: true
836                });
837                store.dynamicUsageDescription = expression;
838                store.dynamicUsageStack = err.stack;
839                throw err;
840            case 'request':
841                if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
842                ;
843                break;
844            case 'generate-static-params':
845                break;
846            default:
847                workUnitStore;
848        }
849    }
850}
851function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
852    // We aren't prerendering but we are generating a static page. We need to bail out of static generation
853    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError("Route ".concat(store.route, " couldn't be rendered statically because it used `").concat(expression, "`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error")), "__NEXT_ERROR_CODE", {
854        value: "E558",
855        enumerable: false,
856        configurable: true
857    });
858    prerenderStore.revalidate = 0;
859    store.dynamicUsageDescription = expression;
860    store.dynamicUsageStack = err.stack;
861    throw err;
862}
863function trackDynamicDataInDynamicRender(workUnitStore) {
864    switch(workUnitStore.type){
865        case 'cache':
866        case 'unstable-cache':
867            // Inside cache scopes, marking a scope as dynamic has no effect,
868            // because the outer cache scope creates a cache boundary. This is
869            // subtly different from reading a dynamic data source, which is
870            // forbidden inside a cache scope.
871            return;
872        case 'private-cache':
873            // A private cache scope is already dynamic by definition.
874            return;
875        case 'prerender':
876        case 'prerender-runtime':
877        case 'prerender-legacy':
878        case 'prerender-ppr':
879        case 'prerender-client':
880        case 'validation-client':
881        case 'generate-static-params':
882            break;
883        case 'request':
884            if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
885            ;
886            break;
887        default:
888            workUnitStore;
889    }
890}
891function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
892    const reason = "Route ".concat(route, " needs to bail out of prerendering at this point because it used ").concat(expression, ".");
893    const error = createPrerenderInterruptedError(reason);
894    prerenderStore.controller.abort(error);
895    const dynamicTracking = prerenderStore.dynamicTracking;
896    if (dynamicTracking) {
897        dynamicTracking.dynamicAccesses.push({
898            // When we aren't debugging, we don't need to create another error for the
899            // stack trace.
900            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
901            expression
902        });
903    }
904}

905function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
906    const dynamicTracking = prerenderStore.dynamicTracking;
907    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
908    // It is important that we set this tracking value after aborting. Aborts are executed
909    // synchronously except for the case where you abort during render itself. By setting this
910    // value late we can use it to determine if any of the aborted tasks are the task that
911    // called the sync IO expression in the first place.
912    if (dynamicTracking) {
913        if (dynamicTracking.syncDynamicErrorWithStack === null) {
914            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
915        }
916    }
917}
918function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
919    const prerenderSignal = prerenderStore.controller.signal;
920    if (prerenderSignal.aborted === false) {
921        // TODO it would be better to move this aborted check into the callsite so we can avoid making
922        // the error object when it isn't relevant to the aborting of the prerender however
923        // since we need the throw semantics regardless of whether we abort it is easier to land
924        // this way. See how this was handled with `abortOnSynchronousPlatformIOAccess` for a closer
925        // to ideal implementation
926        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
927        // It is important that we set this tracking value after aborting. Aborts are executed
928        // synchronously except for the case where you abort during render itself. By setting this
929        // value late we can use it to determine if any of the aborted tasks are the task that
930        // called the sync IO expression in the first place.
931        const dynamicTracking = prerenderStore.dynamicTracking;
932        if (dynamicTracking) {
933            if (dynamicTracking.syncDynamicErrorWithStack === null) {
934                dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
935            }
936        }
937    }
938    throw createPrerenderInterruptedError("Route ".concat(route, " needs to bail out of prerendering at this point because it used ").concat(expression, "."));
939}
940function Postpone(param) {
941    let { reason, route } = param;
942    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
943    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
944    postponeWithTracking(route, reason, dynamicTracking);
945}
946function postponeWithTracking(route, expression, dynamicTracking) {
947    assertPostpone();
948    if (dynamicTracking) {
949        dynamicTracking.dynamicAccesses.push({
950            // When we aren't debugging, we don't need to create another error for the
951            // stack trace.
952            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
953            expression
954        });
955    }
956    _react.default.unstable_postpone(createPostponeReason(route, expression));
957}
958function createPostponeReason(route, expression) {
959    return "Route ".concat(route, " needs to bail out of prerendering at this point because it used ").concat(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";
960}
961function isDynamicPostpone(err) {
962    if (typeof err === 'object' && err !== null && typeof err.message === 'string') {
963        return isDynamicPostponeReason(err.message);
964    }
965    return false;
966}
967function isDynamicPostponeReason(reason) {
968    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');
969}
970if (isDynamicPostponeReason(createPostponeReason('%%%', '^^^')) === false) {
971    throw Object.defineProperty(new Error('Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
972        value: "E296",
973        enumerable: false,
974        configurable: true
975    });
976}
977const NEXT_PRERENDER_INTERRUPTED = 'NEXT_PRERENDER_INTERRUPTED';
978function createPrerenderInterruptedError(message) {
979    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
980        value: "E394",
981        enumerable: false,
982        configurable: true
983    });
984    error.digest = NEXT_PRERENDER_INTERRUPTED;
985    return error;
986}
987function isPrerenderInterruptedError(error) {
988    return typeof error === 'object' && error !== null && error.digest === NEXT_PRERENDER_INTERRUPTED && 'name' in error && 'message' in error && error instanceof Error;
989}
990function accessedDynamicData(dynamicAccesses) {
991    return dynamicAccesses.length > 0;
992}
993function consumeDynamicAccess(serverDynamic, clientDynamic) {
994    // We mutate because we only call this once we are no longer writing
995    // to the dynamicTrackingState and it's more efficient than creating a new
996    // array.
997    serverDynamic.dynamicAccesses.push(...clientDynamic.dynamicAccesses);
998    return serverDynamic.dynamicAccesses;
999}
1000function formatDynamicAPIAccesses(dynamicAccesses) {
1001    return dynamicAccesses.filter((access)=>typeof access.stack === 'string' && access.stack.length > 0).map((param)=>{
1002        let { expression, stack } = param;
1003        stack = stack.split('\n') // Remove the "Error: " prefix from the first line of the stack trace as
1004        // well as the first 4 lines of the stack trace which is the distance

1005        // from the user code and the `new Error().stack` call.
1006        .slice(4).filter((line)=>{
1007            // Exclude Next.js internals from the stack trace.
1008            if (line.includes('node_modules/next/')) {
1009                return false;
1010            }
1011            // Exclude anonymous functions from the stack trace.
1012            if (line.includes(' (<anonymous>)')) {
1013                return false;
1014            }
1015            // Exclude Node.js internals from the stack trace.
1016            if (line.includes(' (node:')) {
1017                return false;
1018            }
1019            return true;
1020        }).join('\n');
1021        return "Dynamic API Usage Debug - ".concat(expression, ":\n").concat(stack);
1022    });
1023}
1024function assertPostpone() {
1025    if (!hasPostpone) {
1026        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", {
1027            value: "E224",
1028            enumerable: false,
1029            configurable: true
1030        });
1031    }
1032}
1033function createRenderInBrowserAbortSignal() {
1034    const controller = new AbortController();
1035    controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError('Render in Browser'), "__NEXT_ERROR_CODE", {
1036        value: "E721",
1037        enumerable: false,
1038        configurable: true
1039    }));
1040    return controller.signal;
1041}
1042function createHangingInputAbortSignal(workUnitStore) {
1043    switch(workUnitStore.type){
1044        case 'prerender':
1045        case 'prerender-runtime':
1046            const controller = new AbortController();
1047            if (workUnitStore.cacheSignal) {
1048                // If we have a cacheSignal it means we're in a prospective render. If
1049                // the input we're waiting on is coming from another cache, we do want
1050                // to wait for it so that we can resolve this cache entry too.
1051                workUnitStore.cacheSignal.inputReady().then(()=>{
1052                    controller.abort();
1053                });
1054            } else {
1055                // Otherwise we're in the final render and we should already have all
1056                // our caches filled.
1057                // If the prerender uses stages, we have wait until the runtime stage,
1058                // at which point all runtime inputs will be resolved.
1059                // (otherwise, a runtime prerender might consider `cookies()` hanging
1060                //  even though they'd resolve in the next task.)
1061                //
1062                // We might still be waiting on some microtasks so we
1063                // wait one tick before giving up. When we give up, we still want to
1064                // render the content of this cache as deeply as we can so that we can
1065                // suspend as deeply as possible in the tree or not at all if we don't
1066                // end up waiting for the input.
1067                if (workUnitStore.type === 'prerender-runtime' && workUnitStore.stagedRendering) {
1068                    const { stagedRendering } = workUnitStore;
1069                    stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering)).then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
1070                } else {
1071                    (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
1072                }
1073            }
1074            return controller.signal;
1075        case 'prerender-client':
1076        case 'validation-client':
1077        case 'prerender-ppr':
1078        case 'prerender-legacy':
1079        case 'request':
1080        case 'cache':
1081        case 'private-cache':
1082        case 'unstable-cache':
1083        case 'generate-static-params':
1084            return undefined;
1085        default:
1086            workUnitStore;
1087    }
1088}
1089function annotateDynamicAccess(expression, prerenderStore) {
1090    const dynamicTracking = prerenderStore.dynamicTracking;
1091    if (dynamicTracking) {
1092        dynamicTracking.dynamicAccesses.push({
1093            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
1094            expression
1095        });
1096    }
1097}

1098function useDynamicRouteParams(expression) {
1099    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
1100    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1101    if (workStore && workUnitStore) {
1102        switch(workUnitStore.type){
1103            case 'prerender-client':
1104            case 'prerender':
1105                {
1106                    const fallbackParams = workUnitStore.fallbackRouteParams;
1107                    if (fallbackParams && fallbackParams.size > 0) {
1108                        // We are in a prerender with cacheComponents semantics. We are going to
1109                        // hang here and never resolve. This will cause the currently
1110                        // rendering component to effectively be a dynamic hole.
1111                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
1112                    }
1113                    break;
1114                }
1115            case 'prerender-ppr':
1116                {
1117                    const fallbackParams = workUnitStore.fallbackRouteParams;
1118                    if (fallbackParams && fallbackParams.size > 0) {
1119                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
1120                    }
1121                    break;
1122                }
1123            case 'validation-client':
1124                {
1125                    break;
1126                }
1127            case 'prerender-runtime':
1128                throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called during a runtime prerender. Next.js should be preventing ").concat(expression, " from being included in server components statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1129                    value: "E771",
1130                    enumerable: false,
1131                    configurable: true
1132                });
1133            case 'cache':
1134            case 'private-cache':
1135                throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called inside a cache scope. Next.js should be preventing ").concat(expression, " from being included in server components statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1136                    value: "E745",
1137                    enumerable: false,
1138                    configurable: true
1139                });
1140            case 'generate-static-params':
1141                throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called in `generateStaticParams`. Next.js should be preventing ").concat(expression, " from being included in server component files statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1142                    value: "E1130",
1143                    enumerable: false,
1144                    configurable: true
1145                });
1146            case 'prerender-legacy':
1147            case 'request':
1148            case 'unstable-cache':
1149                break;
1150            default:
1151                workUnitStore;
1152        }
1153    }
1154}
1155function useDynamicSearchParams(expression) {
1156    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
1157    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1158    if (!workStore) {
1159        // We assume pages router context and just return
1160        return;
1161    }
1162    if (!workUnitStore) {
1163        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
1164    }
1165    switch(workUnitStore.type){
1166        case 'validation-client':
1167            // During instant validation we try to behave as close to client as possible,
1168            // so this shouldn't hang during SSR.
1169            return;
1170        case 'prerender-client':
1171            {
1172                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
1173                break;
1174            }
1175        case 'prerender-legacy':
1176        case 'prerender-ppr':
1177            {
1178                if (workStore.forceStatic) {
1179                    return;
1180                }
1181                throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(expression), "__NEXT_ERROR_CODE", {
1182                    value: "E394",
1183                    enumerable: false,
1184                    configurable: true
1185                });
1186            }
1187        case 'prerender':
1188        case 'prerender-runtime':
1189            throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called from a Server Component. Next.js should be preventing ").concat(expression, " from being included in server components statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1190                value: "E795",
1191                enumerable: false,
1192                configurable: true
1193            });
1194        case 'cache':
1195        case 'unstable-cache':
1196        case 'private-cache':
1197            throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called 

1197inside a cache scope. Next.js should be preventing ").concat(expression, " from being included in server components statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1198                value: "E745",
1199                enumerable: false,
1200                configurable: true
1201            });
1202        case 'generate-static-params':
1203            throw Object.defineProperty(new _invarianterror.InvariantError("`".concat(expression, "` was called in `generateStaticParams`. Next.js should be preventing ").concat(expression, " from being included in server component files statically, but did not in this case.")), "__NEXT_ERROR_CODE", {
1204                value: "E1130",
1205                enumerable: false,
1206                configurable: true
1207            });
1208        case 'request':
1209            return;
1210        default:
1211            workUnitStore;
1212    }
1213}
1214const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
1215// Common implicit body tags that React will treat as body when placed directly in html
1216const bodyAndImplicitTags = 'body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6';
1217// Detects when RootLayoutBoundary (our framework marker component) appears
1218// after Suspense in the component stack, indicating the root layout is wrapped
1219// within a Suspense boundary. Ensures no body/html/implicit-body components are in between.
1220//
1221// Example matches:
1222//   at Suspense (<anonymous>)
1223//   at __next_root_layout_boundary__ (<anonymous>)
1224//
1225// Or with other components in between (but not body/html/implicit-body):
1226//   at Suspense (<anonymous>)
1227//   at SomeComponent (<anonymous>)
1228//   at __next_root_layout_boundary__ (<anonymous>)
1229const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp("\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:".concat(bodyAndImplicitTags, ") \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ").concat(_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME, " \\([^\\n]*\\)"));
1230const hasMetadataRegex = new RegExp("\\n\\s+at ".concat(_boundaryconstants.METADATA_BOUNDARY_NAME, "[\\n\\s]"));
1231const hasViewportRegex = new RegExp("\\n\\s+at ".concat(_boundaryconstants.VIEWPORT_BOUNDARY_NAME, "[\\n\\s]"));
1232const hasOutletRegex = new RegExp("\\n\\s+at ".concat(_boundaryconstants.OUTLET_BOUNDARY_NAME, "[\\n\\s]"));
1233const hasInstantValidationBoundaryRegex = new RegExp("\\n\\s+at ".concat(_boundaryconstants1.INSTANT_VALIDATION_BOUNDARY_NAME, "[\\n\\s]"));
1234function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
1235    if (hasOutletRegex.test(componentStack)) {
1236        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
1237        return;
1238    } else if (hasMetadataRegex.test(componentStack)) {
1239        dynamicValidation.hasDynamicMetadata = true;
1240        return;
1241    } else if (hasViewportRegex.test(componentStack)) {
1242        dynamicValidation.hasDynamicViewport = true;
1243        return;
1244    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
1245        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
1246        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
1247        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
1248        dynamicValidation.hasAllowedDynamic = true;
1249        dynamicValidation.hasSuspenseAboveBody = true;
1250        return;
1251    } else if (hasSuspenseRegex.test(componentStack)) {
1252        // this error had a Suspense boundary above it so we don't need to report it as a source
1253        // of disallowed
1254        dynamicValidation.hasAllowedDynamic = true;
1255        return;
1256    } else if (clientDynamic.syncDynamicErrorWithStack) {
1257        // This task was the task that called the sync error.
1258        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
1259        return;
1260    } else {
1261        const message = 'Route "'.concat(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';
1262        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1263            value: "E1079",
1264            enumerable: false,
1265            configurable: true
1266        }), componentStack, null);
1267        dynamicValidation.dynamicErrors.push(error);
1268        return;
1269    }
1270}
1271var DynamicHoleKind = /*#__PURE__*/ function(DynamicHoleKind) {
1272    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 1] = "Runtime";
1273    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 2] = "Dynamic";
1274    return DynamicHoleKind;
1275}({});
1276function createInstantValidationState(createInstantStack) {
1277    return {
1278        hasDynamicMetadata: false,
1279        hasAllowedClientDynamicAboveBoundary: false,
1280        dynamicMetadata: null,
1281        hasDynamicViewport: false,

1282        hasAllowedDynamic: false,
1283        dynamicErrors: [],
1284        validationPreventingErrors: [],
1285        thrownErrorsOutsideBoundary: [],
1286        createInstantStack
1287    };
1288}
1289function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
1290    if (hasOutletRegex.test(componentStack)) {
1291        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
1292        return;
1293    }
1294    if (hasMetadataRegex.test(componentStack)) {
1295        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`.";
1296        const message = 'Route "'.concat(workStore.route, '": ').concat(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");
1297        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1298            value: "E1076",
1299            enumerable: false,
1300            configurable: true
1301        }), componentStack, dynamicValidation.createInstantStack);
1302        dynamicValidation.dynamicMetadata = error;
1303        return;
1304    }
1305    if (hasViewportRegex.test(componentStack)) {
1306        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`.";
1307        const message = 'Route "'.concat(workStore.route, '": ').concat(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");
1308        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1309            value: "E1086",
1310            enumerable: false,
1311            configurable: true
1312        }), componentStack, dynamicValidation.createInstantStack);
1313        dynamicValidation.dynamicErrors.push(error);
1314        return;
1315    }
1316    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
1317    if (!boundaryLocation) {
1318        // We don't see the validation boundary in the component stack,
1319        // so this hole must be coming from a shared parent.
1320        // Shared parents are fully resolved and don't have RSC holes,
1321        // but they can still suspend in a client component during SSR.
1322        // If we managed to render all the validation boundaries, that means
1323        // that the client holes aren't blocking validation and we can disregard them.
1324        // Note that we don't even care whether they have suspense or not.
1325        if (boundaryState.expectedIds.size === boundaryState.renderedIds.size) {
1326            dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
1327            dynamicValidation.hasAllowedDynamic = true // Holes outside the boundary contribute to allowing dynamic metadata
1328            ;
1329            return;
1330        } else {
1331            // TODO(instant-validation) TODO(NAR-787)
1332            // If shared parents blocked us from validating, we should only log
1333            // the errors from the innermost (segments), i.e. omit layouts whose
1334            // slots managed to render (because clearly they didn't block validation)
1335            const message = 'Route "'.concat(workStore.route, '": Could not validate `unstable_instant` because a Client Component in a parent segment prevented the page from rendering.');
1336            const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1337                value: "E1082",
1338                enumerable: false,
1339                configurable: true
1340            }), componentStack, dynamicValidation.createInstantStack);
1341            dynamicValidation.validationPreventingErrors.push(error);
1342            return;
1343        }
1344    } else {
1345        // The hole originates inside the validation boundary.
1346        //
1347        // Check if we have a Suspense above the hole, but below the validation boundary.

1348        // If we do, then this dynamic usage wouldn't block a navigation to this subtree.
1349        // Conversely, if the nearest suspense is above the validation boundary, then this subtree would block.
1350        //
1351        // Note that in the component stack, children come before parents.
1352        //
1353        // Valid:
1354        //   ...
1355        //   at Suspense
1356        //   ...
1357        //   at __next_prefetch_validation_boundary__
1358        //
1359        // Invalid:
1360        //   ...
1361        //   at __next_prefetch_validation_boundary__
1362        //   ...
1363        //   at Suspense
1364        //
1365        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
1366        if (suspenseLocation) {
1367            if (suspenseLocation.index < boundaryLocation.index) {
1368                dynamicValidation.hasAllowedDynamic = true;
1369                return;
1370            } else {
1371            // invalid - fallthrough
1372            }
1373        }
1374    }
1375    if (clientDynamic.syncDynamicErrorWithStack) {
1376        // This task was the task that called the sync error.
1377        const syncError = clientDynamic.syncDynamicErrorWithStack;
1378        if (dynamicValidation.createInstantStack !== null && syncError.cause === undefined) {
1379            syncError.cause = dynamicValidation.createInstantStack();
1380        }
1381        dynamicValidation.dynamicErrors.push(syncError);
1382        return;
1383    }
1384    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>`.";
1385    const message = 'Route "'.concat(workStore.route, '": ').concat(usageDescription, " This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route");
1386    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1387        value: "E1078",
1388        enumerable: false,
1389        configurable: true
1390    }), componentStack, dynamicValidation.createInstantStack);
1391    dynamicValidation.dynamicErrors.push(error);
1392    return;
1393}
1394function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack) {
1395    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
1396    if (!boundaryLocation) {
1397        // There's no validation boundary on the component stack.
1398        // This error may have blocked a boundary from rendering.
1399        // Wrap the error to provide component context.
1400        // This helps for errors from node_modules which would otherwise
1401        // have no useful stack information due to ignore-listing,
1402        // e.g. next/dynamic with `ssr: false`.
1403        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.', {
1404            cause: thrownValue
1405        }), "__NEXT_ERROR_CODE", {
1406            value: "E1118",
1407            enumerable: false,
1408            configurable: true
1409        }), componentStack, null);
1410        dynamicValidation.thrownErrorsOutsideBoundary.push(error);
1411    } else {
1412        // There's validation boundary on the component stack,
1413        // so we know this error didn't block a validation boundary from rendering.
1414        // However, this error might be hiding be hiding dynamic content that would
1415        // cause validation to fail.
1416        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
1417        if (suspenseLocation) {
1418            if (suspenseLocation.index < boundaryLocation.index) {
1419                // There's a Suspense below the validation boundary but above this error's location.
1420                // This subtree can't fail instant validation because any potential
1421                // dynamic holes would be guarded by the Suspense anyway,
1422                // so we can allow this.
1423                return;
1424            } else {
1425            // invalid - fallthrough
1426            }
1427        }
1428        const message = 'Route "'.concat(workStore.route, '": Could not val

1428idate `unstable_instant` because an error prevented the target segment from rendering.');
1429        const error = addErrorContext(Object.defineProperty(new Error(message, {
1430            cause: thrownValue
1431        }), "__NEXT_ERROR_CODE", {
1432            value: "E1112",
1433            enumerable: false,
1434            configurable: true
1435        }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
1436        );
1437        dynamicValidation.validationPreventingErrors.push(error);
1438    }
1439}
1440function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
1441    if (hasOutletRegex.test(componentStack)) {
1442        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
1443        return;
1444    } else if (hasMetadataRegex.test(componentStack)) {
1445        const message = 'Route "'.concat(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');
1446        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1447            value: "E1080",
1448            enumerable: false,
1449            configurable: true
1450        }), componentStack, null);
1451        dynamicValidation.dynamicMetadata = error;
1452        return;
1453    } else if (hasViewportRegex.test(componentStack)) {
1454        // TODO(instant-validation): If the page only has holes caused by runtime data,
1455        // we won't find out if there's a suspense-above-body and error for dynamic viewport
1456        // even if there is in fact a suspense-above-body
1457        const message = 'Route "'.concat(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');
1458        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1459            value: "E1077",
1460            enumerable: false,
1461            configurable: true
1462        }), componentStack, null);
1463        dynamicValidation.dynamicErrors.push(error);
1464        return;
1465    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
1466        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
1467        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
1468        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
1469        dynamicValidation.hasAllowedDynamic = true;
1470        dynamicValidation.hasSuspenseAboveBody = true;
1471        return;
1472    } else if (hasSuspenseRegex.test(componentStack)) {
1473        // this error had a Suspense boundary above it so we don't need to report it as a source
1474        // of disallowed
1475        dynamicValidation.hasAllowedDynamic = true;
1476        return;
1477    } else if (clientDynamic.syncDynamicErrorWithStack) {
1478        // This task was the task that called the sync error.
1479        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
1480        return;
1481    }
1482    const message = 'Route "'.concat(workStore.route, '": Uncached data or `connection()` 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');
1483    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1484        value: "E1084",
1485        enumerable: false,
1486        configurable: true
1487    }), componentStack, null);
1488    dynamicValidation.dynamicErrors.push(error);
1489    return;
1490}
1491function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
1492    if (hasOutletRegex.test(componentStack)) {
1493        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
1494        return;
1495    } else if (hasMetadataRegex.test(componentStack)) {
1496        const message = 'Route "'.concat(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');
1497        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1498            value: "E1085",
1499            enumerable: false,
1500            configurable: true
1501        }), componentStack, null);
1502        dynamicValidation.dynamicMetadata = error;
1503        return;
1504    } else if (hasViewportRegex.test(componentStack)) {
1505        const message = 'Route "'.concat(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');
1506        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1507            value: "E1081",
1508            enumerable: false,
1509            configurable: true
1510        }), componentStack, null);
1511        dynamicValidation.dynamicErrors.push(error);
1512        return;
1513    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
1514        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
1515        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
1516        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
1517        dynamicValidation.hasAllowedDynamic = true;
1518        dynamicValidation.hasSuspenseAboveBody = true;
1519        return;
1520    } else if (hasSuspenseRegex.test(componentStack)) {
1521        // this error had a Suspense boundary above it so we don't need to report it as a source
1522        // of disallowed
1523        dynamicValidation.hasAllowedDynamic = true;
1524        return;
1525    } else if (clientDynamic.syncDynamicErrorWithStack) {
1526        // This task was the task that called the sync error.
1527        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
1528        return;
1529    } else {
1530        const message = 'Route "'.concat(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');
1531        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
1532            value: "E1083",
1533            enumerable: false,
1534            configurable: true
1535        }), componentStack, null);
1536        dynamicValidation.dynamicErrors.push(error);
1537        return;
1538    }
1539}
1540/**
1541 * In dev mode, we prefer using the owner stack, otherwise the provided

1542 * component stack is used.
1543 *
1544 * Accepts an already-created Error so the SWC error-code plugin can see the
1545 * `new Error(...)` call at each call site and auto-assign error codes.
1546 */ function addErrorContext(error, componentStack, createInstantStack) {
1547    const ownerStack = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : null;
1548    if (createInstantStack !== null) {
1549        error.cause = createInstantStack();
1550    }
1551    // TODO go back to owner stack here if available. This is temporarily using componentStack to get the right
1552    //
1553    error.stack = error.name + ': ' + error.message + (ownerStack || componentStack);
1554    return error;
1555}
1556var PreludeState = /*#__PURE__*/ function(PreludeState) {
1557    PreludeState[PreludeState["Full"] = 0] = "Full";
1558    PreludeState[PreludeState["Empty"] = 1] = "Empty";
1559    PreludeState[PreludeState["Errored"] = 2] = "Errored";
1560    return PreludeState;
1561}({});
1562function logDisallowedDynamicError(workStore, error) {
1563    console.error(error);
1564    if ("TURBOPACK compile-time truthy", 1) {
1565        console.error('To get a more detailed stack trace and pinpoint the issue, try one of the following:\n  - Start the app in development mode by running `next dev`, then open "'.concat(workStore.route, '" in your browser to investigate the error.\n  - Rerun the production build with `next build --debug-prerender` to generate better stack traces.'));
1566    } else //TURBOPACK unreachable
1567    ;
1568}
1569function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
1570    if (serverDynamic.syncDynamicErrorWithStack) {
1571        logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
1572        throw new _staticgenerationbailout.StaticGenBailoutError();
1573    }
1574    if (prelude !== 0) {
1575        if (dynamicValidation.hasSuspenseAboveBody) {
1576            // This route has opted into allowing fully dynamic rendering
1577            // by including a Suspense boundary above the body. In this case
1578            // a lack of a shell is not considered disallowed so we simply return
1579            return;
1580        }
1581        // We didn't have any sync bailouts but there may be user code which
1582        // blocked the root. We would have captured these during the prerender
1583        // and can log them here and then terminate the build/validating render
1584        const dynamicErrors = dynamicValidation.dynamicErrors;
1585        if (dynamicErrors.length > 0) {
1586            for(let i = 0; i < dynamicErrors.length; i++){
1587                logDisallowedDynamicError(workStore, dynamicErrors[i]);
1588            }
1589            throw new _staticgenerationbailout.StaticGenBailoutError();
1590        }
1591        // If we got this far then the only other thing that could be blocking
1592        // the root is dynamic Viewport. If this is dynamic then
1593        // you need to opt into that by adding a Suspense boundary above the body
1594        // to indicate your are ok with fully dynamic rendering.
1595        if (dynamicValidation.hasDynamicViewport) {
1596            console.error('Route "'.concat(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'));
1597            throw new _staticgenerationbailout.StaticGenBailoutError();
1598        }
1599        if (prelude === 1) {
1600            // If we ever get this far then we messed up the tracking of invalid dynamic.
1601            // We still adhere to the constraint that you must produce a shell but invite the
1602            // user to report this as a bug in Next.js.
1603            console.error('Route "'.concat(workStore.route, '" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.'));
1604            throw new _staticgenerationbailout.StaticGenBailoutError();
1605        }
1606    } else {
1607        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
1608            console.error('Route "'.concat(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'));
1609            throw new _staticgenerationbailout.StaticGenBailoutError();
1610        }
1611    }
1612}
1613function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, configAllowsBlocking) {
1614    if (configAllowsBlocking || dynamicValidation.hasSuspenseAboveBody) {

1615        // This route has opted into allowing fully dynamic rendering
1616        // by including a Suspense boundary above the body. In this case
1617        // a lack of a shell is not considered disallowed so we simply return
1618        return [];
1619    }
1620    if (prelude !== 0) {
1621        // We didn't have any sync bailouts but there may be user code which
1622        // blocked the root. We would have captured these during the prerender
1623        // and can log them here and then terminate the build/validating render
1624        const dynamicErrors = dynamicValidation.dynamicErrors;
1625        if (dynamicErrors.length > 0) {
1626            return dynamicErrors;
1627        }
1628        if (prelude === 1) {
1629            // If we ever get this far then we messed up the tracking of invalid dynamic.
1630            // We still adhere to the constraint that you must produce a shell but invite the
1631            // user to report this as a bug in Next.js.
1632            return [
1633                Object.defineProperty(new _invarianterror.InvariantError('Route "'.concat(workStore.route, '" did not produce a static shell and Next.js was unable to determine a reason.')), "__NEXT_ERROR_CODE", {
1634                    value: "E936",
1635                    enumerable: false,
1636                    configurable: true
1637                })
1638            ];
1639        }
1640    } else {
1641        // We have a prelude but we might still have dynamic metadata without any other dynamic access
1642        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
1643            return [
1644                dynamicValidation.dynamicMetadata
1645            ];
1646        }
1647    }
1648    // We had a non-empty prelude and there are no dynamic holes
1649    return [];
1650}
1651function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
1652    // If we have errors related to missing samples, those should take precedence over everything else.
1653    if (validationSampleTracking) {
1654        const { missingSampleErrors } = validationSampleTracking;
1655        if (missingSampleErrors.length > 0) {
1656            return missingSampleErrors;
1657        }
1658    }
1659    const { validationPreventingErrors } = dynamicValidation;
1660    if (validationPreventingErrors.length > 0) {
1661        return validationPreventingErrors;
1662    }
1663    if (boundaryState.renderedIds.size < boundaryState.expectedIds.size) {
1664        const { thrownErrorsOutsideBoundary, createInstantStack } = dynamicValidation;
1665        if (thrownErrorsOutsideBoundary.length === 0) {
1666            const message = 'Route "'.concat(workStore.route, '": Could not validate `unstable_instant` because the target segment was prevented from rendering for an unknown reason.');
1667            const error = createInstantStack !== null ? createInstantStack() : new Error();
1668            error.name = 'Error';
1669            error.message = message;
1670            return [
1671                error
1672            ];
1673        } else if (thrownErrorsOutsideBoundary.length === 1) {
1674            const message = 'Route "'.concat(workStore.route, '": Could not validate `unstable_instant` because the target segment was prevented from rendering, likely due to the following error.');
1675            const error = createInstantStack !== null ? createInstantStack() : new Error();
1676            error.name = 'Error';
1677            error.message = message;
1678            return [
1679                error,
1680                thrownErrorsOutsideBoundary[0]
1681            ];
1682        } else {
1683            const message = 'Route "'.concat(workStore.route, '": Could not validate `unstable_instant` because the target segment was prevented from rendering, likely due to one of the following errors.');
1684            const error = createInstantStack !== null ? createInstantStack() : new Error();
1685            error.name = 'Error';
1686            error.message = message;
1687            return [
1688                error,
1689                ...thrownErrorsOutsideBoundary
1690            ];
1691        }
1692    }
1693    // NOTE: We don't care about Suspense above body here,
1694    // we're only concerned with the validation boundary
1695    if (prelude !== 0) {
1696        const dynamicErrors = dynamicValidation.dynamicErrors;
1697        if (dynamicErrors.length > 0) {
1698            return dynamicErrors;
1699        }
1700        if (prelude === 1) {
1701            // If a client component suspended prevented us from rendering a shell
1702            // but didn't block validation, we don't require a prelude.
1703            if (dynamicValidation.hasAllowedClientDynamicAboveBoundary) {
1704                return [];
1705            }
1706            // If we ever get this far then we messed up the tracking of invalid dynamic.
1707            return [
1708                Object.defineProperty(new _invarianterror.InvariantError('Route "'.concat(workStore.route, '" failed to render during instant validation and Next.js was unable to determine a reason.')), "__NEXT_ERROR_CODE", {
1709                    value: "E1055",
1710                    enumerable: false,
1711                    configurable: true
1712                })
1713            ];
1714        }
1715    } else {
1716        const dynamicErrors = dynamicValidation.dynamicErrors;
1717        if (dynamicErrors.length > 0) {
1718            return dynamicErrors;
1719        }
1720        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicMetadata) {
1721            return [
1722                dynamicValidation.dynamicMetadata
1723            ];
1724        }
1725    }
1726    // We had a non-empty prelude and there are no dynamic holes
1727    return [];
1728}
1729}),

1730891414, ((__turbopack_context__, module, exports) => {
1731"use strict";
1732
1733Object.defineProperty(exports, "__esModule", {
1734    value: true
1735});
1736Object.defineProperty(exports, "unstable_rethrow", {
1737    enumerable: true,
1738    get: function() {
1739        return unstable_rethrow;
1740    }
1741});
1742const _dynamicrenderingutils = __turbopack_context__.r(963138);
1743const _ispostpone = __turbopack_context__.r(367287);
1744const _bailouttocsr = __turbopack_context__.r(132061);
1745const _isnextroutererror = __turbopack_context__.r(265713);
1746const _dynamicrendering = __turbopack_context__.r(67673);
1747const _hooksservercontext = __turbopack_context__.r(476353);
1748function unstable_rethrow(error) {
1749    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)) {
1750        throw error;
1751    }
1752    if (error instanceof Error && 'cause' in error) {
1753        unstable_rethrow(error.cause);
1754    }
1755}
1756if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1757    Object.defineProperty(exports.default, '__esModule', {
1758        value: true
1759    });
1760    Object.assign(exports.default, exports);
1761    module.exports = exports.default;
1762}
1763}),
1764490508, ((__turbopack_context__, module, exports) => {
1765"use strict";
1766
1767/**
1768 * This function should be used to rethrow internal Next.js errors so that they can be handled by the framework.
1769 * When wrapping an API that uses errors to interrupt control flow, you should use this function before you do any error handling.
1770 * This function will rethrow the error if it is a Next.js error so it can be handled, otherwise it will do nothing.
1771 *
1772 * Read more: [Next.js Docs: `unstable_rethrow`](https://nextjs.org/docs/app/api-reference/functions/unstable_rethrow)
1773 */ Object.defineProperty(exports, "__esModule", {
1774    value: true
1775});
1776Object.defineProperty(exports, "unstable_rethrow", {
1777    enumerable: true,
1778    get: function() {
1779        return unstable_rethrow;
1780    }
1781});
1782const unstable_rethrow = typeof window === 'undefined' ? __turbopack_context__.r(891414).unstable_rethrow : __turbopack_context__.r(115507).unstable_rethrow;
1783if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1784    Object.defineProperty(exports.default, '__esModule', {
1785        value: true
1786    });
1787    Object.assign(exports.default, exports);
1788    module.exports = exports.default;
1789}
1790}),
1791592805, ((__turbopack_context__, module, exports) => {
1792"use strict";
1793
1794Object.defineProperty(exports, "__esModule", {
1795    value: true
1796});
17970 && (module.exports = {
1798    ReadonlyURLSearchParams: null,
1799    RedirectType: null,
1800    forbidden: null,
1801    notFound: null,
1802    permanentRedirect: null,
1803    redirect: null,
1804    unauthorized: null,
1805    unstable_isUnrecognizedActionError: null,
1806    unstable_rethrow: null
1807});
1808function _export(target, all) {
1809    for(var name in all)Object.defineProperty(target, name, {
1810        enumerable: true,
1811        get: all[name]
1812    });
1813}
1814_export(exports, {
1815    ReadonlyURLSearchParams: function() {
1816        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
1817    },
1818    RedirectType: function() {
1819        return RedirectType;
1820    },
1821    forbidden: function() {
1822        return _forbidden.forbidden;
1823    },
1824    notFound: function() {
1825        return _notfound.notFound;
1826    },
1827    permanentRedirect: function() {
1828        return _redirect.permanentRedirect;
1829    },
1830    redirect: function() {
1831        return _redirect.redirect;
1832    },
1833    unauthorized: function() {
1834        return _unauthorized.unauthorized;
1835    },
1836    unstable_isUnrecognizedActionError: function() {
1837        return unstable_isUnrecognizedActionError;
1838    },
1839    unstable_rethrow: function() {
1840        return _unstablerethrow.unstable_rethrow;
1841    }
1842});
1843const _readonlyurlsearchparams = __turbopack_context__.r(903680);
1844const _redirect = __turbopack_context__.r(124063);
1845const _notfound = __turbopack_context__.r(222783);
1846const _forbidden = __turbopack_context__.r(879854);
1847const _unauthorized = __turbopack_context__.r(122683);
1848const _unstablerethrow = __turbopack_context__.r(490508);
1849function unstable_isUnrecognizedActionError() {
1850    throw Object.defineProperty(new Error('`unstable_isUnrecognizedActionError` can only be used on the client.'), "__NEXT_ERROR_CODE", {
1851        value: "E776",
1852        enumerable: false,
1853        configurable: true
1854    });
1855}
1856const RedirectType = {
1857    push: 'push',
1858    replace: 'replace'
1859};
1860if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1861    Object.defineProperty(exports.default, '__esModule', {
1862        value: true
1863    });

1864    Object.assign(exports.default, exports);
1865    module.exports = exports.default;
1866}
1867}),
1868976562, ((__turbopack_context__, module, exports) => {
1869"use strict";
1870
1871var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167);
1872"use strict";
1873Object.defineProperty(exports, "__esModule", {
1874    value: true
1875});
18760 && (module.exports = {
1877    ReadonlyURLSearchParams: null,
1878    RedirectType: null,
1879    ServerInsertedHTMLContext: null,
1880    forbidden: null,
1881    notFound: null,
1882    permanentRedirect: null,
1883    redirect: null,
1884    unauthorized: null,
1885    unstable_isUnrecognizedActionError: null,
1886    unstable_rethrow: null,
1887    useParams: null,
1888    usePathname: null,
1889    useRouter: null,
1890    useSearchParams: null,
1891    useSelectedLayoutSegment: null,
1892    useSelectedLayoutSegments: null,
1893    useServerInsertedHTML: null
1894});
1895function _export(target, all) {
1896    for(var name in all)Object.defineProperty(target, name, {
1897        enumerable: true,
1898        get: all[name]
1899    });
1900}
1901_export(exports, {
1902    // We need the same class that was used to instantiate the context value
1903    // Otherwise instanceof checks will fail in usercode
1904    ReadonlyURLSearchParams: function() {
1905        return _hooksclientcontextsharedruntime.ReadonlyURLSearchParams;
1906    },
1907    RedirectType: function() {
1908        return _navigationreactserver.RedirectType;
1909    },
1910    ServerInsertedHTMLContext: function() {
1911        return _serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext;
1912    },
1913    forbidden: function() {
1914        return _navigationreactserver.forbidden;
1915    },
1916    notFound: function() {
1917        return _navigationreactserver.notFound;
1918    },
1919    permanentRedirect: function() {
1920        return _navigationreactserver.permanentRedirect;
1921    },
1922    redirect: function() {
1923        return _navigationreactserver.redirect;
1924    },
1925    unauthorized: function() {
1926        return _navigationreactserver.unauthorized;
1927    },
1928    unstable_isUnrecognizedActionError: function() {
1929        return _unrecognizedactionerror.unstable_isUnrecognizedActionError;
1930    },
1931    unstable_rethrow: function() {
1932        return _navigationreactserver.unstable_rethrow;
1933    },
1934    useParams: function() {
1935        return useParams;
1936    },
1937    usePathname: function() {
1938        return usePathname;
1939    },
1940    useRouter: function() {
1941        return useRouter;
1942    },
1943    useSearchParams: function() {
1944        return useSearchParams;
1945    },
1946    useSelectedLayoutSegment: function() {
1947        return useSelectedLayoutSegment;
1948    },
1949    useSelectedLayoutSegments: function() {
1950        return useSelectedLayoutSegments;
1951    },
1952    useServerInsertedHTML: function() {
1953        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
1954    }
1955});
1956const _interop_require_wildcard = __turbopack_context__.r(151836);
1957const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(271645));
1958const _approutercontextsharedruntime = __turbopack_context__.r(8372);
1959const _hooksclientcontextsharedruntime = __turbopack_context__.r(47790);
1960const _segment = __turbopack_context__.r(813258);
1961const _serverinsertedhtmlsharedruntime = __turbopack_context__.r(13957);
1962const _unrecognizedactionerror = __turbopack_context__.r(292838);
1963const _navigationreactserver = __turbopack_context__.r(592805);
1964const useDynamicRouteParams = typeof window === 'undefined' ? __turbopack_context__.r(67673).useDynamicRouteParams : undefined;
1965const useDynamicSearchParams = typeof window === 'undefined' ? __turbopack_context__.r(67673).useDynamicSearchParams : undefined;
1966const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : {};
1967function useSearchParams() {
1968    useDynamicSearchParams === null || useDynamicSearchParams === void 0 ? void 0 : useDynamicSearchParams('useSearchParams()');
1969    const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
1970    // In the case where this is `null`, the compat types added in
1971    // `next-env.d.ts` will add a new overload that changes the return type to
1972    // include `null`.
1973    const readonlySearchParams = (0, _react.useMemo)(()=>{
1974        if (!searchParams) {
1975            // When the router is not ready in pages, we won't have the search params
1976            // available.
1977            return null;
1978        }
1979        return new _hooksclientcontextsharedruntime.ReadonlyURLSearchParams(searchParams);
1980    }, [
1981        searchParams
1982    ]);
1983    // During build-time instant validation, wrap with an proxy
1984    // so that accessing undeclared search params throws an error.
1985    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1986    ;
1987    // Instrument with Suspense DevTools (dev-only)
1988    if (("TURBOPACK compile-time value", "production") !== 'production' && 'use' in _react.default) //TURBOPACK unreachable
1989    ;
1990    return readonlySearchParams;
1991}
1992function usePathname() {

1993    useDynamicRouteParams === null || useDynamicRouteParams === void 0 ? void 0 : useDynamicRouteParams('usePathname()');
1994    // In the case where this is `null`, the compat types added in `next-env.d.ts`
1995    // will add a new overload that changes the return type to include `null`.
1996    const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
1997    // During build-time instant validation, error if fallback params exist
1998    // because usePathname() can't return a sensible value without all params.
1999    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2000    ;
2001    // Instrument with Suspense DevTools (dev-only)
2002    if (("TURBOPACK compile-time value", "production") !== 'production' && 'use' in _react.default) //TURBOPACK unreachable
2003    ;
2004    return pathname;
2005}
2006function useRouter() {
2007    const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
2008    if (router === null) {
2009        throw Object.defineProperty(new Error('invariant expected app router to be mounted'), "__NEXT_ERROR_CODE", {
2010            value: "E238",
2011            enumerable: false,
2012            configurable: true
2013        });
2014    }
2015    return router;
2016}
2017function useParams() {
2018    useDynamicRouteParams === null || useDynamicRouteParams === void 0 ? void 0 : useDynamicRouteParams('useParams()');
2019    const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
2020    // During build-time instant validation, wrap with a proxy
2021    // so that accessing undeclared params throws an error.
2022    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2023    ;
2024    // Instrument with Suspense DevTools (dev-only)
2025    if (("TURBOPACK compile-time value", "production") !== 'production' && 'use' in _react.default) //TURBOPACK unreachable
2026    ;
2027    return params;
2028}
2029function useSelectedLayoutSegments() {
2030    let parallelRouteKey = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'children';
2031    useDynamicRouteParams === null || useDynamicRouteParams === void 0 ? void 0 : useDynamicRouteParams('useSelectedLayoutSegments()');
2032    const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
2033    // @ts-expect-error This only happens in `pages`. Type is overwritten in navigation.d.ts
2034    if (!context) return null;
2035    // During build-time instant validation, error if fallback params exist
2036    // because useSelectedLayoutSegments() can't return a sensible value without all params.
2037    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2038    ;
2039    // Instrument with Suspense DevTools (dev-only)
2040    if (("TURBOPACK compile-time value", "production") !== 'production' && 'use' in _react.default) //TURBOPACK unreachable
2041    {
2042        var _navigationPromises_selectedLayoutSegmentsPromises;
2043    }
2044    return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
2045}
2046function useSelectedLayoutSegment() {
2047    let parallelRouteKey = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'children';
2048    useDynamicRouteParams === null || useDynamicRouteParams === void 0 ? void 0 : useDynamicRouteParams('useSelectedLayoutSegment()');
2049    const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
2050    const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
2051    // During build-time instant validation, error if fallback params exist
2052    // because useSelectedLayoutSegment() can't return a sensible value without all params.
2053    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
2054    ;
2055    // Instrument with Suspense DevTools (dev-only)
2056    if (("TURBOPACK compile-time value", "production") !== 'production' && navigationPromises && 'use' in _react.default) //TURBOPACK unreachable
2057    {
2058        var _navigationPromises_selectedLayoutSegmentPromises;
2059    }
2060    return (0, _segment.computeSelectedLayoutSegment)(selectedLayoutSegments, parallelRouteKey);
2061}
2062if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
2063    Object.defineProperty(exports.default, '__esModule', {
2064        value: true
2065    });

2066    Object.assign(exports.default, exports);
2067    module.exports = exports.default;
2068}
2069}),
2070]);
2071
2072//# debugId=4d467732-7a3a-0fc2-eb60-78e42c901741